05_Fonctions_pratiques_pour_des_variables_complexes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Introduction à Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "> présentée par Loïc Messal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "## Quelques fonctions bien pratiques pour la manipulation d'itérables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Commençons avec un itérable simple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "un_iterable_simple = [\"JLR\", \"Jakarto\", \"CollPlan\", \"EvalWeb\", \"JLR\", \"JLR encore\", \"JLR toujours\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "un_iterable_simple.count(\"JLR\")  # Compte le nombre d'occurence d'un élément"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "un_iterable_simple.count(\"Jakarto cartographie 3d inc\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "un_iterable_simple.index(\"Jakarto\")  # Récupère l'index de la première occurence d'un élément"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "**Rappel: les index en python commencent à 0 !**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "un_iterable_simple.index(\"JLR\", 1)  # Récupère l'index de la prochaine occurence d'un élément à partir de l'index 1\n",
    "# Renvoie une erreur si l'élément ne se trouve pas dans la sous-liste"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Les prochaines méthodes sont bien utiles. Mais il faut les manipuler avec attention, car elles modifient directement l'objet sur lequel elles s'appliquent (pas de sauvegarde...)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "un_iterable_simple.reverse()  # Renverse l'ordre d'une liste (attention, modifie directement la liste)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['JLR toujours', 'JLR encore', 'JLR', 'EvalWeb', 'CollPlan', 'Jakarto', 'JLR']"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "un_iterable_simple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "un_iterable_simple.sort()  # Trie la liste dans l'ordre croissant"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['CollPlan', 'EvalWeb', 'JLR', 'JLR', 'JLR encore', 'JLR toujours', 'Jakarto']"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "un_iterable_simple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "les_plus_beaux = un_iterable_simple.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['CollPlan', 'EvalWeb', 'JLR', 'JLR', 'JLR encore', 'JLR toujours']"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "un_iterable_simple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Jakarto'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "les_plus_beaux"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Quelques fonctions avancées utiles, surtout quand on manipule des données. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'age': 23, 'employeur': 'Jakarto', 'nom': 'Messal', 'prénom': 'Loïc'},\n",
       " {'age': 17, 'employeur': 'Otrakaj', 'nom': 'Lassem', 'prénom': 'Ciol'},\n",
       " {'age': 20, 'employeur': 'Torakaj', 'nom': 'Alssem', 'prénom': 'Icol'}]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "un_iterable_complexe = []\n",
    "un_iterable_complexe.append({\"nom\": \"Messal\", \"prénom\": \"Loïc\", \"employeur\": \"Jakarto\", \"age\": 23})\n",
    "un_iterable_complexe.append({\"nom\": \"Lassem\", \"prénom\": \"Ciol\", \"employeur\": \"Otrakaj\", \"age\": 17})\n",
    "un_iterable_complexe.append({\"nom\": \"Alssem\", \"prénom\": \"Icol\", \"employeur\": \"Torakaj\", \"age\": 20})\n",
    "un_iterable_complexe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Appliquer une même fonction sur tous les items"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Supposons que l'on veuille récupérer l'age de l'ensemble de notre population dans une liste."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# solution naive\n",
    "recupere_age = []\n",
    "for item in un_iterable_complexe:\n",
    "    age = item[\"age\"]\n",
    "    recupere_age.append(age)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[23, 17, 20]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recupere_age"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "A priori, un proverbe québécois dit : \"Un mauvais ouvrier a toujours de mauvais outils.\" [source](http://citation-celebre.leparisien.fr/citations/29396)\n",
    "\n",
    "Il est désormais temps de commencer à s'équiper."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "On peut utiliser la compréhension des listes dans des cas simples :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "recupere_age = [item[\"age\"] for item in un_iterable_complexe]  # à utiliser lorsque cela reste simple à comprendre"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[23, 17, 20]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recupere_age"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "On peut aussi utiliser la fonction `map()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# solution avancée\n",
    "def age(item):\n",
    "    return item[\"age\"]\n",
    "\n",
    "recupere_age = map(age, un_iterable_complexe) # map() applique la fonction age à tous les éléments de l'itérable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<map at 0x1657a727780>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recupere_age"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "La fonction `map()` retourne un objet de type *map*. Convertissons le!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "recupere_age = list(recupere_age)  # Pour transformer explicitement l'objet map en liste\n",
    "# Attention, si on fait list(recupere_age) sans récupérer le résultat dans recupere_age,\n",
    "# recupere_age (en tant qu'objet map) sera un objet vide les prochaines fois qu'il sera utilisé\n",
    "# et list(recupere_age) sera alors une liste vide."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[23, 17, 20]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recupere_age"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Bien! La fonction `age()` est plutôt simple. A-t-on vraiment besoin d'avoir une telle fonction ? (Si vous avez pensé aux fonctions anonymes (`lambda`), vous avez de bons réflexes.)\n",
    "\n",
    "C'est le moment d'utiliser nos bons outils. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# solution élégante\n",
    "recupere_age = list(map(lambda x: x[\"age\"], un_iterable_complexe))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[23, 17, 20]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recupere_age"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Même principe pour filtrer les données"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Supposons que l'on veuille mettre les éléments ayant un age > 19 dans une liste."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# solution naive\n",
    "adultes_responsables = []\n",
    "for item in un_iterable_complexe:\n",
    "    if item[\"age\"] > 19:\n",
    "        adultes_responsables.append(item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'age': 23, 'employeur': 'Jakarto', 'nom': 'Messal', 'prénom': 'Loïc'},\n",
       " {'age': 20, 'employeur': 'Torakaj', 'nom': 'Alssem', 'prénom': 'Icol'}]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "adultes_responsables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# solution élégante\n",
    "adultes_responsables = list(filter(lambda x: x[\"age\"] > 19, un_iterable_complexe))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'age': 23, 'employeur': 'Jakarto', 'nom': 'Messal', 'prénom': 'Loïc'},\n",
       " {'age': 20, 'employeur': 'Torakaj', 'nom': 'Alssem', 'prénom': 'Icol'}]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "adultes_responsables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Simple. Clair. Efficace."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Trier une liste sans danger!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Supposons que l'on veuille trier les éléments selon leur age (par ordre croissant)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'age': 17, 'employeur': 'Otrakaj', 'nom': 'Lassem', 'prénom': 'Ciol'},\n",
       " {'age': 20, 'employeur': 'Torakaj', 'nom': 'Alssem', 'prénom': 'Icol'},\n",
       " {'age': 23, 'employeur': 'Jakarto', 'nom': 'Messal', 'prénom': 'Loïc'}]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# solution naive\n",
    "un_iterable_complexe_trie = []\n",
    "\n",
    "# on est capable d'ordonner la liste des ages, et on a la liste des personnes.\n",
    "# on peut donc parcourir la liste des ages triée, trouver la personne ayant cet age-là\n",
    "# il restera finalement à ajouter cette personne à la liste un_iterable_complexe_trie\n",
    "recupere_age.sort()\n",
    "\n",
    "\n",
    "for index in range(len(un_iterable_complexe)):\n",
    "    age_recherche = recupere_age[index]  # on récupère le index_ème age le plus petit \n",
    "    # on cherche l'item ayant cet âge là\n",
    "    item_trouve = None  # défini une variable vide dans laquelle on va mettre l'item ayant l'age recherché\n",
    "    for item in un_iterable_complexe:\n",
    "        if item[\"age\"] == age_recherche:\n",
    "            item_trouve = item\n",
    "            break  # On a trouvé l'item cherché, on peut arrêter la recherche\n",
    "    un_iterable_complexe_trie.append(item_trouve)\n",
    "\n",
    "un_iterable_complexe_trie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'age': 17, 'employeur': 'Otrakaj', 'nom': 'Lassem', 'prénom': 'Ciol'},\n",
       " {'age': 20, 'employeur': 'Torakaj', 'nom': 'Alssem', 'prénom': 'Icol'},\n",
       " {'age': 23, 'employeur': 'Jakarto', 'nom': 'Messal', 'prénom': 'Loïc'}]"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# solution un peu mieux (utilisation de filter)\n",
    "un_iterable_complexe_trie = []\n",
    "\n",
    "# on est capable d'ordonner la liste des ages, et on a la liste des personnes.\n",
    "# on peut donc parcourir la liste des ages triée, trouver la personne ayant cet age-là\n",
    "# il restera finalement à ajouter cette personne à la liste un_iterable_complexe_trie\n",
    "recupere_age.sort()\n",
    "\n",
    "\n",
    "for index in range(len(un_iterable_complexe)):\n",
    "    age_recherche = recupere_age[index]  # on récupère le index_ème age le plus petit \n",
    "    item_trouve = list(filter(lambda x: x[\"age\"] == age_recherche, un_iterable_complexe))  # on cherche l'item ayant cet âge là\n",
    "    un_iterable_complexe_trie = un_iterable_complexe_trie + item_trouve  # addition de deux listes\n",
    "\n",
    "un_iterable_complexe_trie"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Question :** Qu'arrive-t-il lorsque deux personnes ont le même âge ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'age': 23, 'employeur': 'Jakarto', 'nom': 'Messal', 'prénom': 'Loïc'},\n",
       " {'age': 17, 'employeur': 'Otrakaj', 'nom': 'Lassem', 'prénom': 'Ciol'},\n",
       " {'age': 20, 'employeur': 'Torakaj', 'nom': 'Alssem', 'prénom': 'Icol'},\n",
       " {'age': 20, 'employeur': 'Karotaj', 'nom': 'Inex', 'prénom': 'Istant'}]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "un_iterable_complexe = []\n",
    "un_iterable_complexe.append({\"nom\": \"Messal\", \"prénom\": \"Loïc\", \"employeur\": \"Jakarto\", \"age\": 23})\n",
    "un_iterable_complexe.append({\"nom\": \"Lassem\", \"prénom\": \"Ciol\", \"employeur\": \"Otrakaj\", \"age\": 17})\n",
    "un_iterable_complexe.append({\"nom\": \"Alssem\", \"prénom\": \"Icol\", \"employeur\": \"Torakaj\", \"age\": 20})\n",
    "un_iterable_complexe.append({\"nom\": \"Inex\", \"prénom\": \"Istant\", \"employeur\": \"Karotaj\", \"age\": 20})\n",
    "un_iterable_complexe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'age': 17, 'employeur': 'Otrakaj', 'nom': 'Lassem', 'prénom': 'Ciol'},\n",
       " {'age': 20, 'employeur': 'Torakaj', 'nom': 'Alssem', 'prénom': 'Icol'},\n",
       " {'age': 20, 'employeur': 'Karotaj', 'nom': 'Inex', 'prénom': 'Istant'},\n",
       " {'age': 20, 'employeur': 'Torakaj', 'nom': 'Alssem', 'prénom': 'Icol'},\n",
       " {'age': 20, 'employeur': 'Karotaj', 'nom': 'Inex', 'prénom': 'Istant'},\n",
       " {'age': 23, 'employeur': 'Jakarto', 'nom': 'Messal', 'prénom': 'Loïc'}]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# solution un peu mieux (utilisation de filter)\n",
    "un_iterable_complexe_trie = []\n",
    "\n",
    "# on est capable d'ordonner la liste des ages, et on a la liste des personnes.\n",
    "# on peut donc parcourir la liste des ages triée, trouver la personne ayant cet age-là\n",
    "# il restera finalement à ajouter cette personne à la liste un_iterable_complexe_trie\n",
    "recupere_age = list(map(lambda x: x[\"age\"], un_iterable_complexe))\n",
    "recupere_age.sort()\n",
    "\n",
    "\n",
    "for index in range(len(un_iterable_complexe)):\n",
    "    age_recherche = recupere_age[index]  # on récupère le index_ème age le plus petit \n",
    "    item_trouve = list(filter(lambda x: x[\"age\"] == age_recherche, un_iterable_complexe))  # on cherche l'item ayant cet âge là\n",
    "    un_iterable_complexe_trie = un_iterable_complexe_trie + item_trouve  # addition de deux listes\n",
    "\n",
    "un_iterable_complexe_trie"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "On a un nombre de personnes supérieures à la liste initiale...\n",
    "\n",
    "Alssem Icol et Inex Istant ont été ajouté deux fois chacun... parce que filter retourne une liste de taille 2."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Prenons alors un seul élément résultant du filtre."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# un peu mieux (utilisation de filter)\n",
    "un_iterable_complexe_trie = []\n",
    "\n",
    "# on est capable d'ordonner la liste des ages, et on a la liste des personnes.\n",
    "# on peut donc parcourir la liste des ages triée, trouver la personne ayant cet age-là\n",
    "# il restera finalement à ajouter cette personne à la liste un_iterable_complexe_trie\n",
    "recupere_age = list(map(lambda x: x[\"age\"], un_iterable_complexe))\n",
    "recupere_age.sort()\n",
    "\n",
    "\n",
    "for index in range(len(un_iterable_complexe)):\n",
    "    age_recherche = recupere_age[index]\n",
    "    correspondances = list(filter(lambda x: x[\"age\"] == age_recherche, un_iterable_complexe))\n",
    "    item_trouve = correspondances[0]  # récupération du premier élément filtré\n",
    "    un_iterable_complexe_trie.append(item_trouve)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'age': 17, 'employeur': 'Otrakaj', 'nom': 'Lassem', 'prénom': 'Ciol'},\n",
       " {'age': 20, 'employeur': 'Torakaj', 'nom': 'Alssem', 'prénom': 'Icol'},\n",
       " {'age': 20, 'employeur': 'Torakaj', 'nom': 'Alssem', 'prénom': 'Icol'},\n",
       " {'age': 23, 'employeur': 'Jakarto', 'nom': 'Messal', 'prénom': 'Loïc'}]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "un_iterable_complexe_trie"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Alssem Icol apparaît deux fois.\n",
    "\n",
    "Mais Inex Istant a disparu... Ce n'est pas la bonne solution !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "On sent bien qu'on est proche de la solution. Il faudrait simplement enlever l'item à chaque fois que nous l'avons utilisé."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'age': 17, 'employeur': 'Otrakaj', 'nom': 'Lassem', 'prénom': 'Ciol'},\n",
       " {'age': 20, 'employeur': 'Torakaj', 'nom': 'Alssem', 'prénom': 'Icol'},\n",
       " {'age': 20, 'employeur': 'Karotaj', 'nom': 'Inex', 'prénom': 'Istant'},\n",
       " {'age': 23, 'employeur': 'Jakarto', 'nom': 'Messal', 'prénom': 'Loïc'}]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# un peu mieux (utilisation de filter)\n",
    "un_iterable_complexe_trie = []\n",
    "\n",
    "# on est capable d'ordonner la liste des ages, et on a la liste des personnes.\n",
    "# on peut donc parcourir la liste des ages triée, trouver la personne ayant cet age-là\n",
    "# il restera finalement à ajouter cette personne à la liste un_iterable_complexe_trie\n",
    "recupere_age = list(map(lambda x: x[\"age\"], un_iterable_complexe))\n",
    "recupere_age.sort()\n",
    "\n",
    "\n",
    "for index in range(len(un_iterable_complexe)):\n",
    "    age_recherche = recupere_age[index]\n",
    "    correspondances = list(filter(lambda x: x[\"age\"] == age_recherche, un_iterable_complexe))\n",
    "    item_trouve = correspondances[0]  # récupération du premier élément filtré\n",
    "    un_iterable_complexe.remove(item_trouve)\n",
    "    un_iterable_complexe_trie.append(item_trouve)\n",
    "\n",
    "un_iterable_complexe_trie"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Tadaaa! Nous avons toutes nos personnes dans la liste triée par âge. Et maintenant affichons l'iterable initial !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "un_iterable_complexe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "En pensant résoudre un problème, vous en avez créé un autre. Félicitations, vous venez d'entrer dans le monde des développeurs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Reprenons notre configuration initiale, cette fois, en sauvegardant notre liste dans une temporaire que l'on modifiera à souhait.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'age': 23, 'employeur': 'Jakarto', 'nom': 'Messal', 'prénom': 'Loïc'},\n",
       " {'age': 17, 'employeur': 'Otrakaj', 'nom': 'Lassem', 'prénom': 'Ciol'},\n",
       " {'age': 20, 'employeur': 'Torakaj', 'nom': 'Alssem', 'prénom': 'Icol'},\n",
       " {'age': 20, 'employeur': 'Karotaj', 'nom': 'Inex', 'prénom': 'Istant'}]"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "un_iterable_complexe = []\n",
    "un_iterable_complexe.append({\"nom\": \"Messal\", \"prénom\": \"Loïc\", \"employeur\": \"Jakarto\", \"age\": 23})\n",
    "un_iterable_complexe.append({\"nom\": \"Lassem\", \"prénom\": \"Ciol\", \"employeur\": \"Otrakaj\", \"age\": 17})\n",
    "un_iterable_complexe.append({\"nom\": \"Alssem\", \"prénom\": \"Icol\", \"employeur\": \"Torakaj\", \"age\": 20})\n",
    "un_iterable_complexe.append({\"nom\": \"Inex\", \"prénom\": \"Istant\", \"employeur\": \"Karotaj\", \"age\": 20})\n",
    "un_iterable_complexe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# solution potable\n",
    "un_iterable_complexe_trie = []\n",
    "\n",
    "# on est capable d'ordonner la liste des ages, et on a la liste des personnes.\n",
    "# on peut donc parcourir la liste des ages triée, trouver la personne ayant cet age-là\n",
    "# il restera finalement à ajouter cette personne à la liste un_iterable_complexe_trie\n",
    "recupere_age = list(map(lambda x: x[\"age\"], un_iterable_complexe))\n",
    "recupere_age.sort()\n",
    "\n",
    "# Copie naive d'une liste\n",
    "une_copie_d_un_iterable_complexe = []\n",
    "for item in un_iterable_complexe:\n",
    "    une_copie_d_un_iterable_complexe.append(item)\n",
    "\n",
    "for index in range(len(une_copie_d_un_iterable_complexe)):\n",
    "    age_recherche = recupere_age[index]\n",
    "    correspondances = list(filter(lambda x: x[\"age\"] == age_recherche, une_copie_d_un_iterable_complexe))\n",
    "    item_trouve = correspondances[0]  # récupération du premier élément filtré\n",
    "    une_copie_d_un_iterable_complexe.remove(item_trouve)\n",
    "    un_iterable_complexe_trie.append(item_trouve)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'age': 17, 'employeur': 'Otrakaj', 'nom': 'Lassem', 'prénom': 'Ciol'},\n",
       " {'age': 20, 'employeur': 'Torakaj', 'nom': 'Alssem', 'prénom': 'Icol'},\n",
       " {'age': 20, 'employeur': 'Karotaj', 'nom': 'Inex', 'prénom': 'Istant'},\n",
       " {'age': 23, 'employeur': 'Jakarto', 'nom': 'Messal', 'prénom': 'Loïc'}]"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "un_iterable_complexe_trie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'age': 23, 'employeur': 'Jakarto', 'nom': 'Messal', 'prénom': 'Loïc'},\n",
       " {'age': 17, 'employeur': 'Otrakaj', 'nom': 'Lassem', 'prénom': 'Ciol'},\n",
       " {'age': 20, 'employeur': 'Torakaj', 'nom': 'Alssem', 'prénom': 'Icol'},\n",
       " {'age': 20, 'employeur': 'Karotaj', 'nom': 'Inex', 'prénom': 'Istant'}]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "un_iterable_complexe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "On a enfin trouvé une solution!\n",
    "\n",
    "Ce qu'on constate, c'est qu'il devient rapidement compliqué de trier une liste lorsqu'on souhaite trier selon une caractéristique d'un item. C'est pour cela que la fonction `sorted()` a été inventée."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'age': 17, 'employeur': 'Otrakaj', 'nom': 'Lassem', 'prénom': 'Ciol'},\n",
       " {'age': 20, 'employeur': 'Torakaj', 'nom': 'Alssem', 'prénom': 'Icol'},\n",
       " {'age': 20, 'employeur': 'Karotaj', 'nom': 'Inex', 'prénom': 'Istant'},\n",
       " {'age': 23, 'employeur': 'Jakarto', 'nom': 'Messal', 'prénom': 'Loïc'}]"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# solution élégante\n",
    "sorted(un_iterable_complexe, key=lambda x: x[\"age\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Et en une ligne, vous avez obtenu le résultat espéré. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Et si vous vouliez trier votre liste par âge, puis par employeur en cas d'égalité (cela suppose qu'il existe une relation d'ordre sur les valeurs de la clé *employeur*)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Dans notre cas, la relation d'ordre existe bien. Pour les chaines de caractère, la relation d'ordre par défaut est l'ordre alphabétique."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'age': 17, 'employeur': 'Otrakaj', 'nom': 'Lassem', 'prénom': 'Ciol'},\n",
       " {'age': 20, 'employeur': 'Karotaj', 'nom': 'Inex', 'prénom': 'Istant'},\n",
       " {'age': 20, 'employeur': 'Torakaj', 'nom': 'Alssem', 'prénom': 'Icol'},\n",
       " {'age': 23, 'employeur': 'Jakarto', 'nom': 'Messal', 'prénom': 'Loïc'}]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(un_iterable_complexe, key=lambda x: (x[\"age\"], x[\"employeur\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Grâce au lambda qui retourne désormais un tuple \"d'importance\", on obtient un super ordonnancement de notre liste."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Simple. Clair. Très efficace."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Note : si vous ressentez un drôle de sentiment, que vous trouvez la solution belle et qu'elle vous fait sourire, alors soit :\n",
    "- vous avez véritablement l'âme d'un programmeur et un bel avenir dans ce domaine s'offre à vous\n",
    "- fuyez tant qu'il est encore temps\n",
    "        \n",
    "si cela ne vous fait aucun effet, alors soit:\n",
    "- vous avez déjà connu ce sentiment (avec les mathématiques, probablement)\n",
    "- le développement informatique n'est pas fait pour vous\n",
    "- il vous en faut peut-être plus ? ;)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "[Prochain chapitre : La Programmation Orientée Objet](06_La_Programmation_Orientée_Objet.ipynb)"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}