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

- TD4 -

\n", "

M. Vincent

\n", " 		\n", "

UFR de sociologie et d'informatique pour les sciences humaines

\n", "

Programmation en Python

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

Fonctions et conteneurs

\n", "\n", "

Les fonctions

\n", "\n", "Rappel : les *fonctions* ont pour but de regrouper plusieurs instructions dans un \"bloc\" qui est\n", "appelé ensuite (aussi souvent que nécessaire) grâce au nom de la fonction, nom que vous choisissez hors de la liste des mots réservés et des mots qui penven amener à confusion comme *type*, *print*, *input*, ...\n", "\n", "Pour définir soi-même une fonction, voici quelques points...\n", "\n", "- le mot clé qui débute la définition d'une fonction est **def**\n", "- le nom de la fonction est choisi par vous, donnez un nom en rapport avec la finalité de la fonction. Par exemple, une fonction dont le rôle est de calculer la longueur d'une phrase peut s'appeler *longphrase()*.\n", "- les *paramètres* ne sont pas obligatoires (cela dépend de ce que fait la fonction), mais les parenthèses ouvrante et fermante le sont.\n", "- **def** est le mot-clé pour définir une fonction. C'est une instruction composée donc la ligne se termine par 2 points et une indentation commence ensuite. Elle se termine à la fin de la définition de la fonction.\n", "- Une fonction peut appeler une ou plusieurs autres fonctions dans sa définition.\n", "\n", "\n", "

Exemple générique

\n", "\n", "```python\n", " def mafonction(arg):\n", " xxxxxxxxxxxxxxxxxxxxxxxxx\n", " xxxxxxxxx\n", " xxxxxxxxxxxxxxx\n", "```\n", "\n", "où *arg* est un argument inexistant, simple ou multiple *passé en paramètre* : si *arg* existe, cela signifie que la fonction a besoin de connaître la valeur de *arg* dans son code.\n", "\n", "

Exemple de fonction qui affiche la longueur d'un mot

\n", "\n", "```python\n", " def longmot(m): # m est un mot qui sera fournit à la fonction\n", " l = len(m) # calcule la longueur\n", " print(\"Le mot\", m, \"a pour longueur\", l) # affichage\n", "```\n", "\n", "

Exemple de fonction qui affiche si un mot $m$ est dans une phase $p$

\n", "\n", "```python\n", " def trouve(m, p): # ici 2 paramètres m et p\n", " ok = m in p # ok est True ou False\n", " if ok:\n", " print(\"Le mot\", m, \"est dans :\", p)\n", " else:\n", " print(m, \"n'est pas dans\", p)\n", "```\n", "\n", "Pour utiliser ces fonctions dans un programme, on peut par exemple écrire le code suivant :\n", "\n", "```python\n", " m = input(\"Donne un mot : \")\n", " p = input(\"Entre une phrase : \")\n", " longmot(m) # appel de la fonction logmot()\n", " trouve(m, p) # appel de la fonction trouve()\n", "```\n", "\n", "> **Exercice** | Définissez ci-dessous une fonction de nom *salut()* qui affiche simplement \"Bonjour !\" à chaque fois qu'elle est appelée (complétez pour cela le code ci-dessous). Exécutez-la." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Bonjour !\n" ] } ], "source": [ "def salut(): # définition de la fonction\n", " print(\"Bonjour !\")\n", " # attention à l'identation\n", "############################ on laisse une ligne entre la définition et la suite...\n", "salut() # appel de la fonction" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Définissez ci-dessous une fonction de nom *derlettre()* qui affiche la dernière lettre d'un mot fourni en argument. Exécutez-la avec le mot *pingouin*, puis avec le mot *kiwi*." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "n\n", "i\n" ] } ], "source": [ "def derlettre(mot):\n", " der = mot[-1] # récupère la dernière lettre\n", " print(der) # et l'affiche\n", " \n", "derlettre(\"pingouin\")\n", "derlettre(\"kiwi\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Définissez ci-dessous une fonction de nom *bilan()* qui affiche la première et dernière lettre d'un mot fourni en argument (sans utiliser la fonction précédente). Exécutez-la avec le mot *pingouin*, puis avec le mot *kiwi*." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "p n\n", "k i\n" ] } ], "source": [ "def bilan(mot):\n", " der = mot[-1]\n", " prem = mot[0]\n", " print(prem, der)\n", "\n", "bilan(\"pingouin\")\n", "bilan(\"kiwi\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Même exercice que le précédent mais en utilisant la fonction *derlettre()* précédemment définie. Exécutez-la avec le mot *pingouin*, puis avec le mot *kiwi*." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "p n\n", "k i\n" ] } ], "source": [ "def bilan(mot):\n", " prem = mot[0]\n", " print(prem, end=\" \") # attention, la fonction derlettre comporte déjà un print()\n", " derlettre(mot) # on ne peut pas avoir print(print(...)), on obtient None (=rien)\n", " \n", "bilan(\"pingouin\")\n", "bilan(\"kiwi\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

L'instruction return

