01-point-sur-les-types.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from IPython.core.display import HTML\n",
    "\n",
    "def _set_css_style(css_file_path):\n",
    "   \"\"\"\n",
    "   Read the custom CSS file and load it into Jupyter.\n",
    "   Pass the file path to the CSS file.\n",
    "   \"\"\"\n",
    "\n",
    "   styles = open(css_file_path, \"r\").read()\n",
    "   s = '<style>%s</style>' % styles     \n",
    "   return HTML(s)\n",
    "\n",
    "_set_css_style('custom/custom.css')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<div style='float:center; margin-right:20pt; width:30em'><img src='img/logo-igm.png'></div>\n",
    "<div style='float:center; font-size:large'>\n",
    "    <strong>Algorithmique et programmation 2</strong><br>\n",
    "    L1 Mathématiques - L1 Informatique<br>\n",
    "    Semestre 2\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Préambule : contenu du cours AP2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Algorithmique :\n",
    "\n",
    "- Récursivité\n",
    "- Éléments de complexité algorithmique\n",
    "- Algorithmes de recherche (dichotomie...)\n",
    "- Algorithmes de tri et applications\n",
    "- Piles et files (implémentation, applications...) <span class=remarque>— si on a le temps</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Programmation :\n",
    "\n",
    "- Le point sur les types Python\n",
    "- De nouveaux types (dictionnaires, ensembles...)\n",
    "- Détails sur les fonctions\n",
    "- Tests, mesures de performance, débuggage...\n",
    "- Nouvelles fonctionnalités du langage (classes...) <span class=remarque>— si on a le temps</span>\n",
    "\n",
    "Et toujours [fltk](https://antoinemeyer.frama.io/fltk/) pour les interface graphiques *(attention ! nouvelle version parue ce mois-ci !)*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Volume et évaluation :\n",
    "\n",
    "- 9 * (cours de 2h + TD de 2h + TP de 2h)\n",
    "- Note finale : contrôle continu intégral (détails à préciser)\n",
    "    - 2 à 4 devoirs sur table\n",
    "    - note pratique (présentation des TP) : bonus (0 à 2 pts)\n",
    "- 5 ECTS\n",
    "- mécanisme de remédiation + CC complémentaire (comme au S1)\n",
    "- <div class=defterm>UE de projet séparée</div> (PR2, sur 2 ECTS, 3 dernières semaines)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Dates des CC :\n",
    "\n",
    "- CC1 le 26 février\n",
    "- CC2 le 5 avril\n",
    "- CC3 le 13 mai"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Quelques conseils\n",
    "\n",
    "- Venez à toutes les séances (cours, TD, TP)\n",
    "- Faites le maximum d'exos en TD, en TP et chez vous\n",
    "- Posez des questions à vos profs (Discord, forum, mail)\n",
    "- Pratiquez en dehors des cours  \n",
    "  <span class=remarque>(nombreux outils en ligne disponibles : PLaTon, http://www.sololearn.com/, http://projecteuler.net/, http://codingame.com...)</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Le point sur les types en Python\n",
    "\n",
    "Références :\n",
    "- https://docs.python.org/fr/3/library/stdtypes.html\n",
    "- https://docs.python.org/fr/3/reference/datamodel.html (début)\n",
    "- https://docs.python.org/fr/3/reference/executionmodel.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Variables, le retour\n",
    "\n",
    "- Une **valeur** est un objet présent dans la mémoire  \n",
    "  <span class=remarque>(plus de détails plus bas)</span>\n",
    "- Une **variable** Python est un **nom** associé à une valeur\n",
    "- Cette association est **temporaire**\n",
    "- L'action d'associer une valeur à un nom est l'**affectation**\n",
    "- Une même variable peut désigner plusieurs valeurs successives"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "a = 2             # a désigne un entier\n",
    "print(a, type(a))\n",
    "\n",
    "a = 'salut !'     # a désigne une chaîne\n",
    "print(a, type(a))\n",
    "\n",
    "a = [2, 3, 4]     # a désigne une liste\n",
    "print(a, type(a))\n",
    "\n",
    "b = a             # a et b désignent le même objet\n",
    "b[1] = 1\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice \n",
    "- Dessiner l'état de la mémoire après l'exécution de la cellule suivante.\n",
    "- Quelle est la valeur finale de `lst2` ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 1\n",
    "lst = [a, a, a]\n",
    "a = 2\n",
    "lst2 = [lst, lst, a]\n",
    "lst2[0][0] = a\n",
    "lst[1] = 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Espaces de noms\n",
    "\n",
    "- Un ensemble de noms définis en un point du programme est un **espace de noms**\n",
    "- Plusieurs espaces de noms \"imbriqués\" :\n",
    "    - L'espace de nom *local* pendant un appel de fonction\n",
    "    - L'espace de nom *global* (module principal)\n",
    "    - L'espace des noms *prédéfinis* ou **built-ins**  \n",
    "      <span class=remarque>(ex : `print, True, min, ...`)</span>\n",
    "    - *Éventuellement d'autres espaces intermédiaires*\n",
    "- Dans chaque contexte on a accès aux espaces de noms extérieurs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "dir()  # noms de l'espace global"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "globals()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def f(truc, machin):\n",
    "    chose = [4, 5]\n",
    "    print(locals())  # noms de l'espace local\n",
    "\n",
    "f(1, 5)\n",
    "print(chose)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "dir(__builtin__)  # espace des noms prédéfinis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Import de noms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La commande `import` permet de charger de nouveaux noms (d'objets de tous types) dans l'espace de noms courant"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import math\n",
    "dir(math)  # espace de noms du module math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(math)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "math.pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "math.cos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plutôt que d'importer un module entier on peut choisir certains de ses éléments (ou tous)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import pi, cos\n",
    "cos(pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Attention, si l'on importe un nom à l'intérieur d'une fonction, ce nom n'existe que dans l'espace de noms local !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def foo():\n",
    "    from math import tan\n",
    "    return tan(pi/4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "foo()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tan(pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Valeurs = objets\n",
    "\n",
    "En Python, *tout* (un entier, une liste, une fonction) est un **objet**\n",
    "- Chaque valeur (chaque objet, donc) consiste en un\n",
    "  **type** et des **données** (ou **attributs**)\n",
    "- Chaque objet manipulé est créé en **mémoire**, puis\n",
    "  détruit quand il n'est plus utilisé\n",
    "- Chaque objet possède un **identifiant entier** unique accessible par la fonction `id()` (*\"numéro d'identification\"*, assimilable à une *adresse*)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "a = 14\n",
    "b = 7\n",
    "print(id(a), id(b))\n",
    "b = a\n",
    "print(id(a), id(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Nouvel opérateur :** `is` / `is not` compare les `id` de deux objets\n",
    "- `exp1 == exp2` teste si deux objets sont \"égaux\"\n",
    "- `exp1 is exp2` teste si `exp1` et `exp2` désignent le **même** objet dans la mémoire"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "a = 14\n",
    "b = 7\n",
    "print(a == b, a is b)\n",
    "b = a\n",
    "print(a == b, a is b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "a = []\n",
    "b = []\n",
    "print(a == b, a is b)\n",
    "b = a\n",
    "print(a == b, a is b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "a = []\n",
    "b = []\n",
    "a.append(1)\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "a = []\n",
    "b = a\n",
    "a.append(1)\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Retour sur les mécanismes de base\n",
    "\n",
    "#### Affectation : `var = expr`\n",
    "\n",
    "- Calculer `expr` renvoie un objet `obj` stocké en mémoire\n",
    "- (Si `var` n'existe pas, on la crée dans l'espace de noms courant)\n",
    "- On associe `id(obj)` à `var` dans l'espace de noms courant"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Cas particulier : `var1 = var2` :\n",
    "- On associe simplement à `var1` l'identifiant `id(var2)`\n",
    "- On obtient deux noms faisant référence au même objet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Passage de paramètre : `f(a1, a2, a3)`\n",
    "\n",
    "\n",
    "Lors d'un appel de la forme `f(e1, e2, e3...)` :\n",
    "  - Les trois expressions `e1`, `e2`, `e3`... sont\n",
    "    évaluées en des objets `o1`, `o2`, `o3`...\n",
    "  - On associe aux noms `a1`, `a2`, `a3`... les identifiants `id(o1)`, `id(o2)`, `id(o3)`...\n",
    "    dans l'espace de noms local de `f`\n",
    "  - Il n'y a pas de création de nouveaux objets !\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def pgcd(a, b):\n",
    "    while b != 0:\n",
    "        a, b = b, a%b\n",
    "    return a\n",
    "\n",
    "m = (2*5)*2*5*5\n",
    "n = (2*5)*3*3*7\n",
    "res = pgcd(m, n)\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Retour de fonction : `return expr`\n",
    "\n",
    "  - L'expression `expr` est évaluée en un objet `obj`\n",
    "  - L'identifiant `id(obj)` est transmis au site d'appel, qui\n",
    "      en fait ce qu'il veut (`print`, affectation, usage dans une expression...)\n",
    "  - L'objet n'est pas dupliqué au moment du `return` !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Le point sur les types\n",
    "\n",
    "- Il existe plusieurs grandes catégories d'objets : nombres\n",
    "    (`int`, `float`...), séquences (`list`, `str`,\n",
    "    `tuple`), etc.\n",
    "- Le type d'un objet détermine ce qu'on a le droit de faire avec\n",
    "- Documentation : https://docs.python.org/fr/3/library/stdtypes.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Chaque type a un certain nombre de caractéristiques :\n",
    "    \n",
    "- Numérique ou pas ?\n",
    "- Collection / conteneur ou pas ?\n",
    "- Séquentiel ou non ?\n",
    "- Itérable ou non ?\n",
    "- Modifiable (mutable) ou non ?\n",
    "    \n",
    "**Exercice :** donnez les caractéristiques de chaque type Python que vous connaissez"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Booléens (`bool`)\n",
    "  \n",
    "- Type numérique et immutable\n",
    "- Nombreuses opérations entre booléens ou produisant des booléens\n",
    "    - opérateurs logiques (`and`, `or`, `not`)\n",
    "    - comparaison, égalité, etc.\n",
    "- **Attention :** comparer deux valeurs de type différent\n",
    "    donne en général `False` ou une erreur -- sauf pour les nombres"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "1 == 1.0  # exception !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'1' == 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "'1' <= 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Aspect paresseux (*lazy*) des opérateurs logiques"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice :** cette fonction est-elle juste quelle que soit la valeur de `lst` ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def commence_par_un(lst):\n",
    "    return lst[0] == 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "commence_par_un([])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Même question :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def commence_par_un(lst):\n",
    "    return lst[0] == 1 and len(lst) > 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Même question :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def commence_par_un(lst):\n",
    "    return len(lst) > 0 and lst[0] == 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "commence_par_un([])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice :** écrire sur le même modèle une fonction `ne_commence_pas_par_un` (sans utiliser `if` ni l'opérateur `not`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ne_commence_pas_par_un(lst):\n",
    "    return len(lst) == 0 or lst[0] != 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ne_commence_pas_par_un([])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ne_commence_pas_par_un([1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ne_commence_pas_par_un([2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Explication : équivalent avec `if`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Opérateur `a and b` à peu près équivalent à la fonction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fonction_and(a, b):\n",
    "    if a:\n",
    "        return b\n",
    "    else:\n",
    "        return a  # on n'a pas évalué b !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "et `or` à la fonction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fonction_or(a, b):\n",
    "    if a:\n",
    "        return a  # on n'a pas évalué b !\n",
    "    else:\n",
    "        return b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Deuxième exemple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice :** corriger cette fonction pour qu'elle soit correcte même si `n == 0`, sans utiliser `if`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def matiere_validee(total, n):\n",
    "    return (total / n) >= 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Interprétation booléenne des autres types\n",
    "\n",
    "En Python toute valeur peut être interprétée comme vraie ou fausse  \n",
    "(en général, 0 ou séquence vide interprétés comme `False`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "if 0 or 0.0 or '' or [] or {}:\n",
    "    ...  # jamais exécuté\n",
    "else:\n",
    "    print(\"Toutes ces valeurs veulent dire False !\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "if 1 and 0.01 and 'a' and [42] and {1:1}:\n",
    "    print(\"Toutes ces valeurs veulent dire True !\")\n",
    "else:\n",
    "    ...  # jamais exécuté"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Un dernier exemple bizarre"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"patate\" and \"courgette\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"patate\" or \"courgette\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Nombres (`int`, `float`, `complex`)\n",
    "  \n",
    "- Types numériques et immutables\n",
    "- Nombreuses opérations arithmétiques disponibles"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Type `int`\n",
    "\n",
    "- Nombres entiers arbitrairement grands  \n",
    "  *(attention au coût en calcul !)*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "2 ** 10000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "# %%time permet de chronométrer la cellule dans Jupyter\n",
    "s = sum(range(n, n+10000))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 2**10000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "s = sum(range(n, n+10000))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Optimisation pour les petits entiers : un seul objet  par entier entre -5 et 256\n",
    "  (pré-alloué et partagé), plusieurs objets de même valeur au-delà"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# Les \"petits\" entiers sont partagés en mémoire\n",
    "a = 256\n",
    "b = 256\n",
    "a is b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Les \"grands\" entiers ne le sont pas\n",
    "a = 257\n",
    "b = 257\n",
    "a is b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Type `float`\n",
    "\n",
    "- Nombres à \"virgule flottante\"  \n",
    "  *(précision et amplitude limitées)*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# Les flottants ont une précision limitée\n",
    "0.1 * 3 == 0.3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "0.1 * 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "0.3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "2.0 ** 1024  # avec 1023 ça passe !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "2.0 ** -1075  # avec -1074 ça passe !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Type `complex`\n",
    "\n",
    "- Nombres complexes à partie réelle et\n",
    "  imaginaire flottante  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# On peut manipuler directement des nombres complexes\n",
    "3+5j"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "(3+5j) * (2 + 1j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "(3 + 5j).imag"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# Mais il faut prendre la bonne version des fonctions...\n",
    "from math import sqrt\n",
    "sqrt(-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "from cmath import sqrt\n",
    "sqrt(-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Autres types numériques\n",
    "\n",
    "- `Fraction` : nombres rationnels\n",
    "- `Decimal` : nombres à virgule en précision arbitraire\n",
    "- ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "from fractions import Fraction\n",
    "3 * Fraction(1, 10) == Fraction(3, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "from decimal import Decimal\n",
    "3 * Decimal(1) / Decimal(10) == Decimal(3) / Decimal(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plus de détails en L2 dans l'UE \"Labo math-info\" !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Chaînes  (`str`)\n",
    "  \n",
    "- Type conteneur, séquence, itérable et immutable\n",
    "- Chaînes de caractères non modifiables (codage [UTF-8](https://en.wikipedia.org/wiki/UTF-8))\n",
    "- [Très nombreuses méthodes](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)  \n",
    "  *recherche, remplacement, découpe, changement de casse, etc.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "s = \"Ceci   est un exemple   de  chaîne.\"\n",
    "lst = s.split()\n",
    "lst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "t = \" |-> \".join(lst)\n",
    "t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Optimisation pour certaines chaînes courtes : un seul objet partagé"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "a = \"abc\"\n",
    "b = \"abc\"\n",
    "a is b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a = \"a\" * 4097\n",
    "b = \"a\" * 4097\n",
    "a is b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Peuvent s'écrire sur plusieurs lignes avec `'''` ou `\"\"\"`  \n",
    "  *utile pour documenter des fonctions (docstrings)*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def pgcd(a, b):\n",
    "    \"\"\"Calcule le pgcd de deux nombres entiers.\n",
    "    \n",
    "    Paramètres :\n",
    "    a : int\n",
    "    b : int\n",
    "    Retour : plus grand diviseur commun à a et b\n",
    "    \n",
    "    >>> pgcd(8, 9)\n",
    "    1\n",
    "    \n",
    "    >>> pgcd(12, 18)\n",
    "    6\n",
    "    \"\"\"\n",
    "    while b:\n",
    "        a, b = b, a % b\n",
    "    return a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "pgcd?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "help(pgcd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "from turtle import forward\n",
    "help(forward)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "-   Test automatique des exemples contenus dans les *docstrings* : module `doctest`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "from doctest import testmod\n",
    "testmod(verbose=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Listes  (`list`)\n",
    "\n",
    "- Type conteneur, séquence, itérable et mutable\n",
    "- Listes hétérogènes d'objets (chaque \"case\" contient en\n",
    "    fait un `id` d'objet)\n",
    "- Nombreuses méthodes disponibles pour chercher, agrandir,\n",
    "    rétrécir, trier, etc.\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Exercice\n",
    "\n",
    "- `lst[i:j:k]` construit une liste des éléments\n",
    "  d'indice `i` à `j-1` de `lst` par pas de `k`\n",
    "- Écrire une fonction `tranche(lst, i, j, k)` qui\n",
    "  fasse la même chose **sans modifier `lst` !**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def tranche(lst, i, j, k):\n",
    "    \"\"\"Extrait une sous-liste de lst contenant\n",
    "    ses éléments d'indices compris entre i et j-1\n",
    "    par pas de k.\n",
    "    \"\"\"\n",
    "    res = []\n",
    "    for l in range(i, j, k):\n",
    "        res.append(lst[l])\n",
    "    return res\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = list(\"abcdefghijklmnop\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tranche(lst, 10, 1, -1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def tranche(lst, i, j, k):\n",
    "    \"\"\"Extrait une sous-liste de lst contenant\n",
    "    ses éléments d'indices compris entre i et j-1\n",
    "    par pas de k.\n",
    "    \"\"\"\n",
    "    # doit renvoyer une liste !\n",
    "    res = []\n",
    "    # init. var. de boucle\n",
    "    ell = i\n",
    "    while ell < j :\n",
    "        res.append(lst[ell])\n",
    "        # incrément\n",
    "        ell = ell + k\n",
    "    return res\n",
    "\n",
    "ma_liste = [n**3 for n in range(10)]\n",
    "print(ma_liste)\n",
    "print(tranche(ma_liste, 3, len(ma_liste)-2, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Exemples d'usage de listes :\n",
    "\n",
    "- Liste des lignes d'un fichier : `f.readlines()`\n",
    "- Liste défilante dans un formulaire\n",
    "- Liste des diviseurs d'un nombre\n",
    "- Liste des arguments d'une fonction\n",
    "- Balayage de fonction en analyse (valeurs de $f$ par pas de 0.01)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### ★ Exercice : *list comprehensions* (mutations de listes)\n",
    "\n",
    "Si `f` et `p` sont deux fonctions à un argument, l'écriture  `[f(x) for x in iterable if p(x)]`  renvoie la liste des éléments `x` de `iterable` tels que `p(x)` vaut `True`, auxquels on a appliqué `f`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[abs(n) for n in range(-10, 10) if n % 3 == 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Programmer une fonction `mapfilter(iterable, f, p)` construisant et renvoyant cette liste. Exemple :\n",
    "```python\n",
    ">>> mapfilter([-1, -2, 3, 1, -4], abs, odd)\n",
    "[1, 3, 1]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mapfilter(iterable, f, p):\n",
    "    ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def odd(x):\n",
    "    return x % 2 == 1\n",
    "\n",
    "mapfilter([-1, -2, 3, 1, -4], abs, odd)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Dictionnaires (`dict`)\n",
    "\n",
    "**Définition :**   Objet associant une liste de *clés* (*keys*) à des *valeurs*\n",
    "    (*values*)\n",
    "    \n",
    "https://docs.python.org/fr/3/tutorial/datastructures.html#dictionaries\n",
    "    \n",
    "- Création d'un dictionnaire vide"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "vide = {}    # dictionnaire vide\n",
    "vide"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "vide = dict()   # idem\n",
    "vide"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Création d'un dictionnaire contenant des éléments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "effectif_groupes = {'a': 31, 'bidule': 28.5, \n",
    "                    'c': 33, 9: 18, 'Prépa': 22}\n",
    "effectif_groupes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Test d'appartenance d'une clé"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "'Prépa' in effectif_groupes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "31 in effectif_groupes  # 31 est une valeur, pas une clé !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Accès à une clé :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "effectif_groupes['Prépa']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "effectif_groupes[31]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Modification ou création d'une clé"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "effectif_groupes['Prépa'] = 23\n",
    "effectif_groupes['A'] = 150\n",
    "effectif_groupes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Objets *itérables* (comme les listes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "d = {'a': 1, 'b': 42, 'c': 9}\n",
    "for cle in d:\n",
    "    print(cle, '->', d[cle])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "-   Peuvent être imbriqués (comme les listes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "d2 = {'type': 'un dico', 'contenu': d, 'taille': len(d)}\n",
    "d2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Dictionnaires *vs.* listes\n",
    "\n",
    "-   Insertion et suppression *en général* (beaucoup) plus rapides\n",
    "-   Accès *en général* presque aussi rapide\n",
    "-   Collections *mutables* et *hétérogènes* (comme les `list`)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Attention :**\n",
    "-   Clés obligatoirement immutables, mais peuvent être de plusieurs types différents\n",
    "-   Valeurs de types quelconques (même mutables)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "d = {True: 1, 'bidule': True, 3.14: 'pi', None: 0}\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "d[99] = [1, 2, 3, 'nous irons...']\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "d[[0, 0]] = \"origine\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "d[(0, 0)] = \"origine\"\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Opérations (résumé)\n",
    "\n",
    "- Création   `d = {}` ou `d = dict()` ou `d = {’a’: 1, ...}`\n",
    "- Accès : `d[cle]`, `d[cle1][cle2]`, ...\n",
    "- Taille : `len(d)`\n",
    "- Test d'appartenance : `cle in d`, `cle not in d`      \n",
    "- Ajout ou modification : `d[cle] = valeur`\n",
    "- Suppression : `del d[cle]`\n",
    "- Itération : `for cle in d`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Méthodes\n",
    "\n",
    "- Accès aux clés : `d.keys()`\n",
    "- Accès aux valeurs : `d.values()`\n",
    "- Accès aux couples `(cle, valeur)` : `d.items()`            \n",
    "- Copie (superficielle) : `d.copy()`             \n",
    "- Vidange : `d.clear()`\n",
    "- Accès avec valeur par défaut : `d.get(cle, defaut)`\n",
    "- Retrait de valeur : `d.pop(cle)`           \n",
    "- Mise à jour / fusion : `d.update(d2)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "for cle in d.keys():\n",
    "    print(cle)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "list(d.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "list(d.values())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "list(d.items())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "d.get('machin', 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "d.pop(3.14)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "d[3.14]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Attention :** la méthode `copy` produit une copie *superficielle* !!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "d = {'lst': [1, 2]}\n",
    "e = d.copy()\n",
    "e['lst'].append(3) \n",
    "print(d)\n",
    "print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Un exemple : comptage de lettres"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def compte_lettres(chaine):\n",
    "    d = dict()\n",
    "    for car in chaine:\n",
    "        if car in d:\n",
    "            d[car] += 1\n",
    "        else:\n",
    "            d[car] = 1\n",
    "    return d\n",
    "\n",
    "s = \"Les chaussettes de l'archi-duchesse sont elles sèches ? Archi-sèches.\"\n",
    "print(compte_lettres(s))\n",
    "s = 'exemple'\n",
    "print(compte_lettres(s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def compte_lettres(chaine):\n",
    "    d = dict()\n",
    "    for car in chaine:\n",
    "        # plus pro, plus beau\n",
    "        d[car] = d.get(car, 0) + 1\n",
    "    return d\n",
    "\n",
    "s = \"Les chaussettes de l'archi-duchesse sont elles sèches ? Archi-sèches.\"\n",
    "print(compte_lettres(s))\n",
    "s = 'exemple'\n",
    "print(compte_lettres(s))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Afficher les éléments par ordre croissant de clés"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "d = compte_lettres('exemple')\n",
    "cles = list(d.keys())\n",
    "cles.sort()\n",
    "for cle in cles:\n",
    "    print(cle, '->', d[cle])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# ou :    \n",
    "for cle in sorted(d.keys()):\n",
    "    print(cle, '->', d[cle])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Un autre exemple : carte de visite"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "carte = {'prenom': 'Antoine',\n",
    "         'nom': 'Meyer',\n",
    "         'email': '<antoine.meyer@univ-eiffel.fr>'}\n",
    "\n",
    "def affiche_carte(carte):\n",
    "    print(\"Bonjour,\")\n",
    "    print(\"Je m'appelle\", carte['prenom'], carte['nom'], '. ')\n",
    "    print(\"Mon adresse email est\", carte['email'], end='.\\n')\n",
    "\n",
    "affiche_carte(carte)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### ★ Un dernier exemple : implémentation des espaces de noms\n",
    "\n",
    "- Un espace de noms associe en réalité à chaque variable\n",
    "    l'identifiant de l'objet associé\n",
    "- Conceptuellement semblable à un dictionnaire\n",
    "    - Clés : noms actuellement définis\n",
    "    - Valeurs : identifiants des objets correspondants\n",
    "- En fait, dans l'implémentation courante de Python, ce *sont* des dictionnaires"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import math\n",
    "math.__dict__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Dictionnaires : pour résumer\n",
    "\n",
    "- Type conteneur, non séquentiel, itérable et mutable\n",
    "- Associations de clés (immutables !) avec des valeurs    (quelconques)\n",
    "- Opération très rapide : recherche d'élément"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Exercices\n",
    "\n",
    "- Écrire, sans utiliser la méthode `items()`, une fonction `dict_vers_list(dico)` recevant en paramètre un dictionnaire et renvoyant une liste de ses couples `(cle, valeur)`.\n",
    "- Écrire, sans utiliser la fonction `dict()`, une fonction `list_vers_dict(lst)` recevant en paramètre une liste de couples `(cle, valeur)` et renvoyant le dictionnaire correspondant."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- $\\bigstar$ Écrire une fonction `inverse_dict(dico)` renvoyant un nouveau dictionnaire dont les clés sont les valeurs de `dico` et les valeurs sont les listes de clés correspondantes. On supposera que toutes les valeurs de `dico` sont immutables.  \n",
    "  Par exemple :\n",
    "\n",
    "  ```python\n",
    "  >>> inverse_dict({'a': 1, 'b': 2, 'c': 1})\n",
    "  {1: ['a', 'c'], 2: ['b']}\n",
    "  ```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "def inverse_dict(dico):\n",
    "    ...\n",
    "\n",
    "inverse_dict({'a': 1, 'b': 2, 'c': 1})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Tuples (`tuple`)\n",
    "  \n",
    "- Type conteneur, séquence, itérable et immutable\n",
    "- Listes hétérogènes d'objets  \n",
    "  (chaque \"case\" contient un `id` d'objet)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "triplet = (35, 6, 89)\n",
    "len(triplet)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "singleton = (12)  # ne marche pas !!\n",
    "len(singleton)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "singleton = (12,)  # attention à la virgule !\n",
    "len(singleton)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "vide = ()\n",
    "len(vide)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Fonctionnent comme des listes, mais interdisent toute modification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "triplet[0] = 9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "lst = list(triplet)\n",
    "lst[0] = 9"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Contrairement aux listes, peuvent servir de clés dans un\n",
    "    dictionnaire    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "horaires = dict()\n",
    "horaires[('Paris', 'Brest')] = [(9, 25), (10, 31), ...]\n",
    "print(horaires)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Souvent utilisés pour permettre à une fonction de renvoyer plusieurs valeurs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def minmax(a, b):\n",
    "    return min(a, b), max(a, b)\n",
    "\n",
    "minmax(12, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "divmod(18, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Ensembles (`set`) \n",
    "  \n",
    "- Type conteneur, non séquentiel, itérable et mutable\n",
    "- Ensembles au sens mathématique (au plus 1 occurrence de chaque objet : pas de doublons !)\n",
    "- Nombreuses opérations (union, intersection, inclusion...)\n",
    "- Semblables à des dictionnaires sans *valeurs* (uniquement clés)\n",
    "- Variante immutable (`frozenset`) pouvant servir de clé de dictionnaire"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "ensemble = {1, 2, 1, 1, 4}\n",
    "ensemble"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "ensemble = set([1, 2, 1, 1, 4])\n",
    "ensemble"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "{1, 2, 3} | {3, 4}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "{1, 2, 3} & {3, 4}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "{1, 3} < {1, 3, 4}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "{1, 2} < {2, 3}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Exemples d'usages  d'ensembles :\n",
    "    \n",
    "- Ensemble des adresses IP ayant visité une page web\n",
    "- Ensemble des mots contenus dans un texte"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Conclusion : les types Python\n",
    "\n",
    "  Les types prédéfinis sont l'une des grandes forces de Python :\n",
    "  \n",
    "- Suffisamment simples pour être appris rapidement\n",
    "- Suffisamment puissants pour représenter beaucoup de choses\n",
    "- Combinables à volonté"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Il y en a encore d'autres dont on n'a pas (re)parlé ici :\n",
    "\n",
    "- descripteurs de fichiers (type `file`)\n",
    "- intervalles (type `range`)\n",
    "- etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Exercice\n",
    "\n",
    "Imaginer des exemples d'usage :\n",
    "\n",
    "- D'une liste de listes\n",
    "- D'une liste d'ensembles\n",
    "- D'une liste de listes de listes\n",
    "- D'un dictionnaire de listes\n",
    "- D'un dictionnaire de dictionnaires de listes \n",
    "- D'un dictionnaire ayant pour clés des `frozenset` \n",
    "- etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "#### Réponses possibles\n",
    "\n",
    "- Liste de listes : matrice, contenu des cases d'un damier ou plateau de jeu (Cf. projet d'AP1)\n",
    "- Liste d'ensembles : liste de groupes de personnes\n",
    "- Liste de listes de listes : matrice 3D, plan Minecraft\n",
    "- Dictionnaire de listes : index de livre\n",
    "- Dictionnaire de dictionnaires : listes d'ingrédients, lexiques en plusieurs langues\n",
    "- Dictionnaire de dictionnaires de listes : liste des horaires de trains de A vers B\n",
    "- Dictionnaire ayant pour clés des `frozenset` : listes ou ensembles de mots ayant un certain ensemble de lettres\n",
    "- Liste de dictionnaires : historique de commandes de produits"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.6"
  },
  "vscode": {
   "interpreter": {
    "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}