{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "\n", " \n", " \n", " \n", " \n", "\n", "
\n", "

- TD3 -

\n", " 		\n", "

UFR de sociologie et d'informatique pour les sciences humaines

\n", "

Programmation en Python

\n", "
\n", "\n", "-----" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Contrôle du flux d'instructions

\n", "\n", "

Avec if

\n", "\n", "Pour exécuter une suite d'instructions relativement à une condition, __*Python*__ propose l'instruction **if**.\n", "\n", "La structure **if** _condition_ (*si condition*) est une instruction composée, c'est-à-dire qu'elle se termine obligatoirement par deux points (**:**) et débute un bloc d'instructions indentés.\n", "\n", "

Exemple 1

\n", "\n", "```python\n", " text = 'bus'\n", " if 'u' in text: # notez les 2 points\n", " print(text, \"contient la lettre u\")\n", "```\n", "La condition _'u' in text_ étant vraie (True), la ligne qui contient le _print()_ sera exécutée. Si la variable *string* _text_ contenait *car*, la condition étant fausse (False), le ligne où figure le _print()_ ne serait pas exécutée.\n", "\n", "

Exemple 2

\n", "\n", "Quelle différence entre les deux programmes qui suivent ?\n", "\n", "```python\n", " text = 'chien' # prog 1\n", " if 'u' in text:\n", " print(text, \"contient la lettre u\")\n", " print('FIN du programme')\n", "```\n", "et\n", "\n", "```python\n", " text = 'loup' # prog 2\n", " if 'u' in text:\n", " print(text, \"contient la lettre u\")\n", " print('FIN du programme')\n", "```\n", "\n", "Dans le $1^e$ cas, la dernière ligne fait partie du bloc d'instructions initié par le **if**. Il ne sera donc exécuté que si la condition du **if** est *True*.\n", "\n", "Dans le $2^e$ cas, la dernière ligne est toujours exécutée quelque soit la valeur booléenne de la condition, elle ne fait pas partie du bloc d'instructions initié par le **if**.\n", "\n", "> **Exercice** | Observez le programme suivant et devinez ce qui va être affiché à l'écran à son exécution. Vérifiez-le ensuite seulement en exécutant le programme.\n", " \n", "> Modifiez ensuite le programme pour qu'il affiche les lignes 7 et 8 seulement et vérifiez-le en exécutant le programme" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "t = 'sanglier'\n", "if 'g' in t:\n", " print('le mot', t, 'contient la lettre g')\n", " print('FIN - 1')\n", "if 'w' in t:\n", " print('le mot', t, 'contient la lettre w')\n", " print('FIN - 2')\n", "print('FIN - 3')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Rédigez un programme qui demande d'entrer un mot au clavier et si ce mot comporte un 'e', le programme écrit \"le mot contient au moins une voyelle\" et si le mot ne contient pas 'e', il affiche \"Pas de 'e' !\"" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Rédigez un programme qui demande d'entrer un mot au clavier et si ce mot comporte une voyelle ('aeiouy'), le programme écrit \"le mot contient au moins une voyelle\" et si le mot ne contient pas de voyelle, il affiche \"mot rare !\"" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Avec if et else

\n", "\n", "La condition **if** *condition*, si elle n'est pas réalisée, prévoit une instruction complémentaire **else** (*sinon*) qui permet d'exécutez des instructions par défaut.\n", "\n", "**else** est aussi une instruction composée, elle nécessite les 2 points (:) à sa suite et débute une identation des instructions qui suivent.\n", "\n", "

Exemple

\n", "\n", "```python\n", " phrase = \"le chien court vers le chat\"\n", " if \"chien\" in phrase:\n", " print(\"la phrase contient le mot chien\")\n", " else: # notez les 2 points après else\n", " print(\"Pas de chien dans la phrase !\")\n", "```\n", "\n", "Dans cet exemple, si le mot *'chien'* figure dans la variable *string*, la ligne 3 sera exécutée, sinon ce sera la ligne 5 qui sera exécutée.\n", "\n", "> **Exercice** | Rédigez un programme qui demande à l'utilisateur son sexe (la réponse sera : H ou F) et qui affiche \"Bonjour Monsieur\" ou \"Bonjour Madame\" selon le cas.\n", "." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Rédigez un programme qui demande d'entrer un mot au clavier et si ce\n", "mot contient une des lettres 'e', 'm' ou 't', le programme affiche 'Gagné !', sinon il affiche 'Perdu !'.\n", "" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Avec if, elif et else

\n", "\n", "Le paragraphe précédent n'envisageait que 2 cas. C'était une situation dichotomique. On peut être amené à traiter plusieurs cas. __*Python*__ a prévu cette siituation avec l'instruction **elif**, qui signifie *sinon si*.\n", "\n", "Imaginez une cible circulaire dans un jeu de fléchette. Si la flèche se plante \n", "- à 2 cm ou moins du centre, on gagne 10 €,\n", "- si elle se plante entre 2 cm et 10 cm on gagne 5 €\n", "- et si elle se plante à 10 cm ou plus du centre, alors on perd !\n", "\n", "Le programme pourrait être le suivant : (Exécutez ce code avec plusieurs valeurs différentes en entrée)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "gain = 0\n", "d = eval(input(\"Distance de la flèche au centre : \"))\n", "if d <= 2: # si la distance est inférieure à 2\n", " gain = 10\n", "elif d >= 10: # sinon si la distance est supérieure à 10\n", " print(\"Perdu !\")\n", "else: # sinon\n", " gain = 5" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | On considère qu'il y a 3 types de mots : les mots *courts* (longueur inférieure ou égale à 5 caractères), les mots *longs* (longueur supérieure ou égale à 11 caractères) et les mots *intermédiaires*.\n", "\n", "> Écrivez un programme ci-dessous, qui demande d'entrer un mot au clavier et qui affiche la catégorie auquel il appartient : court, intermédiare ou long" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Écrivez un programme qui demande à l'utilisateur son sexe (F pour femme et H pour homme) et sa situation matrimoniale (M pour marié et C pour célibataire) et qui affiche : \"Bonjour Monsieur ou Madame ou Mademoiselle...\" selon le cas (astuce : l'homme marié ou pas est toujours monsieur, donc\n", "à traiter d'abord)." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Avec plusieurs cas cette fois...\n", "> **Exercice** | Écrivez un programme qui demande une note obtenue à un examen. Ensuite il affiche \"TB\" si la note est supérieure ou égale à 16 , écrit \"B\" si la note est comprise entre 14 et inférieure à 16 (peut être égale à 14), \"AB\" si la note est comprise entre 12 et inférieure à 14 (peut être égale à 12), \"Passable\" si la note est comprise entre 10 et inférieure à 12 (peut être égale à 10), et \"Refus\" si la note est inférieure à 10. (Traitez les conditions dans l'ordre)." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Travailler avec des prédicats

\n", "\n", "les conditions qui se trouvent entre **if** (ou le **elif** ) et les deux points (**:**) sont appelés des *prédicats*.\n", "Ces *prédicats* sont *True* ou *False* selon le cas.\n", "Vous pouvez tester directement ces prédicats dans une cellule d'un notebook. \n", "\n", "> **Exercice** | Essayez un à un les prédicats suivants dans la cellule de code ci-dessous et notez ce que **_Python_** renvoie.\n", " \n", "```python\n", " 5 < 13 # correspond à 5 est-il inférieur à 13\n", " 3 * 2 == 7 # 3 * 2 est-il égal à 7\n", " 'a' < 'z' # ordre lexicographique\n", " 'alabama' > 'arthur' # Python traite les lettres dans l'ordre par comparaison\n", "```" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Une variable booléenne qui est _True_ **suffit à valider une condition**.\n", "\n", "> **Exercice** | Observez et exécutez le programme ci-dessous." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "statut = False # variable booléenne à False au départ\n", "age = eval(input('Donne ton âge : '))\n", "if age >= 18:\n", " statut = True\n", "# ensuite on traite cette variable\n", "if statut: # on peut écrire (inutile) if statut == True\n", " print('Majeur')\n", "else:\n", " print('Mineur')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Sachez que pour les entiers :\n", "- 0 est False, 1 est True\n", "pour les strings\n", "- '' (chaîne vide) est False\n", "\n", "> **Exercice** | Qu'affiche le programme suivant (exécutez-le pour vérifier) ? Modifiez-le pour qu'il affiche 7, puis remodifiez-le pourqu'il affiche 9." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "nb = 5\n", "print(7 * (nb < 10) + 9 * (nb > 4))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Les mots-clés and, or et not

\n", "\n", "**and**, **or** et **not** sont des opérateurs booléens qui signifient respectivement _et_, _ou_ et _non_ (négation).\n", "\n", "- **and** se place entre deux conditions que l'on veut vraies en même temps pour que l'ensemble soit vrai.\n", "- **or** est dit 'inclusif' c'est-à-dire qu'il se place entre deux conditions dont l'une d'elles doit être vraie, ou les deux vraies à la fois pour que l'ensemble soit vrai.\n", "- **not** s'emploie pour faire la négation d'un booléen. Si un booléen est vrai, alors not(le booléen) est faux, et si le booléen est faux, alors not(le booléen) est vrai.\n", "\n", "

Exemple

\n", "\n", "- $a < 9$ and $a > 5$ signifie que $a$ doit être compris entre $5$ et $9$ pour que la condition soit vraie.\n", "\n", "- $a > 4$ or $a < 7$ signifie que $a$ doit être plus grand que $4$ ou plus petit que $7$ ou les deux\n", "à la fois pour que la condition soit vraie.\n", "\n", "- not($a < 9$) signifie que $a$ doit être plus grand ou égal à $9$ pour que la condition soit vraie.\n", "\n", "> **Exercice** | Écrivez un programme qui affiche le gain obtenu en lançant deux pièces selon la règle suivante : si on obtient 2 \"pile\" ou 2 \"face\", on gagne 10 euros et si on obtient deux faces différentes, on perd 5 euros.\n", "." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Écrivez un programme qui demande d'entrer un mot au clavier et...\n", "- si le mot comporte un 'e' et un 'r' il écrit '*cas 1*',\n", "- si le mot comporte un 'u' ou un 'n' il écrit '*cas 2*' et\n", "- si le nombre ne comporte pas de 's' il écrit '*cas 3*'.\n", "Essayez ensuite avec différents mots pour faire apparaître les divers cas." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Les boucles

\n", "\n", "Avec un programme, si l'on veut épeler les lettres l'alphabet français et les écrire, on peut (bêtement) écrire ceci...\n", "\n", "```python\n", " print('a')\n", " print('b')\n", " print('c')\n", " # etc. etc. etc.\n", "```\n", "\n", "Les tâches répétitives sont du ressort des **boucles** ! Elles sont là pour énormément raccourcir le code.\n", "\n", "Voici le même programme écrit de meilleure façon.\n", "\n", "```python\n", " for let in 'abcdefghijklmnopqrstuvwxyz':\n", " print(let)\n", "```\n", "\n", "La boucle initiée ici par l'instruction **for** va faire que la variable **let** va prendre tour à tour pour valeur chacune des lettres de la chaîne et l'écrire. **for** est aussi une instruction composée.\n", "\n", "Vous allez voir les différents usages des boucles\n", "\n", "

Avec for et range()

\n", "\n", "l'instruction **range()** est surtout là pour aider à énumérer des listes d'entiers, elle prépare la liste que **for** va parcourir... La syntaxe de **range()** est la suivante :\n", "\n", "range(début, fin à ne pas atteindre, pas)\n", "\n", "- début donne l'entier de \"départ\"\n", "- le deuxième entier n'est jamais atteint\n", "- la pas est la succession de \"saut\"\n", "\n", "

Exemple

\n", "\n", "```python\n", " suc = range(3, 9, 2) # signifie la succession des entiers de 3 à avant 9 par saut de 2\n", "```\n", "La variable *suc* peut ensuite être parcouru avec l'instruction **for** qui permet ici de parcourir la séquence d'entiers générée par *range()*\n", "\n", "```python\n", " for n in suc:\n", " print(n)\n", "```\n", "\n", "Par défaut\n", "\n", "```python\n", " for n in range(5): # donne les entiers de 0 à 4 (il y en a 5)\n", " print(n)\n", "```\n", "\n", "> **Exercice** | Exécutez chacune des cellules qui suivent en devinant auparavant ce qui va apparaître." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "for i in range(3):\n", " print(i)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "for i in range(2, 5):\n", " print(i)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "for i in range(5, 19, 5):\n", " print(i)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "for i in range(11, 5, -2):\n", " print(i)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Écrivez un court programme qui compte à rebours de 10 à 0 (n'oubliez pas que le 2e entier de *range()* n'est jamais atteint)." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Écrivez un court programme qui affiche la phrase \"je compte jusqu'à 1\", puis \"je compte jusqu'à 2\", ceci jusqu'à \"je compte jusqu'à 10\"." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Écrivez un programme qui demande un entier entre 1 et 10 et qui affiche la table de multiplication de cet entier." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Énumération d'éléments avec for

\n", "\n", "Ce que l'on fait avec des séquences d'entiers, on le fait aussi avec des séquences de lettres, c'est-à-dire des chaînes de caractères.\n", "\n", "

Exemple

\n", "\n", "```python\n", " mot = 'corbeau'\n", " for lettre in mot:\n", " print(lettre) # écrit successivement chacune des lettres du mot 'corbeau'\n", "```\n", "\n", "**_Python_** a prévu encore mieux !\n", "\n", "Si vous voulez énumérer chaque lettre avec en plus sa position, par exemple vous voulez écrire un programme qui écrit, pour chaque lettre :\n", "\n", "\"la lettre X est la XXe lettre\" où X est la lettre et XX sa position dans la chaîne.\n", "\n", "L'instruction **enumerate** est là pour cela, elle s'emploie en liaison avec **for**. **enumerate** récupère à la fois le rang et la lettre.\n", "\n", "

Exemple

\n", "\n", "```python\n", " mot = 'corbeau'\n", " for pos, let in enumerate(mot): # notez que l'indice est en 1e\n", " print('la lettre', let, \"est la\", pos+1, \"lettre\") # 1e indice est 0, donc pos+1 pour le rang\n", "```\n", "\n", "> **Exercice** | Écrivez un programme qui compte le nombre de voyelles dans un phrase récupérée au clavier. Vous utiliserez une structure conditionnelle avec la variable *voyelle* = \"aeiouy\".\n", "" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Écrivez un programme qui affiche les voyelles et leur position (indice) dans une phrase entrée au clavier. Le programme doit afficher :\n", "- voyelle e trouvée à l'indice 3\n", "- voyelle a trouvée à l'indice 7\n", "- etc.\n", "" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Imaginez deux variables *a* et *b* de type *string* de même longueur qui contiennent chacune une suite aléatoire (plus ou moins) de 0 et de 1. On veut comparer ces 2 chaînes terme à terme et comptez le nombre de 1 alignés (même valeur 1 et même rang). Écrivez un tel programme ci-dessous.\n", "" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Avec while

\n", "\n", "On rappelle que le rôle des boucles est d'itérer (de répéter) un bloc d'instructions, soit un nombre\n", "précis de fois, soit relativement à une condition. Une boucle réalisée avec **while** assure les deux possibilités.\n", "\n", "**while** initie donc une boucle et c'est aussi une instruction composée.\n", "\n", "

Répéter un nombre de fois précis

\n", "\n", "Si l'on veut répéter un certain nombre de fois quelque chose, il faut un *compteur*, c'est-à-dire une\n", "variable qui va assurer le rôle de compter le nombre de répétition.\n", "\n", "

Exemple

\n", "\n", "```python\n", " compt = 1\n", " while compt <= 10: # de 1 à 10 soit 10 fois la boucle\n", " print('répétition numéro', compt) # on utilise ici la valeur du compteur\n", " print('FIN') # la boucle est finie, FIN s'affiche\n", "```\n", "\n", "**Remarque** : la variable *compt* est définie à un niveau supérieur à celui de la boucle, donc sera\n", "*visible* dans la boucle.\n", "\n", "> **Exercice** | Écrivez un programme qui affiche 5 fois (avec *while*) le mot 'coucou'." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Écrivez un programme qui affiche sur la 1e ligne une étoile (\\*), deux étoiles sur la 2e, 3 sur la 3e et ainsi de suite jusqu'à 10 étoiles (rappel _'ha' \\* 3_ donne *hahaha*)." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Répéter relativement à une condition

\n", "\n", "On peut utiliser la boucle **while** quand on ne sait pas a priori combien de fois la boucle va être parcourue. Imaginez un programme qui demande d'entrer des nombres entiers un par un au clavier jusqu'à ce que la lettre 'f' (comme fin) soit entrée. Le programme affiche alors la moyenne des nombres entrés. Le programme pourrait être celui ci-dessous.\n", "\n", "

Exemple

\n", "\n", "```python\n", " somme, nb, n = 0, '', 0\n", " while nb != 'f': # tant que l'entrée n'est pas 'f'\n", " nb = input(\"Entre un entier : \")\n", " if nb.lower() != 'f':\n", " somme += eval(nb) # on ajoute le nb entré à somme\n", " n += 1 # un nombre entré de plus...\n", " print(\"Moyenne :\", somme/n)\n", " \n", "```\n", "\n", "> **Exercice** | Écrivez un programme qui demande d'entrer un mot au clavier. Ensuite, à l'aide d'une boucle *while*, affichez la 1e lettre du mot, puis les 2 premières, puis les 3 premières, etc. sur une ligne chaque fois (rappel *len()* est la fonction qui donne la longueur d'un *string*)." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Écrivez un programme qui demande de façon cyclique d'entrer un mot au clavier et qui affiche le mot à chaque fois qu'il rencontre une voyelle et ainsi de suite. Si le mot est une chaîne vide, le programme s'arrête (ce programme utilise *while* et *for*)." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Sortir d'une boucle...

