{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Découverte des objets listes\n",
    "\n",
    "> Initiation aux listes en python\n",
    "\n",
    "- toc: true\n",
    "- badges: true\n",
    "- comments: false\n",
    "- categories: [python, ISN]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "6b843a5d17fc6bbb784dc0b7eb248c49",
     "grade": false,
     "grade_id": "cell-28d69155883bf434",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "Les listes sont des objets très importants en Python car elles permettent de stocker de multiples informations dans une seule variable.\n",
    "\n",
    "Ci dessous, voici un exemple montrant la liste des entiers de 0 à 9."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "97fa0814e1b02b665570e040cbf657d2",
     "grade": false,
     "grade_id": "cell-ea1324d6d47cf833",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "list(range(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "18a508a2a83ef7368081813f23cc8f2e",
     "grade": false,
     "grade_id": "cell-43f379853031c901",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "Nous allons dans ce chapitre détailler ce qu'est une liste, comment les manipuler et expliquer pourquoi elles sont si importantes en Informatique."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "24eb8ab9428c78cc358f1fc9cf53208f",
     "grade": false,
     "grade_id": "cell-578be28312ea8c54",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "## Manipulation de listes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "8cd18b474482559c88fa4feb24f9961f",
     "grade": false,
     "grade_id": "cell-e98479d288426249",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "### Présentation du type list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "7e339d2f10100612dfc9db1ef4fd6499",
     "grade": false,
     "grade_id": "cell-c7346b64c8620b1e",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "Comme on peut le voir sur l'exemple précédent, une **liste** en Python est un objet délimité par deux crochets et qui renferme un nombre fini d'éléments de n'importe quel type, ces éléments étant séparés par des virgules.\n",
    "\n",
    "Voici quelques caractéristiques sur les listes\n",
    "\n",
    ">- les éléments d'une liste sont ordonnés : si on échange de place deux éléments différents d'une liste, la liste est modifiée.\n",
    ">- les éléments d'une liste sont numérotés **depuis 0**\n",
    ">- un même objet peut appparaître plusieurs fois dans une liste.\n",
    ">- une liste peut contenir des éléments de type différents (nombres, chaines...)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "abe0546915189ee911140762ca369fd1",
     "grade": false,
     "grade_id": "cell-a29e4539ca361f75",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "Premier_Exemple=[21,\"Bonjour\",1+2,[1,2,3,1], 21 ]\n",
    "print(Premier_Exemple)\n",
    "print(Premier_Exemple[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "de04bb7547e7ddba7bf3b9e3fc5c4ff8",
     "grade": false,
     "grade_id": "cell-12e77cb595ab6400",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "### Premières manipulations sur les listes\n",
    "Créez une variable ***liste_carres*** contenant la liste les carrés des entiers de 1 à 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste_carres = ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "e65cf0d763aae71304a241a64b89dd6c",
     "grade": true,
     "grade_id": "cell-bd699523212d225e",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "assert 81 in liste_carres"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "1a003912290af18f77ce5e0f1e6df83f",
     "grade": false,
     "grade_id": "cell-d2b151cbf857f9db",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "Les éléments d'une liste sont numérotés à partir de 0. On accède à un élément en utilisant une notation crochet : ***maListe[index]***. \n",
    "\n",
    "Observez l'exemple et modifiez le pour accéder aux différents éléments de la ***liste_carres***\n",
    "\n",
    "Observez le message d'erreur lorsque l'index dépasse le nombre d'éléments dans la liste !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "38a1b2dab073cb9001e0c97ee34807b4",
     "grade": false,
     "grade_id": "cell-a2f4c968df97a4c1",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "liste_carres[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "3985eaf1d515d66a32d1385731d8a44d",
     "grade": false,
     "grade_id": "cell-c5f3b0117850edce",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "liste_carres[11]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "867218ef04b5217c2bc855e94044b33d",
     "grade": false,
     "grade_id": "cell-24a2f0a6686be5c0",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "Il est possible de modifier un élément particulier d'une liste. Il suffit de faire une affectation au moyen du signe = comme pour une simple variable. Observez plutôt :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "3113bf542fe9663f51bdffceeb89ff92",
     "grade": false,
     "grade_id": "cell-c3f7549341d86179",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "liste_carres[1]=100\n",
    "print(liste_carres)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "d8cc653e41982e6044b5766f7a68e7c7",
     "grade": false,
     "grade_id": "cell-b99fa2e24126176b",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "On peut rechercher si un élément dans une liste. Par exemple pour savoir si 25 est un carré, on peut taper la ligne suivante.\n",
    "\n",
    "Manipulez cette fonction en testant des nombres qui sont dans la liste et d'autres qui n'y sont pas.\n",
    "\n",
    "On sera frappé par la similitude entre la syntaxe de python et le langage naturel. Cette simplicité est une des forces de Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "6ef3212bd53aed0e668a4e3633c818d0",
     "grade": false,
     "grade_id": "cell-f5729d65faa4e727",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "25 in liste_carres"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "348995b2e277b0ca1b4ce8a41d5b1c73",
     "grade": false,
     "grade_id": "cell-56f028f2805aaefb",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "On peut mettre deux listes bout à bout comme on le voit sur l'exemple suivant. On remarque l'utilisation naturelle du signe '+' pour ajouter deux listes bout à bout."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "7b35e0eba453fb882ccd2dfd028fa89f",
     "grade": false,
     "grade_id": "cell-5a69914749a923d3",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "liste_carres=liste_carres + [121,144,169,196,225]\n",
    "print(liste_carres)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "4bd78e1b1dcf11ce48a9be14388eacf2",
     "grade": false,
     "grade_id": "cell-8b0a8ea433aa0cd6",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "De même qu'on possède l'opération +, il existe aussi l'opération * pour obtenir une liste formée de plusieurs fois la même liste. Je vous laisse découvrir le fonctionnement de cet opérateur dans la cellule ci-dessous :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "9919cc2911e9e2eba201a8805554261e",
     "grade": false,
     "grade_id": "cell-ef9c8867abfd449f",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "3*[1,2,4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "64cf5ca10cb7ec73ffdd3b9d1bd88318",
     "grade": false,
     "grade_id": "cell-d19527f6580b8bcd",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "Pour savoir combien d'éléments contient une liste, on peut utiliser la fonction ***len()***.\n",
    "\n",
    "Testez aussi les fonctions ***min()*** et ***max()*** sur la liste_carres. A quoi servent elles ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "07ddc63565d72c502413dbdd72c248ad",
     "grade": false,
     "grade_id": "cell-6dfe025564e75cc2",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "len(liste_carres)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "418dea206630aa0d201f6d8e16863dbf",
     "grade": false,
     "grade_id": "cell-17835528718aa1df",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "print(min(liste_carres))\n",
    "print(max(liste_carres))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "cc7d5b6ed46d5e826ef082a6152835e4",
     "grade": false,
     "grade_id": "cell-f97a0c87efe304f7",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "Pour connaître la position d'un objet dans une liste, on peut utiliser la méthode ***.index()**. Elle s'utilise comme suit. Que se passe t-il si l'objet recherché n'appartient pas à la liste ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "719a510fb96e22a33be2bcac64fa253a",
     "grade": false,
     "grade_id": "cell-61f17571b352bb03",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "liste_carres.index(81)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "9a791668f548a4256c2b43273d4ae2e0",
     "grade": false,
     "grade_id": "cell-6e7acd0cfd13a8b8",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "De la même manière, on peut compter le nombre d'éléments dans une liste. Pour cela, on utilise la méthode ***.count()*** de manière similaire à ***.index()***. Pour vous exercer, ajouter à ***liste_carres*** la liste [121,81,169,81] et comptez le nombre d'occurences du nombre 81."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A vous de jouer dans cette cellule\n",
    "liste_carres=..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "780a9c3e3b6bfc71d6df3f12237007b7",
     "grade": false,
     "grade_id": "cell-e67e9678680feb3d",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "### Parcourir une liste\n",
    "\n",
    "Il existe deux manières de parcourir une liste :\n",
    "- le parcours élément par élément\n",
    "- le parcours par index\n",
    "\n",
    "Dans les deux cas on utilisera une boucle *pour*. Observez les exemples suivants :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "8ca46d5aca7ef314df44c60794a0c700",
     "grade": false,
     "grade_id": "cell-839cfd660fa353e1",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "# Parcours élément par élément\n",
    "for elmt in liste_carres:\n",
    "    print (\"ce nombre est un carré : \",elmt)\n",
    "    \n",
    "# Parcours par index\n",
    "longueur_liste = len(liste_carres)\n",
    "for indx in range(longueur_liste):\n",
    "    print (\"ce nombre est aussi un carré : \",liste_carres[indx])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "8fbc67d770881b40aa59ceed1e5bd4cf",
     "grade": false,
     "grade_id": "cell-2e23fabbfcc9d10b",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "Dans le parcours par élément, la variable de boucle **contient les différents éléments** de la liste. Dans le second parcours par index, la variable de boucle est l'**index permettant d'accéder à l'élément**. Il faut dans ce cas commencer par déterminer la longueur de la liste pour ne pas risquer un dépassement d'index."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "66203201fb5763821f01e4caaac66b51",
     "grade": false,
     "grade_id": "cell-df745ff97bc566c7",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "### Exercice 1\n",
    "1. Ecrire une fonction **etendue** \n",
    "    - prenant en paramètre une liste de nombres\n",
    "    - renvoyant l'étendue de cette liste à savoir l'écart entre la plus grande valeur et la plus petite valeur\n",
    "    \n",
    "2. Ecrire une fonction **somme** \n",
    "    - prenant en argument une liste \n",
    "    - renvoyant la somme de tous les termes de la liste\n",
    "\n",
    "3. Ecrire une fonction **moyenne**\n",
    "    - prenant en paramètre une liste de nombres\n",
    "    - renvoyant la valeur moyenne des nombres de la liste"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "e6a47e8214e4971d7163675064ef2254",
     "grade": false,
     "grade_id": "cell-b9dffb8ec332e048",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# YOUR CODE HERE\n",
    "raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "6d9f1e50ea2d37e30c25fbae3a168779",
     "grade": false,
     "grade_id": "cell-2c074dcf443774cb",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "La cellule de tests suivante doit s'exécuter sans erreur"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "da503bd1d93a8ce72ac096fd614e473b",
     "grade": true,
     "grade_id": "cell-abee4a80fa99017c",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "assert somme(list(range(1,30))) == 435\n",
    "assert etendue([3,1,9,4,5])==8\n",
    "assert moyenne([3,1,9,4,5])==4.4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "fe32b854273867efaa6b2137a92af6a3",
     "grade": false,
     "grade_id": "cell-85f5bd76e1ed95e7",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "### Modification d'une liste"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "ee0fb65a95d480cb29739bd3f96033da",
     "grade": false,
     "grade_id": "cell-fb5737d57a20dbf7",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "Pour modifier une liste, il suffit d'effectuer une affectation à l'un de ses éléments via son index. Observez les exemples ci-dessous. Que signifie l'index -1 dans une liste ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "1f779dc545e11fa3bb7cf63d2849d07e",
     "grade": false,
     "grade_id": "cell-1e24a199286e25d4",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "L=[[1,2,3],\"bonjour\",3]\n",
    "print(\"Liste initiale \",L)\n",
    "L[0]=[6,8]\n",
    "print(\"Premier élément modifié :\",L)\n",
    "L[-1]=\"au revoir\"\n",
    "print(\"Qu'est-ce qui a changé ?\", L)\n",
    "L[0][-1]=9\n",
    "print(\"On modifie le premier élément :\",L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "d394cc70e019448b3ebaa355baf6d5ee",
     "grade": false,
     "grade_id": "cell-b9bac807f8186073",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "## Les méthodes sur les listes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "7198909d5937bfcf862e35e91307c7f4",
     "grade": false,
     "grade_id": "cell-84b03c1abf0aad47",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "Il existe encore d'autres moyens de manipulation de listes.\n",
    "\n",
    "Il existe en fait des fonctions intégrées à la structure de listes permettant d'agir sur celles-ci : on les nomme **méthodes** et leur syntaxe générale est, étant donnée une liste $L$ : \n",
    "\n",
    "$L.Methode()$, où $Methode()$ fait référence à l'une des méthodes détaillée ci-dessous.\n",
    "\n",
    "Il est à noter qu'une fois la ligne $L.Methode()$ executée, la liste $L$ est, en général, transformée en sa liste modifiée.\n",
    "\n",
    "Ces méthodes revoient à la programmation orientée objet de Python : les listes sont des objets qui sont manipulés, modifiés selon certains transformations et évoluent au grés de ces modifications.\n",
    "\n",
    "Voici un petit catalogue des méthodes utiles. Vous retrouverez des méthodes déjà vues ci-dessus."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "6baf05cfd1fb80cb5f4df31ffc24fa97",
     "grade": false,
     "grade_id": "cell-40885e5786e66486",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "### La méthode .append()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "c54c45db89eaf6c528961cf9fc9c1231",
     "grade": false,
     "grade_id": "cell-6f14371783ea23fd",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "La syntaxe  $L.append(objet)$ ajoute $objet$ à droite dans $L$ :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "2d656932ebe58fe6cc9cdc9956c4d6d3",
     "grade": false,
     "grade_id": "cell-6e1002e0d933b810",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "L=[1,2,3,4]\n",
    "L.append(5)\n",
    "print(L)  # la liste initiale vient d'être modifiée !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "7a61e92856b22c6cc9a804fb4288d1a5",
     "grade": false,
     "grade_id": "cell-cef99566892323ba",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "### La méthode .insert()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "d075b334fbada4cd5df7bfff90a075e6",
     "grade": false,
     "grade_id": "cell-45e3b562e7d9a362",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "La syntaxe $L.insert(Indice,objet)$ insère $objet$ en place $Indice$ dans la liste $L$ et décale le reste des occurrences de $L$ à droite :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "342f44e8695bf8d2c330e09677d9335d",
     "grade": false,
     "grade_id": "cell-de4032b65f98c0ab",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "L=[\"Pomme\",\"Poire\",\"Banane\"]\n",
    "print(L)\n",
    "L.insert(1,\"Fraise\") # vient prendre la place de \"Poire\"\n",
    "print(L)\n",
    "L.insert(-1,\"Ananas\") # vient prendre la place de \"Banane\"\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "be8eb0a2d9494552da1b49cf654ae70f",
     "grade": false,
     "grade_id": "cell-22b3c000e29a5b25",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "### La méthode .remove()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "0b0a28b4eb955077822066b6cc7654fd",
     "grade": false,
     "grade_id": "cell-7ae460a54444dc77",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "La syntaxe  $L.remove(objet)$ supprime de la liste la première occurrence égale à $objet$ dans la liste $L$. Si $objet$ n'est pas présent dans $L$, cela produit un message d'erreur."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "621c39d2d20d7fcb982c3a3ab954f67d",
     "grade": false,
     "grade_id": "cell-65186a98512f154f",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "M=[2,3,2,3,3,2,3]\n",
    "print(M)\n",
    "M.remove(2)\n",
    "print(M)  # seul le premier \"2\" est supprimé !\n",
    "M.remove(3)\n",
    "print(M)  # seul le premier \"3\" est supprimé !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "7d676094aa3b2f6543ba45bf9ac811c9",
     "grade": false,
     "grade_id": "cell-c6ab5b61e0138332",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "### La méthode .pop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "0e1c65dcd29839b43684886a4dddfd6f",
     "grade": false,
     "grade_id": "cell-bc9c25aba31ced2c",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "La syntaxe  $L.pop([Indice])$ renvoie $L[Indice]$ et supprime l'élément d'index $Indice$ de la liste $L$. Il n'est pas nécessaire que  $Indice$ soit dans les bornes cycliques licites entre $-len(L)$ et $len(L)-1$, mais cela est quand même conseillé pour une meilleure lecture du script."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "dcfd71a4fd11ed57aca7e44aebbed04a",
     "grade": false,
     "grade_id": "cell-1d3af5d0d3c40ada",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "L=[2,3,2,2,1,2,\"mot\",2,3]\n",
    "print(L)\n",
    "print(L.pop(6))\n",
    "print(L)\n",
    "L.pop(-1)\n",
    "print(L)\n",
    "L.pop(3)\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### La méthode .index()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "6082841c01533c64edcf79770760d5a7",
     "grade": false,
     "grade_id": "cell-c6197091521e75a2",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "La syntaxe $L.index(objet)$ renvoie l'index de la première occurrence d'$objet$ dans $L$. La liste $L$ n'est pas modifiée par cette méthode. Cela renvoie un message d'erreur lorsque $objet$ ne figure pas dans la liste $L$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "f532afa8cf09de824dfc0b2f9bc63daf",
     "grade": false,
     "grade_id": "cell-a6c489d9fa3bb168",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "Liste=[2,1,2,\"un mot\",3,2,3,2]\n",
    "print(Liste)\n",
    "print(Liste.index(\"un mot\"))\n",
    "print(Liste.index(3))\n",
    "print(Liste)  # liste non modifiée"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "ad134f9670de0527d25873d858f89013",
     "grade": false,
     "grade_id": "cell-fc13660af5d58e69",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "### La méthode .count()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "21c7f2b848fab91cebdf9f7e2288039f",
     "grade": false,
     "grade_id": "cell-54ae6e053837dce3",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "La syntaxe $L.count(objet)$ renvoie le nombre d'occurrences égales à $objet$ dans la liste $L$. Cele ne modifie pas la liste initiale."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "a86df5e19712d9c19867aeddecbd5db9",
     "grade": false,
     "grade_id": "cell-9b7ceea3161e32b2",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "Liste.count(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "92775dd5cf3eea2e0c77987560af85f0",
     "grade": false,
     "grade_id": "cell-5d06acd166b6add6",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "### Tranches de listes\n",
    "Etant donnée une liste $L$, la syntaxe $L[Indice$_$Debut:Indice$_$Fin:Pas]$ renvoie la sous-liste composée des termes $L[k]$, où l'indice $k$ vaut successivement $Indice$_$Debut$,$Indice$_$Debut$+$Pas$, $Indice$_$Debut$+2 $Pas$, etc. On s'arrête avant d'avoir atteint $Indice$_$Fin$. Le dernier indice n''est jamais inclus dans la sélection.\n",
    "\n",
    "Il est à noter que $Pas$ peut être strictement négatif. Regardez attentivement les exemples suivants. N'hésitez pas à les modifier pour observer l'influence de chaque indice."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "a407a9ba59c96fab41557af2094928d1",
     "grade": false,
     "grade_id": "cell-5d6f83a5dcdb3e72",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "L=list(range(30)) # list() trasnforme un objet en liste\n",
    "print(\"affichage de toute la liste : \",L)\n",
    "print(\"une liste du troisième au dixième terme :\",L[2:10])\n",
    "print(\"affichage de certains termes : \", L[3:28:6])\n",
    "print(\"affichage sans le premier terme :\", L[1:])\n",
    "print(\"affichage des cinq premiers termes :\",L[:5])\n",
    "print(\"la liste dans le sens inverse :\",L[::-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "c4ef3b6ebf0a23f861c435b48cf38f42",
     "grade": false,
     "grade_id": "cell-8f3a705f2579faa5",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "### Exercice 2 : Simulation de lancer de dé\n",
    "1. Ecrire une fonction **genere_liste** \n",
    "    - prenant en paramètre un entier $n$\n",
    "    - renvoyant une liste de $n$ nombres aléatoires entre 1 et 6\n",
    "2. Ecrire une fonction **frequence_6**\n",
    "    - prenant en paramètre une liste de nombres\n",
    "    - renvoyant la fréquence d'apparition du 6\n",
    "    \n",
    "*Indication* : On pourra utiliser les commandes suivantes pour tirer un nombre aléatoire entre 1 et 6 :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "33cbd04489950df91fd3667f96194e8b",
     "grade": false,
     "grade_id": "cell-635f936527f69af8",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "from random import * # A mettre au début du programme\n",
    "\n",
    "randint(1,6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "c24277fc35e6045c29e3dd332992c741",
     "grade": false,
     "grade_id": "cell-e13f882a3d5a03df",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "from random import * # A mettre au début du programme\n",
    "\n",
    "# YOUR CODE HERE\n",
    "raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "b787c07450c33c46a7fd9a79df1d36f0",
     "grade": true,
     "grade_id": "cell-c9ce258ed8ca889a",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}