{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <center> TP n°2 : Initiation à Python (listes, tuples, dictionnaires et tableaux)</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\" role=\"alert\" style=\"margin: 0px\">\n",
    "    <p>Afin de pouvoir personnaliser votre notebook Jupyter sans détruire le notebook sur lequel travaille votre voisin(e), vous allez tout d'abord aller dans le menu <B><code>File</code></B> (en haut) puis cliquer sur <B><code>Make a copy...</code></B>. Renommez le notebook avec votre nom, par exemple.</p>\n",
    "</div>  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Les cellules des notebook Jupyter sont éditables et exécutables :**\n",
    "\n",
    "Pour exécuter le contenu d'une cellule dans ce document, vous pouvez utiliser le bouton\n",
    "<button><i class=\"fa fa-step-forward\"> Exécuter</i></button> (dans le menu en haut) ou bien utiliser les combinaisons de touches suivantes :\n",
    "\n",
    "* **Shift + Enter** : le code de la cellule est exécuté et le curseur à la cellule suivante.\n",
    "* **Ctrl + Enter** : le code de la cellule est exécuté et le curseur reste sur la même cellule.\n",
    "* **Alt + Enter** : le code de la cellule est exécuté et le notebook crée une nouvelle cellule immédiatement après."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<U>Rappels :</U>\n",
    "* Pour lire ce notebook, il faut exécuter les cellules **au fur et à mesure et dans l'ordre**, en partant de la première cellule, et en tapant **Maj+Entrée** -- ou **Shift+Enter**  -- (sur le clavier, une fois sur la cellule) jusqu'à la fin du notebook, de sorte à bien évaluer toutes les cellules de code ;\n",
    "\n",
    "* Pour modifier le contenu d'une cellule, il suffit de double cliquer dessus."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\" role=\"alert\" style=\"margin: 1px\">\n",
    "    <p><U><B>Remarques :</B></U></p>\n",
    "    <ul>\n",
    "        <li><p>Vous pouvez également ajouter une nouvelle cellule à l'aider du bouton <button class='fa fa-plus icon-plus btn btn-xs btn-default'></button> (dans le menu en haut);</p></li>\n",
    "        <li><p>Toutes les cellules de ce notebook commençant par <B><I>Entrée [x]</I></B> sont à exécuter.</p></li>\n",
    "    </ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <center>Il est vivement conseillé de modifier le code de chaque cellule commençant par <I>Entrée [x]</I> afin de s'entrainer</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Les Listes\n",
    "\n",
    "Les objets de type **liste** sont similaires aux chaines de caractères, hormis que chaque élément peut être de n'importe quel type. Les listes permettent de stocker plusieurs éléments, en préservant leur ordre.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list = []                           # Déclare une liste vide : on construit une liste avec des crochets []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "list = [1,1,1,2,3]                  # Déclare une liste avec des éléments (entiers ici)\n",
    "list                                # affichage de la liste"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour connaître la taille d'une liste on utilise la fonction `len()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\" role=\"alert\" style=\"margin: 1px\">\n",
    "    <p><U><B>Remarque :</B></U></p>\n",
    "    <p>On peut générer une liste depuis un objet <code>range()</code>...</p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(range(5))\n",
    "list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.1. Opérations sur les listes\n",
    "\n",
    "Dans une liste, l'**index** est la position d'un élément dans cette liste."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Opération                                               | Syntaxe                       |\n",
    "|---------------------------------------------------------|-------------------------------|\n",
    "| Ajouter un élément                                      | `liste.append(element)`       |\n",
    "| Supprimer la première occurence d'un élément            | `liste.remove(element)`       |\n",
    "| Accéder à un élément                                    | `liste[index]`                |\n",
    "| Insérer un élément dans une liste                       | `liste.insert(index, element)`|\n",
    "| Supprimer l'élément à un index donné                    | `del liste[index]`            |\n",
    "| Retourner le dernier élément en le retirant de la liste |  `liste.pop()`                |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <U>Exemples :</U>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list.append(2)                      # ajout d'un élément à la liste\n",
    "list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list.remove(2)                      # suppression de la première occurence (= première apparition en partant du début) de la valeur 2 dans la liste\n",
    "list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list[1]                             # accés à l'élément situé en position 1 de la liste"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list[-1]                            # les index négatifs permettent d'accéder aux éléments de la liste en partant de la fin\n",
    "                                    # ici le premier élément en partant de la fin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "list.insert(1, 2)                   # insertion de l'entier \" 2 \" à la position (index) 1\n",
    "list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "del list[3]                         # suppression de l'élément situé à la position (index) 3\n",
    "list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(list.pop())                   # affiche le dernier élément de la liste et le supprime\n",
    "print(list)                         # l'entier \"7\" est bien supprimé de la liste"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\" role=\"alert\" style=\"margin: 10px\">\n",
    "    <p><U><B>Remarque :</B></U></p>\n",
    "    <ul>\n",
    "        <li>Ces opérations fonctionnent quelques soit le type des éléments de la liste (entiers (<code>int</code>), réels (<code>float</code>), chaînes de caractères (<code>str</code>),...</li>\n",
    "    </ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- ### <U>Autres opérations possibles :</U>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list += [6,7,8]                     # ajoute trois éléments supplémentaires à la liste\n",
    "list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "list2 = list + [6]                  # crée une nouvelle liste en ajoutant l'élément \"6\"\n",
    "list2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "del list[:]                         # Supprimer tous les éléments d'une liste\n",
    "list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list.clear()                        # Supprimer tous les éléments d'une liste (une autre manière)\n",
    "list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "del list                            # Supprime l'objet list\n",
    "list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\" role=\"alert\" style=\"margin: 10px\">\n",
    "    <p><U><B>Remarque :</B></U></p>\n",
    "    <ul>\n",
    "        <li>La commande <code>del</code> fonctionne avec n'importe quel objet Python.</li>\n",
    "    </ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.2. Le *slicing*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'intérêt des slices est essentiellement la concision et la souplesse de leur syntaxe et le fait qu'elles économisent beaucoup de code (des instructions for ou if, des créations de listes intermédiaires, de la gestion d'indices, etc)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**<U>Syntaxe :</U>**\n",
    "\n",
    "```python\n",
    "liste[début:fin:saut]\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list = [ 1, 2, 3, 4, 5, 6, 7, 8 ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list[3:-1]                       # on récupère les éléments compris entre l'index  3 et l'index 1 en partant de la fin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "list[::2]                        # renvoie un élément sur deux de la liste"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list[3::2]                       # renvoie un élément sur deux de la liste, en partant de l'élément situé à la position (index) 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list[::-1]                       # le saut négatif renvoie la liste dans l'ordre inverse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list[2:-2:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <U>Exercice :</U> expliquer la dernière ligne (ci-dessus)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Explication :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.3. Les listes polymorphes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lorsque l'on ajoute des éléments de types différents, Python construit automatiquement une liste polymorphe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list = [ 1, 2.0 , 'A', [4, 5] , '10' ]\n",
    "print(\"La liste est :\",list)\n",
    "print('\\nLes éléments de la liste sont de type différent :\\n')\n",
    "print(\"Premier élément :\", type(list[0]))\n",
    "print(\"Deuxième élément :\", type(list[1]))\n",
    "print(\"Troisième élément :\", type(list[2]))\n",
    "print(\"Dernier élément :\", type(list[3]))\n",
    "print(\"Dernier élément :\", type(list[4]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.4. Les listes en compréhension\n",
    "\n",
    "Il existe des astuces python qui permettent d' optimiser le code. Une de ces astuces est la compréhension de liste ( ou liste en compréhension ou list comprehension ). L'idée est de simplifier le code pour le rendre plus lisible et donc plus rapide à écrire et plus simple à maintenir (reprendre).\n",
    "\n",
    "On peut ainsi générer une liste à l'aide d'une boucle `for` et une syntaxe compacte."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <U>Synthaxe :</U>\n",
    "\n",
    "```python\n",
    "list = [fonction(item) for item in list if condition(item)]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**<U>Exemples :</U>**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[2*x for x in range(10)]                # tous les multiples de 2, jusqu'à 9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[ i for i in range(-3, 3) if i != 0 ]   # on ne met dans la liste que les éléments compris entre -3 et 2, sauf 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[x for x in range(10) if x**2 > 3]      # on ne met dans la liste que les éléments dont le carré est supérieur à 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.5. La boucle `for` sur une liste"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut itérer (= parcourir avec une boucle)  directement sur les éléments d'une liste :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "a = 0\n",
    "for a in [ 2, .4, 8, 'mot', 12 ]:\n",
    "    print(a)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ou tester la création d'une liste :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list = [0]\n",
    "if list:                              # Si l'objet \" list \" existe\n",
    "    print(True)                       # Alors on affiche True (Vrai)\n",
    "else:                                 # Sinon\n",
    "    print(False)                      # on affiche False (Faux)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.6. La boucle `while` sur une liste"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La liste est : [0, 1, 2, 3] \n",
      "\n",
      "3\n",
      "2\n",
      "1\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "list = [ i for i in range(4) ]\n",
    "print(\"La liste est :\",list,\"\\n\")\n",
    "\n",
    "while list:\n",
    "    print(list.pop())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <U>Exercice :</U> expliquer le déroulement du programme ci-dessus"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Explication :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.7. Exercices d'entraînement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <U>Exercice n°1 :</U> créer une liste"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Écrire un script (programme) qui créé une liste d’au moins 5 entiers et qui affiche la valeur du quatrième élément de la liste."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre code ici"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Rajouter, à la suite, une ligne de code au script précédent qui permet de modifier la liste en remplaçant le deuxième élément par 15."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre code ici"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <U>Exercice n°2 :</U> opérations sur les listes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Écrire un script qui échange les valeurs du premier et du dernier élément d’une liste quelconque, non vide. (Aide : il faudra utiliser un variable intermédiaire)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre code ici"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <U>Exercice n°3 :</U> parcours de liste"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Écrire un programme qui crée une liste d’entiers, puis à l’aide de parcours successifs (boucle `for`) de la liste effectue les actions suivantes :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Calcule la somme de toutes les valeurs de la liste"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre code ici"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Calcule la moyenne arithmétique des valeurs de la liste et indique si elle est supérieure ou égale à 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre code ici"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <U>Exercice n°4 :</U> expliquer un programme"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exécuter le programme ci-dessous. Que fait-il, à quoi correspond le résultat affiché ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L = [1, 3, 5, 0, 10]\n",
    "t = len(L)\n",
    "\n",
    "som = 0\n",
    "for i in range (t):\n",
    "     if L[i]%2 == 0:\n",
    "          som = som + L[i]\n",
    "print (\"Résultat : \", som)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Explication :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <U>Exercice n°5 :</U> expliquer un programme"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exécuter le programme ci-dessous. Que fait la fonction enumerate ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste = [ 1, 4, 9, 3, 1, 2 ]\n",
    "\n",
    "for indice, element in enumerate(liste):\n",
    "    print(\"Le nombre n°\",indice, \"est\", element)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Explication :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <U>Exercice n°6 :</U> liste en compréhension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Expliquer le déroulement du programme ci-dessous :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste = [1, 2, 3, 4, 5]\n",
    "[ n + 3 for n in liste ]"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Explication :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <U>Exercice n°7 :</U> liste en compréhension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Construire **en une seule ligne**, un script qui affiche une liste des carrés des entiers compris entre 1 et 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre code ici"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <U>Exercice n°8 :</U> liste en compréhension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compléter le script ci-dessous pour qu'il affiche la liste des mots de la liste donnée, qui se terminent par un &laquo; s &raquo;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste = [\"maths\", \"info\", \"python\", \"exposants\", \"alpha\", \"fonctions\", \"parabole\", \"equilateral\", \"orthogonal\", \"cercles\", \"isocèle\" ]\n",
    "print(        )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Les tuples (ou n-uplets)\n",
    "\n",
    "Les tuples sont semblables aux listes, hormis qu'ils ne peuvent plus être modifiés une fois crées. On dit qu'ils sont ***immuables***."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il exite deux syntaxes, l'une avec des parenthèses ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3) <class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "t1 = (1, 2, 3)\n",
    "print(t1, type(t1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... l'autre sans."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(4, 5, 6) <class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "t2 = 4, 5, 6\n",
    "print(t2, type(t2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3, 4, 5, 6)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t1 + t2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut &laquo; défaire &raquo; un tuple, toujours en utilisant les parenthèses (ou pas)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y, z = t1\n",
    "print(x, y, z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(x, y, z) = t2\n",
    "print(x, y, z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut crée un nouveau tuple à partir d'autres tuples, avec l'opérateur **`+`**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t1 + t2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le *slicing* fonctionne aussi sur les tuples !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t1[::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vérifiez le caractère immuable des tuples en essayant de modifier l'un des éléments de `t1` (par exemple)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t1[0] = 0                               # Cette commande essaie de modifier le premier élément du tuple t1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\" role=\"alert\" style=\"margin: 10px\">\n",
    "    <p><U><B>Remarque :</B></U></p>\n",
    "    <p>On peut générer un tuple depuis un objet <code>range</code>...</p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tuple(range(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.1. La boucle `for` sur un tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut itérer directement sur les éléments d'un tuple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tuple = ('Brout', 'Englert', 'Higgs', 'Hagen', 'Guralnik', 'Kibble')\n",
    "for prenom in tuple:\n",
    "    print(prenom)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\" role=\"alert\" style=\"margin: 10px\">\n",
    "    <p><U><B>Remarque :</B></U></p>\n",
    "    <p>La fonction <code>enumerate()</code> retourne un couple (donc un tuple) : (<code>index</code>, <code>item</code>).</p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i, prenom in enumerate(tuple):\n",
    "    print(\"Index\", i, \":\", prenom)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Les dictionnaires\n",
    "\n",
    "Les dictionnaires sont semblables aux listes, hormis que chaque élément est un couple :\n",
    "\n",
    "```python\n",
    "{ clé: valeur }\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La clé et la valeur sont séparées par `(:)` et les éléments sont séparés par `(,)`. La clé est unique est doit être de type non-mutable (son état ne peut pas être modifié après sa création) tel que `str`, `int` ou `tuple`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**<U>Exemple :</U>**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dictionaire = { 'Nom': \"Maël\", 'Age': 16, 'Sexe': \"Homme\" }\n",
    "dictionaire"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si la clé n'existe pas, une nouvelle entrée est créée dans le dictionnaire."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dictionaire['Classe'] = '1ère'\n",
    "dictionaire['b'] = 3\n",
    "dictionaire['c'] = 5\n",
    "dictionaire"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.1. Opérations sur les dictionnaires"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **Accès aux éléments**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dictionaire[\"Nom\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "dictionaire['Age']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dictionaire['Sexe']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dictionaire.get('Sexe')                                       # équivalent à ce qui précède"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dictionaire.items()                                             # Affiche les couples du dictionnaire"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dictionaire.keys()                                              # Affiche les clés du dictionnaire"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dictionaire.values()                                            # Affiche les valeurs du dictionnaire"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **Supprimer des éléments**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "del dictionaire['Nom']                                          # supprimer un élément spécifique\n",
    "dictionaire"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dictionaire.clear()                                             # Supprimer tout le contenu du dictionnaire\n",
    "dictionaire"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "del dictionaire                                                 # Supprimer le dictionnaire\n",
    "dictionaire"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **Modifier les éléments**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dictionaire = { 'Nom': \"Maël\", 'Age': 16, 'Sexe': \"Homme\" }\n",
    "dictionaire"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dictionaire['Age'] = 14\n",
    "dictionaire"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.2. Autres opérations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Longueur du dictionnaire\n",
    "\n",
    "dictionaire = {'Nom': \"Maël\", 'Age': 16, 'Classe': \"1ère\" }\n",
    "len(dictionaire)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Copie d'un dictionnaire dans un autre\n",
    "\n",
    "dictionaire2 = dictionaire.copy()\n",
    "dictionaire2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Création d'un nouveau dictionnaire avec des clés dans un tuple\n",
    "\n",
    "seq = ('Nom', 'Age', 'Classe')\n",
    "\n",
    "dictionaire = dictionaire.fromkeys(seq)\n",
    "print(\"Nouveau dictionnaire \", dictionaire)\n",
    "\n",
    "dictionaire = dictionaire.fromkeys(seq, 10)\n",
    "print(\"Nouveau dictionnaire \", dictionaire)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Comment choisir entre `Listes`, `Tuples` ou `Dictionnaires` ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **Liste** : à utiliser quand on a besoin d'une séquence ordonnée d'objets homogènes, qui peuvent changer de valeur dans le programme.\n",
    "\n",
    "* **Tuple** : à utiliser quand on a besoin d'une séquence ordonnée d'objets homogènes, qui ne changent pas de valeur dans le programme.\n",
    "\n",
    "* **Dictionnaire** : approprié quand on a besoin de faire le lien entre des valeurs et des clés, afin de mieux les manipuler en utilisant les clés."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. Les tableaux"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "http://python.physique.free.fr/listes_et_tableaux.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cette activité s'inspire très largement de :\n",
    "- cours de [Antony Lesage](https://www.lptmc.jussieu.fr/user/barbi/ENSEIGNEMENT/M2/Python1617/TD01-Exercices/TD01-Introduction_%D0%95_Python.html)\n",
    "- MOOC [Bioinformatique : algorithmes et génomes sur FUN](https://www.fun-mooc.fr/courses/course-v1:inria+41003+session03/about)"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": false,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": false,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}