\n", "\n", "**_Python_** a prévu de pouvoir sortir d'une boucle **for** ou **while** au beau milieu de celle-ci. L'instriction **break** est là pour cela.\n", "\n", "Voici deux exemples d'utilisation.\n", "\n", "

Exemple 1

\n", "\n", "Ici on sort de la boucle dès que la variable *val* atteint la valeur 7.\n", "\n", "```python\n", " for val in range(15):\n", " print(val)\n", " if val == 7:\n", " break\n", " print('FIN')\n", "```\n", "\n", "\n", "

Exemple 2

\n", "\n", "Ici on sort de la boucle dès que la variable *mot[indice]* est la voyelle 'a'\n", "\n", "```python\n", " mot, indice = 'crash', 0\n", " while indice < len(mot): # tant que l'indice est inférieur à la longueur du mot\n", " if mot[indice] == 'a':\n", " break\n", " print(mot[indice])\n", " indice += 1\n", " print('FIN')\n", "```\n", "\n", "> **Exercice** | Écrivez un programme qui demande d'entrer des mots au clavier et qui affiche ces mots à l'envers, le programme s'arrête si le mot entré est 'stop'." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Écrivez un programme qui, pour un mot entré au clavier, affiche l'un en-dessous les lettres qui composent ce mot mais qui s'arrête dès que la lettre est une voyelle parmi \"a\" ou \"o\" ou \"u\"." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# FIN du TD3" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.3" } }, "nbformat": 4, "nbformat_minor": 4 }