listes_tuples_dictionnaires.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <center> Compléments sur les listes, tuples, dictionnaires</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Compléments sur les listes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Listes en compréhension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Voici un programme qui ajoute des éléments dans une liste façon successive:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]\n"
     ]
    }
   ],
   "source": [
    "L=[]\n",
    "for i in range(20):\n",
    "    if i%2==0:\n",
    "        L.append(i)\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il existe une manière plus concise de procéder, la définition en compréhension :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 3, 6, 9, 12, 15, 18]\n"
     ]
    }
   ],
   "source": [
    "# Une liste en compréhension\n",
    "L=[i for i in range(20) if i%3==0]\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Syntaxes\n",
    "Voici des types d'instructions possibles pour générer des listes en compréhension:\n",
    "\n",
    "*  [*fonction de x*  **for** *x in ensemble* ]\n",
    "*  [*fonction de x* **if** *condition sur x* **else** *autre fonction de x* **for** *x in ensemble* ]\n",
    "*  [*fonction de x* **for** *x in ensemble* **if** *condition sur x* ]\n",
    "\n",
    "#### Exemples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30]\n",
      "[3, 5, 2, 5, 6, 6, 4, 5, 2, 1]\n",
      "['F', 'P', 'P', 'P', 'P', 'P', 'F', 'F', 'P', 'F', 'F', 'P', 'F', 'P', 'F', 'F', 'P', 'F', 'P', 'P']\n"
     ]
    }
   ],
   "source": [
    "#1\n",
    "L=[3*i for i in range(11)]\n",
    "print(L)\n",
    "\n",
    "#2\n",
    "from random import *\n",
    "n=10\n",
    "Des=[randint(1,6) for i in range(n)]\n",
    "print(Des)\n",
    "\n",
    "#3\n",
    "pileface=[choice(['P','F']) for i in range(20)]\n",
    "print(pileface)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 1:\n",
    "En utilisant la syntaxe des listes en compréhension :\n",
    "1. Générer les entiers naturels de 1 à 100.\n",
    "2. Générer les multiples de 5 inférieurs ou égaux à 100.\n",
    "3. Générer une liste des entiers naturels de 1 à 100 dans laquelle les multiples de 5 seront remplacées par le caractère `*`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#1.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#2.\n",
    " \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#3.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 2:\n",
    "En utilisant les fonctions `randint()` ou `choice()` du module `random` et la syntaxe des listes en compréhension:\n",
    "1. Générer une liste de 20 entiers naturels aléatoires entre 0 et 255.\n",
    "2. Générer 100 caractères au hasard parmi `a`,`b`,`c`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#1.\n",
    "from random import *\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#2.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Listes de listes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour représenter des tableaux à double entrée(images, matrices...), on peut utiliser une liste de listes. On identifie ainsi un élément du tableau à l'aide de deux indexs.\n",
    "\n",
    "Exemple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A\n"
     ]
    }
   ],
   "source": [
    "tableau=[['A','b','c','d'],['E','f','g'],['I','j','k','m'],['N','o','p','q']]\n",
    "print(tableau[0][0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 3:\n",
    "1. Quel est la lettre correpondant à `tableau[1][2]`?\n",
    "2. Quelle instruction permet d'accéder à la lettre 'm' ?\n",
    "3. Ajouter au tableau la ligne `['R','s','t','u']`.\n",
    "4. Ajouter le caractère `h` à sa place.\n",
    "5. Remplacer la caractère `N` par `n`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#1.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#2.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#3\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#4\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#5\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 4:\n",
    "Générer en comprehension une liste de 10 listes contenant chacune 10 entiers binaires aléatoires(0 ou 1)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Avant de poursuivre"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous avons étudié jusqu’ici deux types de données construits(composites) : les chaînes, qui sont composées de caractères, et les listes, qui sont composées d’éléments de n’importe quel type. \n",
    "\n",
    "Rappel sur une différence importante entre chaînes et listes : il n’est pas possible de changer les caractères au sein d’une chaîne existante, alors que l'on peut modifier les éléments d’une liste. En d’autres termes, les listes sont des séquences modifiables, alors que les chaînes de caractères sont des séquences non-modifiables.\n",
    "\n",
    "Exemples :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'c']\n"
     ]
    }
   ],
   "source": [
    "# Les listes sont modifiables\n",
    "L=['a','b','d']\n",
    "L[2]='c'\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'str' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-3-23e01673f992>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# les chaînes ne sont pas modifiables\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0mmot\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'abd'\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mmot\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'c'\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'str' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "# les chaînes ne sont pas modifiables\n",
    "mot='abd'\n",
    "mot[2]='c'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans la suite de cette feuille deux nouveaux types de données : les tuples et les dictionnaires"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. tuples (ou p-uplets)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python propose un type de données appelé tuple, qui est assez semblable à une liste mais qui, comme les chaînes, n’est pas modifiable. Du point de vue de la syntaxe, un tuple est une collection d’éléments séparés par des virgules :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3) <class 'tuple'>\n",
      "(6, 7) <class 'tuple'>\n",
      "('abc', 'def') <class 'tuple'>\n",
      "('a', 1, 'b', 2) <class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "#Exécuter le code ci-dessous\n",
    "tup1 = 1,2,3\n",
    "tup2 = (6,7)\n",
    "tup3 = 'abc','def'\n",
    "tup4 = ('a',1,'b',2)\n",
    "print(tup1,type(tup1))\n",
    "print(tup2,type(tup2))\n",
    "print(tup3,type(tup3))\n",
    "print(tup4,type(tup4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A retenir :\n",
    "   *  De simples virgules suffisent à définir un tuple mais pour la lisibilité du code, il est préférable de l'enfermer dans des parenthèses."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Opérations sur les tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "#affectations\n",
    "t= 7,8,9\n",
    "a,b,c = t\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 2, 1, 3, 2, 1, 6, 5, 4)\n"
     ]
    }
   ],
   "source": [
    "# opérateurs + et * : concanténation et répétition\n",
    "t1=  (3,2,1)\n",
    "t2 = (6,5,4)\n",
    "t3 = 2*t1+t2\n",
    "print(t3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "# Accéder aux éléments\n",
    "t4 = (2,4)\n",
    "print(t4[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "# longueur d'un tuple\n",
    "print(len(t3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 6 7 8 9 10 "
     ]
    }
   ],
   "source": [
    "# Parcours d'un tuple\n",
    "t5 = (0,1,2,3,4,5,6,7,8,9)\n",
    "for e in t5 :\n",
    "    print(e+1, end=' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "# test in \n",
    "b = 3 in (2,4,6)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'tuple' object has no attribute 'append'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-19-366c3bc37ff0>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# les tuples ne sont pas des listes\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0mt6\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m6\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m8\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mt6\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m10\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m: 'tuple' object has no attribute 'append'"
     ]
    }
   ],
   "source": [
    "# les tuples ne sont pas des listes\n",
    "t6 = (2,4,6,8)\n",
    "t6.append(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4, 5, 6)\n"
     ]
    }
   ],
   "source": [
    "#Ajouter un élément à un tuple\n",
    "t7 = 1,2,3,4,5\n",
    "t7 = t7 + (6,) # ne pas oublier la virgule et les parenthèses\n",
    "print(t7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A retenir :\n",
    "* Les opérateurs de concaténation `+` et de multiplication `*` donnent les mêmes résultats que pour les chaînes et les listes.\n",
    "* On accède aux éléments d'un tuple comme avec les chaînes et les listes.\n",
    "* On peut déterminer la taille d’un tuple à l’aide de la fonction `len()`.\n",
    "* On peut le parcourir à l’aide d’une boucle `for`, utiliser l’instruction `in` pour savoir si un élément donné en fait partie, exactement comme pour une liste ou pour une chaîne.\n",
    "* Les tuples ne sont pas modifiables et on ne peut pas utiliser avec eux  ni la méthode `.append()`ni l'instruction `del()`.\n",
    "* Les tuples sont moins souples que les listes mais c'est aussi leur force. On est sûr que leur contenu ne sera pas modifié par erreur. De plus ils sont beaucoup moins gourmands en ressources et sont éxécutés plus rapidement."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 5 :\n",
    "Ecrire la fonction `reverse(t)` qui prend en paramètre un tuple de trois valeurs et qui renvoie un tuple contenant les 3 valeurs dans l'ordre inverse.\n",
    "\n",
    "Ainsi `reverse(1,2,3)` renvoie `(3,2,1)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Réponse\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 6 : \n",
    "Ecrire la fonction `initiales` qui prend en paramètre une chaîne de caractères de type `'NOM Prénom'` et qui renvoie un tuple contenant les initiales des noms et prénoms passés en argument. \n",
    "\n",
    "Ainsi `initiales('John Doe')` doit renvoyer `('J','D')`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Réponse:\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 7 :\n",
    "En utilisant le résultat précédent, compléter la fonction `initiale_nom(noms,lettre)` qui prend en paramètres un tuple de noms et prénoms formatés comme précédemment ainsi qu'un caractère et qui renvoie un tuple contenant les chaînes avec la même initiale de nom.\n",
    "\n",
    "Ainsi avec le tuple ci-dessous, `initiale_nom(stars,'S')` doit renvoyer `('Claude Shannon','Ivan Sutherland', 'Otto Scmitt')`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Réponse\n",
    "stars = ('Ada Lovelace','Alan Turing','Claude Shannon','Donald Knuth','Georges Boole','Grace Hopper',\n",
    "         'Ivan Sutherland','John Von Neumann','Linus Thorvalds','Otto Schmitt','Tim Berners-Lee','Tommy Flowers')\n",
    "\n",
    "def initiale_nom(noms, lettre):\n",
    "    resultats=()\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    return resultats   \n",
    "\n",
    "#Appels\n",
    "initiale_nom(stars,'S')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 8 :\n",
    "<img style='float:right;' src='fusions.png' width=200>\n",
    "On se place dans le contexte du codage des couleurs selon le système RGB, déjà vu dans une feuille précédente. Dans une image dite bitmap, chaque pixel contient une couleur composée de ses couches Rouge, Verte et Bleue, chacune de ces couches étant représentée par un entier compris entre $0$ et $255$\n",
    "\n",
    "Dans les logiciels de traitement d'images(Photoshop, Gimp,...), on travaille avec des calques d'images que l'on superpose et que l'on fusionne. En fonction des opérations mathématiques utilisées pour fusionner les calques, on obtient des rendus esthétiques différents:\n",
    "<img style='float:right;' src='http://www.info-3000.com/photoshop/modefusion02.jpg' width=400>\n",
    "\n",
    "Chacune des fonctions demandées correspondent à un mode de fusion de Photoshop , prennent en paramètres deux tuples de trois valeurs`pix1`et `pix2` correspondants aux deux pixels que l'on souhaite fusionner et renvoient un tuple  contenant la couleur finale obtenue.\n",
    "\n",
    "Pour s'aider, voici une description des formules de certains modes de fusion( en milieu de page) :\n",
    "https://helpx.adobe.com/fr/after-effects/using/blending-modes-layer-styles.html\n",
    "\n",
    "On pourra tester avec les deux pixels `p1=(200,128,63)` et `p2=(125,205,50)`. Fonctions `min()` et `max()` autorisées !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "p1 = (200,128,63)\n",
    "p2 = (125,205,50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. `eclaircir(p1,p2)` renvoie `(200,205,63)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('to do', 'to do', 'to do')"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#1 : remplacer \"to do\" par les bonnes valeurs\n",
    "def eclaircir(pix1, pix2):\n",
    "    r= \"to do\"\n",
    "    g= \"to do\"\n",
    "    b= \"to do\"\n",
    "    \n",
    "    return (r,g,b)\n",
    "\n",
    "eclaircir(p1,p2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. `obscurcir(p1,p2)` renvoie `(125,128,50)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('to do', 'to do', 'to do')"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#2 :\n",
    "def obscurcir(pix1, pix2):\n",
    "    r= \"to do\"\n",
    "    g= \"to do\"\n",
    "    b= \"to do\"\n",
    "    \n",
    "    return (r,g,b)\n",
    "\n",
    "obscurcir(p1,p2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. `difference(p1,p2)` renvoie `(75,77,13)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('to do', 'to do', 'to do')"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#3 :\n",
    "def difference(pix1,pix2):\n",
    "    r= \"to do\"\n",
    "    g= \"to do\"\n",
    "    b= \"to do\"\n",
    "    \n",
    "    return (r,g,b)\n",
    "\n",
    "difference(p1,p2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. `addition(p1,p2)` renvoie `(255,255,113)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('to do', 'to do', 'to do')"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#4 :\n",
    "def addition(pix1,pix2):\n",
    "    r= \"to do\"\n",
    "    g= \"to do\"\n",
    "    b= \"to do\"\n",
    "    \n",
    "    return (r,g,b)\n",
    "\n",
    "addition(p1,p2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5. `soustraction(p1,p2)` renvoie `(0,77,0)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('to do', 'to do', 'to do')"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#5 :\n",
    "def soustraction(pix1,pix2):\n",
    "    r= \"to do\"\n",
    "    g= \"to do\"\n",
    "    b= \"to do\"\n",
    "    \n",
    "    return (r,g,b)\n",
    "\n",
    "soustraction(p1,p2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6. `produit(p1,p2)` renvoie `(98,103,12)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('to do', 'to do', 'to do')"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#6 :\n",
    "def produit(pix1,pix2):\n",
    "    r= \"to do\"\n",
    "    g= \"to do\"\n",
    "    b= \"to do\"\n",
    "    \n",
    "    return (r,g,b)\n",
    "\n",
    "produit(p1,p2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7. `division(p1,p2)` renvoie `(159,255,202)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('to do', 'to do', 'to do')"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#7 :\n",
    "def division(pix1,pix2):\n",
    "    r= \"to do\"\n",
    "    g= \"to do\"\n",
    "    b= \"to do\"\n",
    "    \n",
    "    return (r,g,b)\n",
    "\n",
    "division(p1,p2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8. `superposition(p1,p2)` renvoie `(226,230,100)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('to do', 'to do', 'to do')"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#8 :\n",
    "def superposition(pix1,pix2):\n",
    "    r= \"to do\"\n",
    "    g= \"to do\"\n",
    "    b= \"to do\"\n",
    "    \n",
    "    return (r,g,b)\n",
    "    \n",
    "superposition(p1,p2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Dictionnaires"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Définition et création"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les types de données construits que nous avons abordés jusqu’à présent (chaînes, listes et tuples) sont tous des séquences, c’est-à-dire des suites ordonnées d’éléments. Dans une séquence, il est facile\n",
    "d’accéder à un élément quelconque à l’aide d’un index (un nombre entier), mais encore faut-il le connaître.\n",
    "\n",
    "Les dictionnaires constituent un autre type construit. Ils ressemblent aux\n",
    "listes( ils sont modifiables comme elles), mais ce ne sont pas des séquences.\n",
    "Les éléments que nous allons y enregistrer ne seront pas disposés dans un ordre immuable. En revanche, nous pourrons accéder à n’importe lequel d’entre eux à l’aide d’un index que l’on appellera une clé, laquelle pourra être alphabétique ou numérique.\n",
    "\n",
    "\n",
    "Comme dans une liste, les éléments mémorisés dans un dictionnaire peuvent être de n’importe quel type( valeurs numériques, chaînes, listes ou encore des dictionnaires, et même aussi des fonctions).\n",
    "\n",
    "Exemple :\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'nom': 'Paris-Orly Airport', 'ville': 'Paris', 'pays': 'France', 'code': 'ORY', 'gps': (48.7233333, 2.3794444)}\n",
      "ORY\n",
      "(48.7233333, 2.3794444)\n"
     ]
    }
   ],
   "source": [
    "dico1={}\n",
    "dico1['nom']='Paris-Orly Airport'\n",
    "dico1['ville']='Paris'\n",
    "dico1['pays']='France'\n",
    "dico1['code']='ORY'\n",
    "dico1['gps']=(48.7233333,2.3794444)\n",
    "\n",
    "print(dico1)\n",
    "print(dico1['code'])\n",
    "print(dico1['gps'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remarques :\n",
    "\n",
    "- Des accolades délimitent un dictionnaire.\n",
    "- Les éléments d'un dictionnaire sont séparés par une virgule.\n",
    "- Chacun des éléments est une paire d'objets séparés par deux points : une clé et une valeur.\n",
    "- La valeur de la clé `'code'` est `'ORY'`.\n",
    "- La valeur de la clé `'gps'` est un tuple de deux flottants.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 9 :\n",
    "Voici des données concernant l'aéroport international de Los Angeles :\n",
    "\n",
    "* __\"Los Angeles International Airport\",\"Los Angeles\",\"United States\",\"LAX\",33.94250107,-118.4079971__\n",
    "\n",
    "\n",
    "En utilisant les mêmes clés que dans l'exemple précédent, créer le dictionnaire 'dico2' qui contiendra les données ci-dessus"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Réponse\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Méthodes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['nom', 'ville', 'pays', 'code', 'gps'])\n",
      "dict_values(['Paris-Orly Airport', 'Paris', 'France', 'ORY', (48.7233333, 2.3794444)])\n",
      "dict_items([('nom', 'Paris-Orly Airport'), ('ville', 'Paris'), ('pays', 'France'), ('code', 'ORY'), ('gps', (48.7233333, 2.3794444))])\n"
     ]
    }
   ],
   "source": [
    "#Afficher les clés\n",
    "print(dico1.keys())\n",
    "\n",
    "#Affichées les valeurs\n",
    "print(dico1.values())\n",
    "\n",
    "#Afficher les éléments\n",
    "print(dico1.items())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Parcours"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut traiter par un parcours les éléments contenus dans un dictionnaire, mais attention :\n",
    "* Au cours de l'itération, __ce sont les clés__ qui servent d'index\n",
    "* L'ordre dans lequel le parcours s'effectue est imprévisible\n",
    "\n",
    "Exemple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nom\n",
      "ville\n",
      "pays\n",
      "code\n",
      "gps\n"
     ]
    }
   ],
   "source": [
    "for element in dico1:\n",
    "    print(element)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 10 :\n",
    "Modifier le programme ci-dessus pour obtenir l'affichage ci-dessous :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Exercices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 11 :\n",
    "Lors d'une élection, entre 2 et 6 candidats se présentent. Il y a 100 votants, chacun glisse un bulletin avec le nom d'un candidat dans l'urne. Les lignes de code ci-dessous simulent cette expérience."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Candidats :  ['Eva', 'Charlie']\n"
     ]
    }
   ],
   "source": [
    "from random import *\n",
    "\n",
    "#liste des candidats potentiels\n",
    "noms=['Alice','Bob','Charlie','Daniella','Eva','Fred']\n",
    "\n",
    "#liste des candidats réels\n",
    "candidats=list(set([choice(noms) for i in range(randint(2,len(noms)))]))\n",
    "\n",
    "#nombre de votants\n",
    "votants=100\n",
    "\n",
    "#liste des bulletins dans l'urne\n",
    "urne=[choice(candidats) for i in range(votants)]\n",
    "\n",
    "print('Candidats : ',candidats)\n",
    "#print(\"Contenu de l'urne :\", urne)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Vérifier que les candidats réels changent à chaque éxecution de la cellule ci-desssus ainsi que le contenu de l'urne."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Compléter la fonction `depouillement(urne)`. Elle prend en paramètre une liste (la liste des bulletins exprimés) et renvoie un dctionnaire. Les paires clés-valeurs sont respectivement constituées du noms d'un candidat réels et du nombre de bulletins exprimés en sa faveur. Par exemple, si la liste des candidats est `['Alice','Charlie,'Bob']`, le résultat pourra s'afficher sous la forme `{'Eva': 317, 'Charlie': 363, 'Alice': 320}`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Remplacer \"pass\" par les bonnes instructions\n",
    "def depouillement(urne):\n",
    "    decompte={}\n",
    "    \n",
    "    for bulletin in urne:\n",
    "        if bulletin in decompte:\n",
    "            pass\n",
    "        else:\n",
    "            pass\n",
    "    \n",
    "    return decompte\n",
    "\n",
    "\n",
    "depouillement(urne)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Ecrire la fonction `vainqueur(election)` qui prend en paramètre un dictionnaire contenant le décompte d'une urne renvoyé par la fonction précédente et qui renvoie le nom du vainqueur."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Bob'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def vainqueur(election):\n",
    "    vainqueur=''\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "\n",
    "vainqueur(depouillement(urne))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 12\n",
    "<img style='float:center;' src='https://openflights.org/demo/openflights-routedb-2048.png' width=500>\n",
    "\n",
    "Sur le site https://openflights.org/data.html , on trouve des bases de données mondiales aéronautiques.Le fichier `airports.txt`  présent dans le dossier de cette feuille contient des informations sur les aéroports.\n",
    "\n",
    "\n",
    "Chaque ligne de ce fichier est formatée comme l'exemple ci-dessous :\n",
    "\n",
    "`1989,\"Bora Bora Airport\",\"Bora Bora\",\"French Polynesia\",\"BOB\",\"NTTB\",-16.444400787353516,-151.75100708007812,10,-10,\"U\",\"Pacific/Tahiti\",\"airport\",\"OurAirports\"`\n",
    "\n",
    "On souhaite extraire les informations suivantes pour chaque aéroport:\n",
    "* Sa référence unique, un entier.\n",
    "* Le nom de l'aéroport, une chaîne de caractères\n",
    "* La ville principale qu'il dessert, une chaîne de caractères\n",
    "* Le pays de cette ville,une chaîne de caractères\n",
    "* Le code IATA de l'aéroport composé de 3 lettres en majuscules\n",
    "* Ses coordonées gps (latitude puis longitude), un tuple de 2 flottants."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1. Compléter les champs ci-dessous pour l'aéroport cité en exemple:**\n",
    "   * ref :  \n",
    "   * nom :  \n",
    "   * ville :  \n",
    "   * pays : \n",
    "   * gps :  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2. La fonction `data_extract` doit parcourir le fichier et extraire les données demandées qu'elle renvoie sous forme d'une liste de dictionnaires.**\n",
    "\n",
    "* Chaque élément de la liste est donc un dictionnaire qui correspond à un aéroport. \n",
    "* Les clés sont les noms des champs que l'on souhaite extraire et les valeurs sont celles associées à chaque aéroport.\n",
    "\n",
    "Recopier , modifier et compléter cette fonction pour qu'elle éxécute la tâche demandée :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A compléter\n",
      "{'ref': 8631, 'nom': 'Capital City Airport', 'ville': 'A compléter', 'pays': 'United States', 'A compléter': 'FFT', 'gps': 'A compléter'}\n"
     ]
    }
   ],
   "source": [
    "#2.\n",
    "def data_extract(chemin):\n",
    "    fichier = open(chemin, \"r\",encoding='utf-8')\n",
    "    res = [] # Pour contenir le résultat qui sera une liste de dictionnaires\n",
    "    for ligne in fichier:\n",
    "        datas = ligne.strip().split(\",\")  # une ligne du fichier\n",
    "        res.append(\n",
    "        { \"ref\": int(datas[0]),\n",
    "          \"nom\": datas[1][1:-1],\n",
    "          \"ville\": \"A compléter\",\n",
    "          \"pays\": datas[3][1:-1],\n",
    "          \"A compléter\": datas[4][1:-1],\n",
    "          \"gps\" : \"A compléter\"\n",
    "        })\n",
    "        \n",
    "    fichier.close()\n",
    "    return res\n",
    "\n",
    "airports=data_extract('airports.txt')\n",
    "\n",
    "#nombre d'aéroports référencés\n",
    "print(\"A compléter\")\n",
    "\n",
    "#un aéroport au hasard\n",
    "print(choice(airports))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "#2. Réponse\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3. A l'aide d'une liste en compréhension, récupérer la liste des villes françaises desservies par un aéroport**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "#3. Réponse\n",
    "country='France'\n",
    "res=['A compléter']\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**4. Ecrire la fonction `infos(airports,ville)`.** \n",
    "\n",
    "Elle prend en paramètres la liste des dictionnaires de données extraites et une chaîne de caractères(le nom d'une ville). Elle renvoie les informations du ou des aéroports de cette ville dans une liste de dictionnaires:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "#4.\n",
    "def infos(airports,ville):\n",
    "    res=[]\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    return res\n",
    "\n",
    "print(infos(airports,'Nice'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**5. Compléter les listes du code ci-dessous pour représenter les points de coordonnées gps  de chacun des aéroports de la base de données(liste `X` des longitudes et liste `Y` des latitudes)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0xef48b0>]"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#5.\n",
    "from matplotlib import pyplot #bibliothèque pour tracer des graphiques\n",
    "\n",
    "X=[] #liste des longitudes\n",
    "Y=[] #liste des latitudes\n",
    "\n",
    "pyplot.figure(figsize = (14,7))\n",
    "pyplot.xlim(-180, 180) \n",
    "pyplot.ylim(-90, 90)\n",
    "\n",
    "pyplot.plot(X,Y,'rx') # g=green, x est une croix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**6. Recopier et modifier le code précédent pour faire apparaître en rouge les aéroports situés en zone tropicale (c'est à dire dont la latitude est comprise entre $-23$ et $+23$)et en bleu les autres**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "#5.Réponse\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <center> FIN </center>"
   ]
  }
 ],
 "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}