\n", "\n", "Vous avez vu des fonctions propres au langage Python , certaines qui ne renvoient aucune valeur comme *print()* qui se contente d'afficher son argument, d'autres comme *input()* qui permettent de récupérer une donnée entrée au clavier. On dit alors que la fonction *input()* renvoie une donnée. On écrit : \n", "\n", "```python\n", " a = input(\"Entre un mot : \")\n", "```\n", "\n", "et la variable **a** récupère ce qui est entré au clavier. Vous pouvez avec une fonction définie par vous-même, récupérer une valeur en sortie. La commande *return* est là pour cela.\n", "\n", "Exécutez les lignes suivantes :" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "def triple(mot):\n", " return 3 * mot\n", "\n", "def double(mot):\n", " return 2 * mot" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "On peut ensuite appeler ces fonctions dans des lignes de code.\n", "\n", "Exécutez les lignes suivantes :" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "louplouploup\n", "veauveau\n" ] } ], "source": [ "print(triple(\"loup\"))\n", "print(double(\"veau\"))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "On peut même encapsuler une fonction dans une autre.\n", "\n", "Exécutez les lignes suivantes :" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "coqcoqcoqcoqcoqcoq\n" ] } ], "source": [ "print(triple(double(\"coq\"))) # c'est-à-dire 6 fois coq" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " En général on évite de mettre des *print()* dans une fonction. Il est préférable d'appeler une fonction avec un *print()* extèrieure à la définition de cette fonction, comme dans la cellule précédente.\n", "\n", "> **Exercice** | Définissez une fonction de nom *nbVoy()* qui prend en argument une phrase *p* et qui renvoie le nombre de voyelles contenues. Exécutez-la avec la phrase \"*le chien court vers le chat qui miaule*\". Le début a été écrit..." ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "La phrase : le chien court vers le chat qui miaule , comporte 14 voyelle(s)\n" ] } ], "source": [ "voyelles = \"aeiouy\"\n", "phrase = \"le chien court vers le chat qui miaule\"\n", "def nbVoy(p):\n", " nbvoy = 0 # au débur, 0 voyelle, initialisation\n", " for l in p: # pour chaque lettre de p\n", " if l in voyelles: # si la lettre est une voyelles\n", " nbvoy = nbvoy + 1 # on peut écrire aussi nbvoy += 1\n", " return nbvoy\n", " \n", "print(\"La phrase :\", phrase, \", comporte\", nbVoy(phrase), \"voyelle(s)\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Suite de l'exercice précédent. Définissez une fonction de nom *compareMots()* qui prend en argument 2 mots et qui renvoie celui qui a le plus de voyelles. Utlisez la fonction *nbVoy()*. L'essayer avec les 2 mots \"ananas\" et \"pomme\"." ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "ananas\n" ] } ], "source": [ "voyelles = \"aeiouy\" # je redéfinie voyelles (pas obligatoire, déjà fait au-dessus)\n", "def compareMots(m1, m2): # prend 2 mots en argument\n", " nb1 = nbVoy(m1)\n", " nb2 = nbVoy(m2)\n", " if nb1 > nb2:\n", " print(m1)\n", " elif nb1 < nb2:\n", " print(m2)\n", " else:\n", " print(m1, m2)\n", "\n", "compareMots(\"ananas\", \"pomme\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Définissez une fonction de nom *inv()* qui prend en argument un mot et qui renvoie le même mot mais écrit à l'envers. Par exemple *inv(\"lapin\") renvoie *nipal\" (épelez le mot lettre par lettre pour le reconstituer à l'envers)" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'nipal'" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def inv(mot):\n", " tom = \"\"\n", " for l in mot: # pour chaque lettre du mot\n", " tom = l + tom # on colle la lettre à gauche à chaque fois cou -> uoc\n", " return tom\n", "\n", "inv(\"lapin\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Vous allez ci-dessous écrire un programme qui chiffre un message, grâce à la fonction *inv()* précédente. Par exemple la phrase \"*le chat attrape la souris*\" sera codé \"*el tahc epartta al sirous*\" (vous aurez intérêt à traîter chaque mot en vous basant sur les espaces dans une 1e temps, en inversant chaque mot et à reconstituer la phrase codée simultanément)\n", "1. Codez la phrase \"* le covid est incidieux et nous cause problème *\"\n", "2. Décodez la phrase \"* el tahc tse étnom rus al elbat \"" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "el divoc tse xueidicni te suon esuac emèlborp \n", "le chat est monté sur la table \n" ] } ], "source": [ "p = \" le covid est incidieux et nous cause problème \"\n", "pcode = \"\"\n", "mot = \"\"\n", "for c in p:\n", " if c == \" \": # si on trouve une espace, on remet à vide le mot\n", " pcode = pcode + inv(mot)\n", " mot = \"\"\n", " mot = mot + c\n", "print(pcode)\n", "# le même programme sert aussi à décoder\n", "p = \" el tahc tse étnom rus al elbat \"\n", "pcode = \"\"\n", "mot = \"\"\n", "for c in p:\n", " if c == \" \": # si on trouve une espace, on remet à vide le mot\n", " pcode = pcode + inv(mot)\n", " mot = \"\"\n", " mot = mot + c\n", "print(pcode)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Les listes avec Python

\n", "\n", "**Généralités**\n", "\n", "Les listes sont des objets qui peuvent en contenir d'autres : nombres, chaîne de caractères, listes,\n", "etc. Une liste peut être donc constituée d'objets hétérogènes.\n", "\n", "Une liste est un *itérable* , de la même façon qu'une chaîne de caractères contient une séquence de\n", "lettres, que l'on peut donc parcourir par une boucle.\n", "\n", "Une liste se note entre crochets et les éléments sont séparés par une virgule.\n", "\n", "Tapez et exécutez (notez les résultats) :" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['l', 'a', 'p', 'i', 'n']\n", "[0, 1, 2, 3, 4, 5, 6, 7]\n" ] } ], "source": [ "L0 = [] # liste vide, on peut ensuite la modifier\n", "maliste = list('lapin') # trandforme une chaîne en une liste de lettres\n", "print(maliste)\n", "taliste = list(range(8)) # range() est utile pour les listes de nombres\n", "print(taliste)\n", "L1 = [2, \"rat\", [1, 3, 7], -5.8] # 4 éléments : un entier, une chaîne, une liste, un float" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "La liste L1 précédente contient 4 éléments (comme énoncé). Pour le savoir, il suffit d'exécuter (faites-le)" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "4\n" ] } ], "source": [ "print(len(L1))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Accès aux éléments de la liste**\n", "\n", "Comme pour une chaîne de caractères, chaque élément de la liste est accessible grâce à son indice.\n", "\n", "Si\n", "\n", "```python\n", " liste = ['car', 34, 'pin', 3.14]\n", "```\n", "alors\n", "```python\n", " print(liste[0])\n", " print(liste[3])\n", "```\n", "renvoie\n", "```python\n", " car\n", " 3.14\n", "```\n", "Si une liste contient elle-même une liste comme par exemple\n", "```python\n", " L1 = [7, 'cool', [2, 'e', 'f']]\n", "```\n", "pour accéder au $1^e$ élément de la sous-liste, qui est elle-même le $3^e$ élément de L1, il faut écrire\n", "```python\n", " print(L1[2][0])\n", "```\n", "qui renvoie\n", "```python\n", " 2\n", "```\n", "La notation crochet et l'opérateur : permettent les mêmes accès que pour une chaîne de caractères. Les mêmes opérations de **slicing** sont possibles.\n", "\n", "Éxécutez les lignes suivantes et notez attentivement les résultats :" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "e\n", "[5, 'e', 'g']\n", "[1, 5, 'e', 'g']\n", "['g', 'a', 8, 'z']\n", "[1, 5, 'e', 'g', 'a', 8, 'z']\n", "z\n", "['g', 'a', 8]\n", "[5, 'g', 8]\n", "['z', 8, 'a', 'g', 'e', 5, 1]\n" ] } ], "source": [ "L2 = [1, 5, 'e', 'g', 'a', 8, 'z']\n", "print(L2[2])\n", "print(L2[1 : 4]) # notez que l'on coupe avant L2[4]\n", "print(L2[ : 4])\n", "print(L2[3 : ])\n", "print(L2[ : ])\n", "print(L2[-1])\n", "print(L2[-4 : -1])\n", "print(L2[1 : 6 : 2]) # de 2 en 2\n", "print(L2[-1 : -8 : -1]) # à l'envers, de -1 à avant -8 (soit -7) par pas de -1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Parcourir une liste avec une boucle**\n", "\n", "On peut parcourir une liste à l'aide d'une boucle de 3 façons.\n", "\n", "**Avec while** qui oblige à utiliser un compteur et surveiller quand on atteint le fin de la liste. Exécutez la cellule ci-dessous :" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1\n", "5\n", "e\n", "g\n", "a\n", "8\n", "z\n" ] } ], "source": [ "k = 0\n", "long = len(L2)\n", "while k < long: # tant que l'on a pas atteint la fin de la liste\n", " print(L2[k]) # affiche chaque élément\n", " k += 1 # équivaut à k = k + 1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Avec for** qui est le plus efficace mais qui ne permet pas de savoir à quel indice on est... \n", "\n", "Exécutez la cellule ci-dessous :" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1\n", "5\n", "e\n", "g\n", "a\n", "8\n", "z\n" ] } ], "source": [ "for elt in L2:\n", " print(elt)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Avec for et enumerate()** qui permet d'être efficace et de récupérer au passage l'indice.\n", "\n", "Exécutez la cellule ci-dessous :" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Indice: 0 Élément: 1\n", "Indice: 1 Élément: 5\n", "Indice: 2 Élément: e\n", "Indice: 3 Élément: g\n", "Indice: 4 Élément: a\n", "Indice: 5 Élément: 8\n", "Indice: 6 Élément: z\n" ] } ], "source": [ "for ind, elt in enumerate(L2): # notez que l'indice est en premier\n", " print(\"Indice:\", ind, \"Élément:\", elt)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Manipulation des listes**\n", "\n", "**Remplacement d'élément** : contrairement aux chaînes de caractères, il est ici possible de remplacer un élément par un autre.\n", "\n", "Exécutez" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[123, 'bcd', 'xy', 'z', 'mon']\n" ] } ], "source": [ "L3 = ['a', 'bcd', 'xy', 'z', 'mon']\n", "L3[0] = 123 # on remplace le 1e élément par le nombre 123\n", "print(L3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ajout d'élement** : à la droite de la liste\n", "\n", "\n", "Exécutez" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[123, 'bcd', 'xy', 'z', 'mon', 'ttt', 777]\n" ] } ], "source": [ "L3.append('ttt')\n", "L3.append(777)\n", "print(L3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Insérer un élément à une place** : on désigne l'indice en $1^e$, suivi de l'élément à insérer. Attention il ne s'agit pas d'un remplacement.\n", "\n", "Exécutez" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[123, 'bcd', 'lapin', 'xy', 'z', 'mon', 'ttt', 777]\n" ] } ], "source": [ "L3.insert(2, \"lapin\")\n", "print(L3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Détruire un élément** : on désigne l'indice de l'élément à détruire\n", "\n", "Exécutez" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[123, 'bcd', 'xy', 'z', 'mon', 'ttt', 777]\n" ] } ], "source": [ "del(L3[2])\n", "print(L3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Récupérer un indice** : si on veut détruire un élément particulier par exemple, il faut connaître son indice. On peut aussi spécifier la plage de recherche." ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [], "source": [ "indice = L3.index('ttt') # on pouvait écrire L3.index('ttt', 2, 5) pour chercher entre ces 2 indices\n", "del(L3[indice]) # détruit l'élément 'ttt'" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Concaténer des listes** : 2 façons de faire\n", "\n", "Exécutez les 2 cellules suivantes et observez" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['e', 'd', 1, 7, 9]\n" ] } ], "source": [ "L1 = ['e', 'd']\n", "L2 = [1, 7, 9]\n", "L = L1 + L2\n", "print(L)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "ou" ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1, 2, 5, 7, 9, 11]\n" ] } ], "source": [ "L1 = [1, 2, 5]\n", "L2 = [7, 9, 11]\n", "L1.extend(L2)\n", "print(L1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "La méthode **extend** peut être utile pour de plus transformer l'ajout (ici une chaîne) en une liste. Par exemple\n", "\n", "Exécutez" ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['a', 'b', 'c', 'd', 'e', 'f']\n" ] } ], "source": [ "L1 = ['a', 'b', 'c']\n", "L1.extend('def')\n", "print(L1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Récupérer le nombre d'occurence** d'un élément\n", "\n", "Exécutez" ] }, { "cell_type": "code", "execution_count": 41, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "4\n" ] } ], "source": [ "L = [2, 1, 6, 5, 2, 7, 2, 8, 9, 2, 3]\n", "print(L.count(2)) # récupère le nombre de 2 contenus dans L" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Supprimer** la $1^e$ occurrence trouvé d'un élément (lecture de gauche à droite)\n", "\n", "Exécutez" ] }, { "cell_type": "code", "execution_count": 42, "metadata": {}, "outputs": [], "source": [ "L = ['a', 'e', 'u', 'a', 'e', 'o']\n", "L.remove('e')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "On peut aussi supprimer un élément et le récupérer à la volée.\n", "\n", "Exécutez" ] }, { "cell_type": "code", "execution_count": 47, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "c\n" ] } ], "source": [ "L = ['a', 'c', 'f']\n", "recup = L.pop(1)\n", "print(recup)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Si on ne précise pas le paramètre de pop(), il récupère le dernier élément.\n", "\n", "Exécutez" ] }, { "cell_type": "code", "execution_count": 48, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "q\n" ] } ], "source": [ "L = [6, 's', 'h', 'q']\n", "recup = L.pop()\n", "print(recup)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Supprimer tous les éléments** : la liste est vide ensuite mais est toujours présente.\n", "\n", "Exécutez" ] }, { "cell_type": "code", "execution_count": 49, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[]\n" ] } ], "source": [ "L = [6, 's', 'h', 'q']\n", "L.clear()\n", "print(L)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ordonner** une liste. La liste est modifiée en place.\n", "\n", "Exécutez" ] }, { "cell_type": "code", "execution_count": 50, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['d', 'e', 'o', 'p', 'z']\n" ] } ], "source": [ "L = ['d', 'z', 'e', 'o', 'p']\n", "L.sort()\n", "print(L)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Renverser une liste** : l'ordre des éléments est renversé en place.\n", "\n", "Exécutez" ] }, { "cell_type": "code", "execution_count": 51, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['p', 'o', 'e', 'z', 'd']\n" ] } ], "source": [ "L = ['d', 'z', 'e', 'o', 'p']\n", "L.reverse()\n", "print(L)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Découpez et recoller** une chaîne de caractères.\n", "\n", "Exécutez" ] }, { "cell_type": "code", "execution_count": 52, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "L1: ['le', 'lapin', 'saute', 'dans', 'la', 'prairie']\n", "L2: ['le l', 'pin s', 'ute d', 'ns l', ' pr', 'irie']\n", "le lApin sAute dAns lA prAirie\n" ] } ], "source": [ "p = \"le lapin saute dans la prairie\"\n", "L1 = p.split() # on récupère le découpage selon les espaces dans une liste\n", "print(\"L1:\", L1)\n", "L2 = p.split('a') # on découpe selon la lettre 'a'\n", "print(\"L2:\", L2)\n", "# on recolle en remplaçant les 'a' par des 'A'\n", "print('A'.join(L2))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Recollez la liste des mots suivants en une seule phrase." ] }, { "cell_type": "code", "execution_count": 54, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "je mange du pain et bois du vin\n" ] } ], "source": [ "listeMots = ['je', 'mange', 'du', 'pain','et', 'bois', 'du', 'vin']\n", "print(' '.join(listeMots))\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Notions de base :\n", "1. Définissez (le plus astucieusement) une liste L1 des entiers de 0 à 10.\n", "2. Définissez la liste L2 = [4, 7, 2, 8, 4, 1, 4]. Comptez le nombre de 4 qui figurent dans cette liste L2.\n", "3. Créez une liste L3 des éléments des 2 listes L1 et L2 concaténées. Ajoutez l'élément 7 à L3 et\n", "affichez L3.\n", "4. Quel est l'indice de la 1e occurrence du nombre 8 dans L3? Supprimez ensuite cet élément 8.\n", "5. L4 est la liste des éléments de L3, de l'élément d'indice 3 à celui d'indice 12. Triez, puis inversez\n", "l'ordre des éléments de L4.\n", "6. Insérez dans L4, à l'indice 7, le nombre 0.\n", "7. Créez une liste L5 des éléments de L3 qui ne sont pas dans L4." ] }, { "cell_type": "code", "execution_count": 55, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", "3\n", "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 4, 7, 2, 8, 4, 1, 4, 7]\n", "8\n", "[0, 1, 2, 3, 4, 5, 6, 7, 9, 10, 4, 7, 2, 8, 4, 1, 4, 7]\n", "[10, 9, 7, 7, 6, 5, 4, 4, 3, 2]\n", "[10, 9, 7, 7, 6, 5, 4, 0, 4, 3, 2]\n", "[1, 8, 1]\n" ] } ], "source": [ "# 1\n", "L1 = list(range(11))\n", "print(L1)\n", "# 2\n", "L2 = [4, 7, 2, 8, 4, 1, 4]\n", "print(L2.count(4))\n", "# 3\n", "L3 = L1 + L2\n", "L3.append(7)\n", "print(L3)\n", "# 4\n", "print(L3.index(8))\n", "L3.remove(8)\n", "print(L3)\n", "# 5\n", "L4 = L3[3:13]\n", "L4.sort()\n", "L4.reverse()\n", "print(L4)\n", "# 6\n", "L4.insert(7, 0)\n", "print(L4)\n", "# 7\n", "L5 = []\n", "for elt in L3:\n", " if elt not in L4:\n", " L5.append(elt)\n", "print(L5)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Notions de base avec des chaînes et des listes :\n", "1. Soit a = \"Je vais manger ma soupe\". Découpez ce texte en une liste L de mots.\n", "2. Comptez le nombre de mots\n", "3. Affichez, grâce à une boucle *for* et *enumerate()* , tous les mots de rang pair (le 1er mot est de\n", "rang 0 )\n", "4. Ajoutez à la fin de la liste le mot \"froide\".\n", "5. Remplacez le mot \"manger\" par \"dévorer\" (commencez par chercher l'indice du mot \"manger\"\n", "et ensuite à l'aide du résultat, après avoir supprimé \"manger\", insérez \"dévorer\").\n", "6. Insérez le mot \"bonne\" après \"ma\"\n", "7. Assemblez et affichez l'ensemble des mots de cette liste en une phrase avec un point à la fin." ] }, { "cell_type": "code", "execution_count": 62, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['Je', 'vais', 'manger', 'ma', 'soupe']\n", "5\n", "Je\n", "manger\n", "soupe\n", "['Je', 'vais', 'manger', 'ma', 'soupe', 'froide']\n", "['Je', 'vais', 'dévorer', 'ma', 'soupe', 'froide']\n", "['Je', 'vais', 'dévorer', 'ma', 'bonne', 'soupe', 'froide']\n", "Je vais dévorer ma bonne soupe froide.\n" ] } ], "source": [ "a = \"Je vais manger ma soupe\"\n", "# 1\n", "L = a.split()\n", "print(L) # découpage\n", "# 2\n", "print(len(L))\n", "# 3\n", "for ind, elt in enumerate(L):\n", " if ind % 2 == 0: # si l'indice est pair\n", " print(elt)\n", "# 4\n", "L.append(\"froide\")\n", "print(L)\n", "# 5\n", "i = L.index('manger')\n", "del L[i]\n", "L.insert(i, \"dévorer\")\n", "print(L)\n", "# 6\n", "i = L.index('ma')\n", "L.insert(i+1, \"bonne\")\n", "print(L)\n", "# 7\n", "print(' '.join(L)+'.')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Vous allez importer un module (bibliothèque) pour l'utiliser. Vous verrez plus tard ce que sont\n", "ces modules et comment les gérer. Pour l'instant, exécutez simplement les lignes suivantes." ] }, { "cell_type": "code", "execution_count": 63, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "abcdefghijklmnopqrstuvwxyz\n" ] } ], "source": [ "import string # importation du module string\n", "alpha = string.ascii_lowercase # dans string, on récupère ascii_lowercase\n", "print(alpha) # on l'écrit" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | \n", "1. Créez, à partir de alpha, une liste Python L1 des lettres de l'alphabet.\n", "2. Créez la liste L2 qui correspond à la place de chaque lettre dans l'alphabet (attention aux indices,\n", "'a' a l'indice 0 mais c'est la 1e lettre).\n", "3. Créez la liste L (liste de listes), en agrégeant terme à terme, les listes L1 et L2 terme à terme, afin d'obtenir ceci : \n", "L = [ ['a', 1], ['b', 2], ... ,['z', 26] ]\n", "4. Créez une fonction de nom **code()** qui prend une chaîne en argument et qui renvoie la même\n", "chaîne mais codé par chaque place que prend chaque lettre dans l'alphabet (ex : zoo sera codé 26\n", "15 15, avec un espace entre).\n", "5. Codez la phrase \"je sors prendre un verre avec un ami\".\n", "6. Décodez la phrase suivante '5 20 13 15 9 10 5 16 1 18 19 6 1 9 18 5 13 15 14 6 15 15 20 9 14\n", "7' (il faudra par exemple d'abord créer la fonction **decode()** qui à chaque nombre entre 1 et 26\n", "associe la lettre correspondante)" ] }, { "cell_type": "code", "execution_count": 71, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']\n", "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26]\n", "[['a', 1], ['b', 2], ['c', 3], ['d', 4], ['e', 5], ['f', 6], ['g', 7], ['h', 8], ['i', 9], ['j', 10], ['k', 11], ['l', 12], ['m', 13], ['n', 14], ['o', 15], ['p', 16], ['q', 17], ['r', 18], ['s', 19], ['t', 20], ['u', 21], ['v', 22], ['w', 23], ['x', 24], ['y', 25], ['z', 26]]\n", "10 5 19 15 18 19 16 18 5 14 4 18 5 21 14 22 5 18 18 5 1 22 5 3 21 14 1 13 9 \n", "etmoijeparsfairemonfooting\n" ] } ], "source": [ "# 1\n", "L1 = list(alpha)\n", "print(L1)\n", "# 2\n", "L2 = list(range(1, 27))\n", "print(L2)\n", "# 3\n", "L = []\n", "for ind, lettre in enumerate(L1):\n", " L.append([lettre, L2[ind]])\n", "print(L)\n", "# 4\n", "def code(chaine):\n", " decod = ''\n", " for l in chaine:\n", " if l != ' ': # si on est pas sur une espace\n", " for ind, elt in enumerate(L):\n", " if l == elt[0]: # on teste si la lettre correspond à une lettre de L\n", " decod = decod + str(L[ind][1]) + ' ' # on ajoute le nb correspondant en string + espace\n", " return decod\n", "# 5\n", "ch = \"je sors prendre un verre avec un ami\"\n", "print(code(ch))\n", "# 6\n", "def decode(chaine):\n", " result = ''\n", " listenb = chaine.split() # on récupère la liste des nbs\n", " for nb in listenb: # pour chaque nb\n", " for ind, elt in enumerate(L):\n", " if elt[1] == eval(nb):\n", " result = result + L[ind][0]\n", " return result\n", "\n", "c = '5 20 13 15 9 10 5 16 1 18 19 6 1 9 18 5 13 15 14 6 15 15 20 9 14 7'\n", "print(decode(c)) # sans la gestion des espaces..." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Les tuples

\n", "\n", "Un tuple se comporte un peu comme une liste, sauf qu'il n'est pas modifiable.\n", "\n", "Pourquoi les utiliser? ils sont plus rapidement gérable par **Python** (plus rapide à l'exécution), ils permettent les affectations multiples, ils sont intéressants si le tuple doit être exploité tel quel.\n", "\n", "Le tuple est créé à l'aide de parenthèses, mais pas nécessairement.\n", "\n", "Exécutez et observez les lignes suivantes" ] }, { "cell_type": "code", "execution_count": 72, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(1, 2, 3)\n", "(3, 6, 'ours')\n", "(3, 6, 'ours')\n", "(77,)\n" ] } ], "source": [ "t0 = tuple([1,2,3]) # liste tranformée en tuple\n", "print(t0)\n", "t1 = (3, 6, \"ours\") # préférable plutôt que ce qui suit...\n", "print(t1)\n", "t1 = 3, 6, \"ours\"\n", "print(t1)\n", "t2 = () # tuple vide, on ne peut plus en faire grand chose...\n", "t3 = (77, ) # tuple à 1 élément\n", "# ou\n", "t3 = 77, # équivalent mais ne pas oublier la virgule, diffère de t3 = 77\n", "print(t3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Opérer sur les tuples**\n", "\n", "Comme dit précédemment, un tuple ne peut être modifié, donc pas de modification des éléments, de remplacement, d'ajout, de suppression.\n", "\n", "Attention tout de même, si un tuple contient une liste, les éléments de la liste sont modifiables car une liste est modifiable, mais vous ne pouvez pas changer l'élément *liste* du tuple en autre chose.\n", "\n", "On peut concaténer des tuples, ce qui donne un autre tuple, donner la longueur d'un tuple, tester si un élément s'y trouve, ...\n", "\n", "Exécutez et observez les lignes suivantes" ] }, { "cell_type": "code", "execution_count": 73, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "4\n", "True\n", "lapin\n", "7\n", "[3, 7]\n", "('a', 9)\n", "('lapin', 7, [3, 7], ('a', 9), 4, 8)\n" ] } ], "source": [ "t = ('lapin', 7, [3, 7], ('a', 9))\n", "print(len(t)) # 4 éléments\n", "print(7 in t) # True\n", "for elt in t: # parcours le tuple\n", " print(elt)\n", "h = (4, 8)\n", "print(t + h) # concaténation" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Notez que le tuple t précédent n'est pas modifiable, mais les éléments qui le constituent si ! ... si ils\n", "sont eux-mêmes modifiables!\n", "\n", "Exécutez et observez les lignes suivantes" ] }, { "cell_type": "code", "execution_count": 74, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "('lapin', 7, [3, 7], ('a', 9))\n", "('lapin', 7, [333, 7], ('a', 9))\n" ] } ], "source": [ "print(t) # avec t = ('lapin', 7, [3, 7], ('a', 9))\n", "t[2][0] = 333 # remplacement du 1e élément de la liste, 3e élément du tuple\n", "print(t) # c'est fait !" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Créez un tuple **t** à 2 élements, contenant deux listes : [1, 2] et [3, 4] dans cet ordre.\n", "1. Affectez si possible au $1^e$ élément de la $1^e$ liste la valeur 5, soit t = ( [5, 2], [3, 4] ).\n", "2. En 3 lignes de code, trouvez le moyen d'obtenir t = ( [3, 4], [5, 2] )\n", "3. Soit un second tuple h = ('a', 'b'). Peut-on concaténer t et h? Qu'obtient-on?" ] }, { "cell_type": "code", "execution_count": 77, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "([5, 2], [3, 4])\n", "([3, 4], [5, 2])\n", "([3, 4], [5, 2], 'a', 'b')\n" ] } ], "source": [ "t = ([1, 2], [3, 4])\n", "# 1\n", "t[0][0] = 5\n", "print(t)\n", "# 2\n", "t = list(t)\n", "t[0], t[1] = t[1], t[0]\n", "t = tuple(t)\n", "print(t)\n", "# 3\n", "h = ('a', 'b')\n", "print(t + h) # oui, on obtient un nouveau tuple" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Les dictionnaires

\n", "\n", "On rappelle qu'un dictionnaire est un tableau associatif modifiable, c'est-à-dire qu'il se comporte\n", "un peu comme une liste non ordonnée d'éléments << clé <->_valeur >>.\n", "\n", "Les clés sont uniques, les valeurs quelconques.\n", "\n", "Un dictionnaire se note entre accolades.\n", "\n", "```python\n", " dico = {'lapin': 7, 'chat': 3, 'chien': 7}\n", "```\n", "\n", "'lapin', 'chat' et 'chien' sont les clés, 7, 3 et 7 sont les valeurs associées.\n", "\n", "Remarquez les 2 points entre la clé et la valeur associée, les éléments sont séparés par une virgule. Les clés\n", "peuvent être de tout type (numérique, alphabétique, ...) et les valeurs sont quelconques (donc tuple,\n", "liste et dictionnaire y compris). \n", "\n", "Voici un exemple plus \"tordu\"...\n", "\n", "```python\n", " dicotordu = {1 : 'oui', 'non': 7, 4 : [3, 6], 'e' : 'tout'}\n", "```\n", "\n", "**Générer un dictionnaire**\n", "\n", "On peut créer un dictionnaire vide puis, alimenter son contenu avec des éléments clé-valeur. Exécutez et observez les lignes suivantes" ] }, { "cell_type": "code", "execution_count": 78, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'a': 5, 'e': 9}\n" ] } ], "source": [ "d = {} # dictionnaire vide\n", "d['a'] = 5 # 'a' est la clé, 5 la valeur\n", "d['e'] = 9\n", "print(d) # affichage" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "On peut aussi créer un dictionnaire à partir d'une liste de tuples, ou d'un tuple de listes ou d'une liste\n", "de listes ou ...\n", "\n", "Observez, puis exécutez les ligne suivantes" ] }, { "cell_type": "code", "execution_count": 79, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'a': 5, 'b': 7} {'a': 5, 'b': 7} {'a': 5, 'b': 7}\n" ] } ], "source": [ "a = [('a', 5), ('b', 7)]\n", "b = [['a', 5], ['b', 7]]\n", "c = (('a', 5), ('b', 7))\n", "d1 = dict(a)\n", "d2 = dict(b)\n", "d3 = dict(c)\n", "print(d1, d2, d3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Manipuler des dictionnaires**\n", "\n", "Imaginez que vous ayez rangé le nombre de voyelles dans un texte, selon les voyelles concernées. Soit d le dictionnaire suivant :\n", "\n", "```python\n", " d = {'a':5, 'e':12, 'i':4, 'o':2, 'u':4, 'y':1}\n", "```\n", "\n", "On peut alors obtenir la liste des clés avec *keys()*, des valeurs avec *values()* ou les deux avec *items()*.\n", "\n", "Exécutez les ligne suivantes" ] }, { "cell_type": "code", "execution_count": 80, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "dict_keys(['a', 'e', 'i', 'o', 'u', 'y'])\n", "dict_values([5, 12, 4, 2, 4, 1])\n", "dict_items([('a', 5), ('e', 12), ('i', 4), ('o', 2), ('u', 4), ('y', 1)])\n" ] } ], "source": [ "d = {'a':5, 'e':12, 'i':4, 'o':2, 'u':4, 'y':1}\n", "print(d.keys())\n", "print(d.values())\n", "print(d.items())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Les 3 entités ci-dessus sont en fait des itérables. Il vaut mieux présenter comme ci-dessous :\n", "\n", "Exécutez" ] }, { "cell_type": "code", "execution_count": 81, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "a 5\n", "e 12\n", "i 4\n", "o 2\n", "u 4\n", "y 1\n" ] } ], "source": [ "for cle, val in d.items():\n", " print(cle, val)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Modification des éléments**\n", "\n", "On peut changer une valeur et détruire une clé (donc dans ce cas aussi sa valeur associée)\n", "\n", "Exécutez et observez le retour :" ] }, { "cell_type": "code", "execution_count": 82, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'a': 3, 'e': 12, 'i': 4, 'o': 2, 'u': 4, 'y': 1}\n", "{'a': 3, 'e': 12, 'i': 4, 'o': 2, 'u': 4}\n" ] } ], "source": [ "d['a'] = 3\n", "print(d)\n", "del d['y']\n", "print(d)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "On peut tester l'appartenance ou pas d'une clé\n", "\n", "Exécutez et observez le retour :" ] }, { "cell_type": "code", "execution_count": 83, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "True\n", "False\n", "True\n" ] } ], "source": [ "print('a' in d)\n", "print('y' in d)\n", "print('z' not in d)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "On peut aussi supprimer une clé et récupérer sa valeur au passage.\n", "\n", "Exécutez et observez le retour :" ] }, { "cell_type": "code", "execution_count": 84, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "12\n", "{'a': 3, 'i': 4, 'o': 2, 'u': 4}\n" ] } ], "source": [ "nombre = d.pop('e')\n", "print(nombre)\n", "print(d)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Une dernière méthode bien utile est *get()* qui attend 2 paramètres : une clé et une valeur de retour\n", "par défaut. Observez le code suivant :\n", "\n", "Dans ce code, *dico* contient que des voyelles comme clé. *get()* renvoie la valeur associée à la clé, si elle n'existe pas, elle renvoie le second paramètre (ici le texte \"n'est pas une voyelle\")\n", "\n", "Exécutez les lignes suivantes" ] }, { "cell_type": "code", "execution_count": 85, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Valeur associée à a : 5\n", "Valeur associée à b : n'est pas une voyelle\n", "Valeur associée à e : 12\n", "Valeur associée à i : 4\n", "Valeur associée à u : 4\n", "Valeur associée à t : n'est pas une voyelle\n" ] } ], "source": [ "dico = {'a':5, 'e':12, 'i':4, 'o':2, 'u':4, 'y':1}\n", "for elt in ['a','b','e','i','u','t']:\n", " print(\"Valeur associée à \", elt, \":\", dico.get(elt,\"n'est pas une voyelle\"))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Bien d'autres méthodes sont disponibles pour les dictionnaires qui sont très utiles. N'hésitez pas à\n", "consulter la documentation sur internet.\n", "\n", "> **Exercice** | Soit le dictionnaire suivant : dic1 = {'lapin' :5, 'vache' :7, 'cochon' :2, 'cheval' :4}. Créez un programme qui échange clé et valeur pour former un nouveau dictionnaire de nom dic2." ] }, { "cell_type": "code", "execution_count": 86, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{5: 'lapin', 7: 'vache', 2: 'cochon', 4: 'cheval'}\n" ] } ], "source": [ "dic1 = {'lapin' :5, 'vache' :7, 'cochon' :2, 'cheval' :4}\n", "dic2 = {}\n", "for cle, val in dic1.items():\n", " dic2[val] = cle\n", "print(dic2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Les résultats en Français, Maths, Physique, Anglais sont respectivement les suivants pour 4 étudiants. \n", "Jean : 12, 15, 8, 7 Anne : 5, 7, 11, 9 Pierre : 17, 18, 15, 13 Kelly : 14, 15, 9, 19\n", "1. Créez un dictionnaire de nom dico , dont les clés sont les prénoms et les valeurs un tuple contenant\n", "dans l'ordre les notes obtenues.\n", "2. Affichez le ou les éléments dont la note en physique est supérieure ou égale à 15\n", "3. Affichez le ou les éléments qui n'ont pas la moyenne en anglais.\n", "4. Ajoutez au dictionnaire, Paul qui a eu 11, 10, 9 et 12\n", "5. Calculez la moyenne des notes obtenues en Maths." ] }, { "cell_type": "code", "execution_count": 93, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "physique >= 15\n", "Pierre\n", "anglais < 10\n", "Jean\n", "Anne\n", "{'Jean': (12, 15, 8, 7), 'Anne': (5, 7, 11, 9), 'Pierre': (17, 18, 15, 13), 'Kelly': (14, 15, 9, 19), 'Paul': (11, 10, 9, 12)}\n", "5\n", "moyenne en maths 13.0\n" ] } ], "source": [ "# 1\n", "dico = {'Jean':(12, 15, 8, 7), 'Anne':(5, 7, 11, 9), 'Pierre':(17, 18, 15, 13), 'Kelly':(14, 15, 9, 19)}\n", "# 2\n", "print('physique >= 15')\n", "for cle, val in dico.items():\n", " if val[2] >= 15:\n", " print(cle)\n", "# 3\n", "print('anglais < 10')\n", "for cle, val in dico.items():\n", " if val[3] < 10:\n", " print(cle)\n", "# 4\n", "dico['Paul'] = (11,10,9,12)\n", "print(dico)\n", "# 5\n", "moy = 0\n", "for val in dico.values():\n", " moy = moy + val[1]\n", "moy = moy/len(dico)\n", "print('moyenne en maths', moy)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Soit le texte **t** suivant : \"le loup est en route vers la bergerie pour y faire je ne sais quoi\".\n", "Construisez un dictionnaire qui comporte comme clés, les lettres utilisées dans cette phrase, et\n", "comme valeurs, le nombre de fois où la lettre apparaît dans le texte. Utilisez *get()* avec comme valeur\n", "par défaut 0 . Affichez ensuite le dictionnaire." ] }, { "cell_type": "code", "execution_count": 95, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'l': 3, 'e': 11, 'o': 4, 'u': 4, 'p': 2, 's': 4, 't': 2, 'n': 2, 'r': 6, 'v': 1, 'a': 3, 'b': 1, 'g': 1, 'i': 4, 'y': 1, 'f': 1, 'j': 1, 'q': 1}\n" ] } ], "source": [ "t = \"le loup est en route vers la bergerie pour y faire je ne sais quoi\"\n", "dico = {}\n", "for l in t:\n", " if l != ' ': # si ce n'est pas une espace\n", " dico[l] = dico.get(l, 0) + 1 # si la cle existe, on ajoute 1 à la valeur, sinon la valeur est 0 + 1 \n", "print(dico)\n" ] } ], "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 }