NSI1_e15a_listes-v7.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"width:100%;border-collapse:separate;border:solid 2px;border-radius:14px;\">\n",
    "    <div style=\"display:flex;\">\n",
    "        <div style=\"display:inline;width:5%;\"></div>\n",
    "        <div style=\"display:inline;width:15%;\">NSI1</div>\n",
    "        <div style=\"display:inline;width:15%;\">e15a</div>\n",
    "        <div style=\"display:inline;width:70%;text-align:right;\"><b>Représentation des données</b></div>\n",
    "        <div style=\"display:inline;width:5%;\"></div>\n",
    "    </div>\n",
    "    <div  style=\"display: flex;background-color:#EEE\">\n",
    "        <p style=\"width:100%;text-align:center;\">Types construits </p>\n",
    "    </div>\n",
    "    <div  style=\"display: flex;\">\n",
    "        <p style=\"width:100%;text-align:center;\">Listes</p>\n",
    "    </div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class = \"alert alert-success\">\n",
    "    \n",
    "**Objectifs de la séquence:**  \n",
    "Définition générale des types construits.  \n",
    "Définition et utilisation des listes (type list)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class = \"alert alert-info\">\n",
    "    \n",
    "**Activités:**\n",
    "- Syntaxe\n",
    "- Création\n",
    "- Accès à un élément, longueur d'une liste: len()\n",
    "- Parcours d'une liste\n",
    "- Modifier un élément\n",
    "- Principales méthodes: append(), insert(), remove(), pop(), sort(), opérateur +\n",
    "- Défis 1 et 2: Top des prénoms de filles donnés en 2019\n",
    "- Listes de listes\n",
    "- Défi 3: Le Pingou1\n",
    "- Construction d'une liste d'éléments identiques: opérateur *\n",
    "- Copie de listes: copy.copy() et copy.deepcopy()\n",
    "- Listes en compréhension\n",
    "- Dessin d'une courbe: matplotlib.pyplot.plot\n",
    "- Défi 4: Analyse d'une consommation d'eau"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class = \"alert alert-danger\">\n",
    "    \n",
    "<h3>Les types construits</h3>\n",
    "\n",
    "Contrairement aux types simples comme les <b>bool</b>, <b>int</b> et <b>float</b> par exemple, les types construits vont nous permettre de manipuler des regroupements de valeurs sous un seul <b>identifiacteur</b>.<br>  \n",
    "De la même façon qu'un type <code>str</code> permet de regrouper un ensemble de caractères."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "chaine = \"Je suis une chaîne de caractères UTF-8\"\n",
    "chaine[15]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<code>chaine</code> est l'identificateur d'une chaine de caractères.  \n",
    "<code>chaine[15]</code> est le seixième caractère.\n",
    "\n",
    "Chaque type (<code>list</code>, <code>tuple</code> ou <code>dict</code>) donne accès à un certains nombres de fonctionnalités ou méthodes.\n",
    "\n",
    "Par exemple, pour le type <code>str</code>, nous avions vu que <code>len (chaine)</code> renvoie la longueur de la chaine:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(chaine)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>Les Listes</h3>\n",
    "Une liste est un ensemble ordonné d’éléments avec des indices pour les repérer.\n",
    "\n",
    "<b>Syntaxe:</b> Les éléments d’une liste sont séparés par des virgules et entourés de crochets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste1 = [\"a\", \"b\", \"c\"] # une liste à 3 éléments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Création de listes</b>  \n",
    "Une liste peut être créée lors d'une affectation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste2 = [1] # une liste contenant un seul élément\n",
    "liste3 = [[1, 2], [3, 4]] # une liste de listes\n",
    "liste_vide = [] # une liste vide"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous pouvons utiliser les fonctions <code>list</code> et <code>range</code>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste4 = list(range(2, 21, 3)) \n",
    "liste4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Accès aux éléments d'une liste, et longueur d'une liste</b>\n",
    "\n",
    "Rien de neuf par rapport aux chaînes de caractères de ce côté là:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "famille = [\"Bart\", \"Lisa\", \"Maggie\",\"Marge\",\"Homer\"]\n",
    "famille[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(famille)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Attention à ne pas interroger un indice qui dépasse <code>len(famille)-1</code>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "famille[5] # Ca va planter... Il n'y a personne à cette adresse."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les indices négatifs peuvent être utilisés pour lire la liste à l'envers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "famille[-2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Parcours d'une liste</b>  \n",
    "Une liste est  un <b>itérable</b>.\n",
    "Il est donc possible la parcourir ainsi:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for nom in famille:\n",
    "    print(nom, end=\" \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il est aussi possible d'utiliser un indice:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(len(famille)):\n",
    "    print(famille[i], end=\" \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Modifier les éléments</b>  \n",
    "Une liste est un objet <b>mutable:</b> Il est possible de modifier directement un élément."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "famille[0]=\"Hugo\" # change la valeur du premier élément\n",
    "famille # affiche la liste qui est ici le dernier objet appelé par l'interpréteur "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Principales méthodes sur les listes</b>  \n",
    "Les fonctions propres à un type donné sont appelées des méthodes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "famille.append(\"Mona\") # ajoute un élément à la fin\n",
    "famille"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Erreur classique:</b>  \n",
    "Pour ajouter un élément à une liste, il faut qu'elle existe !\n",
    "Si ce n'est pas le cas, créez au moins la liste vide.   \n",
    "<code>nouvelle_liste = []</code>  \n",
    "Puis seulement:  \n",
    "<code>nouvelle_liste.append(nouvel_element_a_ajouter)</code>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "famille.insert(5,'Abraham') # insert \"Abraham\" à l'indice 5\n",
    "famille"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "famille.remove('Hugo') # supprime 'Hugo'. On peut aussi écrire del famille[0]\n",
    "famille"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dernier_element = famille.pop() # supprime le dernier élément de la liste et renvoie sa valeur\n",
    "dernier_element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "famille # notez que le dernier élément a disparu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "famille.sort() # classe les éléments dans l'ordre croissant\n",
    "famille"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Remarque:</b> <code>famille_triée = sorted(famille)</code> renvoie une nouvelle liste triée sans toucher à la liste d'origine.\n",
    "\n",
    "Concaténation de listes:  \n",
    "On peut utliser l'opérateur <code>+</code> pour ajouter des éléments ou fusionner deux listes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits = ['pomme', 'poire', 'kiwi']\n",
    "legumes = ['poireau', 'salade', 'haricot']\n",
    "nourriture_saine = fruits + legumes + ['pain']\n",
    "nourriture_saine"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Défi 1:</b>  \n",
    "Soit la liste de noms les plus donnés aux filles nées en 2019:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "top_prenom_filles_2019=['CAMILLE','LOUISE','LÉA','AMBRE','AGATHE','JADE','JULIA','MILA','ALICE','CHLOÉ','EMMA',\n",
    "'ANDRÉA','ANNA','LUCIE','EDEN','ROMANE','ÉLISE','LOLA','ZOÉ','EMY','LÉONIE','MIA','ROSE','CANDICE','AMÉLIA',\n",
    "'MAËLYS','CLÉMENCE','ÉLÉNA','MANON','THAIS','VALENTINE','EVA','JEANNE','LÉNA','LOUNA','MYA','CHARLOTTE',\n",
    "'CLARA','CONSTANCE','IRIS','LISE','LOU','MATHILDE','OLIVIA','INÈS','ADÈLE','ALICIA','ANGELINA','APOLLINE',\n",
    "'CAPUCINE']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1- Combien y-a-t-il de prénoms dans cette liste?  \n",
    "2- Créez le programme qui permet de retourner une nouvelle liste ne contenant que les prénoms commençant par la lettre 'M'  \n",
    "3- Combien y-a-t-il de prénoms dans cette nouvelle liste?  \n",
    "4- Triez la dans l'ordre alphabétique"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# parcourir tous les éléments de la liste top_prenom_filles_2019\n",
    "    # pour chaque élément, tester si le premier caractère est égale à 'M'\n",
    "        # si c'est le cas, ajouter cet élément à la nouvelle liste\n",
    "# afficher la longueur de la nouvelle liste\n",
    "# afficher la nouvelle liste"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Défi 2:</b>  \n",
    "Créer une fonction qui prend la liste des prénoms et un caractère en paramètres et qui renvoie le nombre de prénoms commençant par cette lettre."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def nombre_initiales_dans_liste(liste_prenom,lettre):\n",
    "    # initialiser un compteur à 0\n",
    "    # parcourir tous les éléments de la liste liste_prenom\n",
    "        # pour chaque élément, tester si le premier caractère est égale à lettre\n",
    "            # si c'est le cas, ajouter 1 au compteur\n",
    "    return # renvoyer la valeur du compteur\n",
    "\n",
    "nombre_initiales_dans_liste(top_prenom_filles_2019,'C')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Liste de listes</b>  \n",
    "Comme vu plus haut, une liste peut contenir des listes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste5 = [[1, 2], [3, 4],[5, 6]] # une liste de listes\n",
    "print(\"Nombre de lignes de liste5:\",len(liste5))\n",
    "print(\"Ligne d'indice 0 de liste5:\",liste5[0])\n",
    "print(\"Le nombre d'éléments de liste5[0] correspond au nombre de colonnes:\", len(liste5[0]))\n",
    "print(\"L'élément d'indice 0 de la ligne d'indice 1:\",liste5[1][0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous allons utiliser une liste de listes pour représenter un tableau de points d'une image.  \n",
    "A chaque pixel de l'image 'pingou1.png' correspond une case du tableau pingou1 repérée par la ligne y et la colonne x.  \n",
    "Dans chaque case, on note un caractère pour coder la couleur du pixel: "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Pingouin](https://github.com/ebuonocore/NS1_15_Listes/blob/master/img/pingouin2.png?raw=true \"pingouin2.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pingou1 = [['C', 'C', 'C', 'C', 'C', 'C', 'C', 'G', 'G', 'G', 'G', 'G', 'C', 'C', 'C', 'C', 'C', 'C', 'C'], \n",
    "           ['C', 'C', 'C', 'C', 'C', 'C', 'G', 'G', 'G', 'G', 'G', 'G', 'G', 'C', 'C', 'C', 'C', 'C', 'C'],\n",
    "           ['C', 'C', 'C', 'C', 'C', 'G', 'G', 'G', 'G', 'G', 'G', 'G', 'G', 'G', 'C', 'C', 'C', 'C', 'C'],\n",
    "           ['C', 'C', 'C', 'C', 'G', 'G', 'B', 'B', 'G', 'G', 'G', 'B', 'B', 'G', 'G', 'C', 'C', 'C', 'C'],\n",
    "           ['C', 'C', 'C', 'G', 'G', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'G', 'G', 'C', 'C', 'C'],\n",
    "           ['C', 'C', 'C', 'G', 'G', 'B', 'B', 'G', 'B', 'B', 'B', 'G', 'B', 'B', 'G', 'G', 'C', 'C', 'C'],\n",
    "           ['C', 'C', 'C', 'G', 'G', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'G', 'G', 'C', 'C', 'C'],\n",
    "           ['C', 'C', 'C', 'G', 'G', 'G', 'B', 'B', 'J', 'J', 'J', 'B', 'B', 'G', 'G', 'G', 'C', 'C', 'C'],\n",
    "           ['C', 'C', 'C', 'C', 'G', 'G', 'G', 'J', 'J', 'J', 'J', 'J', 'G', 'G', 'G', 'C', 'C', 'C', 'C'],\n",
    "           ['C', 'C', 'C', 'C', 'C', 'G', 'G', 'G', 'J', 'J', 'J', 'G', 'G', 'G', 'C', 'C', 'C', 'C', 'C'],\n",
    "           ['C', 'C', 'C', 'C', 'C', 'G', 'G', 'G', 'G', 'G', 'G', 'G', 'G', 'G', 'C', 'C', 'C', 'C', 'C'],\n",
    "           ['C', 'C', 'C', 'C', 'G', 'G', 'G', 'G', 'G', 'G', 'G', 'G', 'G', 'G', 'G', 'C', 'C', 'C', 'C'],\n",
    "           ['C', 'C', 'C', 'G', 'G', 'G', 'G', 'B', 'B', 'B', 'B', 'B', 'G', 'G', 'G', 'G', 'C', 'C', 'C'],\n",
    "           ['C', 'C', 'G', 'G', 'G', 'G', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'G', 'G', 'G', 'G', 'C', 'C'],\n",
    "           ['C', 'C', 'G', 'G', 'G', 'J', 'B', 'B', 'J', 'B', 'J', 'B', 'B', 'J', 'G', 'G', 'G', 'C', 'C'],\n",
    "           ['C', 'C', 'G', 'C', 'G', 'J', 'J', 'J', 'J', 'B', 'J', 'J', 'J', 'J', 'G', 'C', 'G', 'C', 'C'],\n",
    "           ['C', 'C', 'C', 'C', 'G', 'J', 'J', 'J', 'J', 'B', 'J', 'J', 'J', 'J', 'G', 'C', 'C', 'C', 'C'],\n",
    "           ['C', 'C', 'C', 'C', 'G', 'G', 'J', 'J', 'G', 'G', 'G', 'J', 'J', 'G', 'G', 'C', 'C', 'C', 'C'],\n",
    "           ['V', 'V', 'V', 'V', 'V', 'V', 'V', 'V', 'V', 'V', 'V', 'V', 'V', 'V', 'V', 'V', 'V', 'V', 'V'],\n",
    "           ['V', 'V', 'V', 'V', 'V', 'V', 'V', 'V', 'V', 'V', 'V', 'V', 'V', 'V', 'V', 'V', 'V', 'V', 'V']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Défi 3</b>  \n",
    "1- Donnez le nombre de colonnes du tableau pingou1  \n",
    "2- Donnez le nombre de lignes  \n",
    "3- Déduisez le nombre de cases du tableau (= nombre de pixels de l'image)  \n",
    "4- Calculez le nombre de points gris  \n",
    "5- Déduisez la proportion de points gris (en %)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Construction d'une liste d'éléments identiques</b>  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste6 = [0] * 8\n",
    "liste6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cette instruction est très utile pour initialiser des listes de taille donnée.  \n",
    "Ensuite, il est possible de changer un élément de la liste:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste6[4] = 5\n",
    "liste6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cela se complique si l'on souhaite créer des tableaux:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tableau1 = [[0] * 3] * 4\n",
    "tableau1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Je souhaite modifier un élément du tableau:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tableau1[1][2] = 8\n",
    "tableau1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Toutes les lignes ont été modifiées!  \n",
    "En effet, l'opérateur <code>*</code> n'a pas créé des copies indépendantes, mais chaque ligne pointe sur la même liste.  \n",
    "Cela n'était pas gênant avec liste6, car l'instruction <code>liste6[4] = 5</code> ne change pas la valeur du '0' précédemment en liste6[4], mais va pointer vers un nouvel élément de valeur '5' ('0' n'est pas mutable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "id(tableau1[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "id(tableau1[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "id(tableau1[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une solution pour créer un tableaude 3 colonnes et 4 lignes distinctes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tableau2 = [] # initilisation d'un liste vide\n",
    "for i in range(4):\n",
    "    tableau2.append([0]*3) # ajout d'une nouvelle ligne constituée de 3 zéros\n",
    "tableau2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tableau2[1][2] = 8\n",
    "tableau2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Seul l'élément de la ligne d'indice 1 et de colonne d'indice 2 a été modifié.  \n",
    "Toutes les lignes sont bien indépendantes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "id(tableau2[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "id(tableau2[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Copie de listes</b>  \n",
    "Pour les mêmes raisons, il faudra être attentif lors des copies de listes.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste7 = ['a', 'b', 'c', 'd']\n",
    "liste8 = liste7\n",
    "liste8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut s'attendre à ce qu'une modification de la liste8 n'affecte pas liste7... pourtant:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste8[0] = 'z' # je modifie l'élémen d'indice 0 de liste8\n",
    "print(\"liste7:\",liste7) # j'affiche le contenu de liste7 et liste 8\n",
    "print(\"liste8:\",liste8)\n",
    "print(\"id(liste7):\",id(liste7)) # j'affiche \"l'identité\" de liste7 et liste8\n",
    "print(\"id(liste8):\",id(liste8))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En effet, l'oppérateur <code>=</code> a juste créé une nouvelle référence vers la même liste.  \n",
    "Une modifictaion sur liste7 ou liste8 impacte forcément l'autre, puisque ces 2 identificateurs pointent sur le même objet!\n",
    "\n",
    "Pour résoudre ce problème, il faut faire appel à  la méthode copy du module copy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from copy import copy\n",
    "listea = [\"a\", \"b\", \"c\", \"d\"]\n",
    "listeb = copy(listea)\n",
    "listeb[1] = \"z\"\n",
    "print(\"listea:\",listea)\n",
    "print(\"listeb:\",listeb)\n",
    "print(\"id(listea):\",id(listea))\n",
    "print(\"id(listeb):\",id(listeb))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour les listes de listes, il faut faire appel à la méthode deepcopy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from copy import deepcopy\n",
    "listec = [[\"a\", \"b\"], [\"c\", \"d\"]]\n",
    "listed = deepcopy(listec)\n",
    "listec[1][0] = \"z\"\n",
    "print(\"listec:\",listec)\n",
    "print(\"listed:\",listed)\n",
    "print(\"id(listec):\",id(listec))\n",
    "print(\"id(listed):\",id(listed))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Construire une liste d'éléments qui répondent à une règle:</b> Listes en compréhension  \n",
    "Imaginons que je doive construire une liste des 10 premiers multiples de 5.  \n",
    "Voici plusieurs façons d'y parvenir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "multiple_5=[] # j'initialise la liste vide\n",
    "for i in range(20):\n",
    "    multiple_5.append(i*5)\n",
    "multiple_5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "multiple_5 = list(range(0,100,5))\n",
    "multiple_5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On voit que le deuxième solution est plus efficae. Mais il existe une autre solution encore plus forte:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "multiples_5 = [5 * i for i in range(100)]\n",
    "multiple_5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cette technique permet d'aller plus loin.\n",
    "Imaginons maintenant que nous souhaitons construire une liste qui répond à ne fonction f(x):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x): # f(x) est une fonction  mathématiques quelconque\n",
    "    return (x**3-6*x**2-10) # ici, f(x) correspond à un polynome\n",
    "    \n",
    "x = [i for i in range(-5,10)] # x est la liste de tous les entiers de -5 à 9\n",
    "y = [f(a) for a in x] # y est la liste de toutes les images de f(a), a appartenant à l'ensemble x\n",
    "print(x) # affiche la liste x\n",
    "print(y) # affiche la liste y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il devient possible de tracer par exemple le graphique de la courbe correspondnt à la fonction f sur l'ensemble de définition x."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt # importation de la bibliothèque matpllotlib\n",
    "\n",
    "plt.plot(x, y) # trace le graphique de y en fonction de x\n",
    "plt.grid() # affiche la grille\n",
    "plt.show() # affiche le graphique"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cerise sur le gâteau avec des listes emboitées:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "listef = [[[i, j] for i in range(1,4)] for j in range(2,4)]\n",
    "listef"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "listef est une liste de listes de couples:  \n",
    "<code>listef[0]</code> comprend tous les couples [i,2] pour i allant de 1 à 3  \n",
    "<code>listef[1]</code> comprend tous les couples [i,3] pour i allant de 1 à 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Défi 4:</b> Analyse d'une consommation d'eau  \n",
    "Le  fichier <i>conso_eau_fin_2019.csv</i> du répertoire <i>fichiers</i> contient les relevés quotidients de la consmmation d'eau d'un ménage entre le 22/07/2019 et le 31/12/2019.  \n",
    "22/07/2019 13:00;883674  \n",
    "23/07/2019 13:00;883674  \n",
    "24/07/2019 13:00;883674  \n",
    "25/07/2019 13:00;883674  \n",
    "26/07/2019 13:00;883780  \n",
    "27/07/2019 13:00;884583  \n",
    "...  \n",
    "Le début de la ligne correspond au jour et l'heure du relevé.  \n",
    "Après le séparateur ; le nombre correspond à l'indice  du compteur d'eau en litres.\n",
    "\n",
    "<b>Objectifs:</b>  \n",
    "1- Récupérer les données du fichier  \n",
    "2- Tracer l'évolution de la consommation d'eau  \n",
    "3- Créer une liste des consommations journalière d'eau. En tracer le graphique.  \n",
    "4- En déduire les jours d'absence des individus dans la maison.(Consommation journalière < 20 litres)  \n",
    "5- Les jours d'absence, la consommation <20 litres correspond aux fuites dans l'habitation: Calculer la moyenne des fuites par jour."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importation des données depuis un fichier hébergé sur Github\n",
    "import urllib.request\n",
    "req = urllib.request.Request('https://github.com/ebuonocore/NS1_15_Listes/blob/master/fichiers/conso_eau_fin_2019.csv?raw=true')\n",
    "with urllib.request.urlopen(req) as response:\n",
    "    donnees_brutes = str(response.read()) # Lecture des données brutes\n",
    "    fichier_str = donnees_brutes[2:-2].replace(\"\\\\r\\\\n\",\"\\n\") # Nettoyage et mise en forme des données\n",
    "# Les données du fichier sont stockées dans la variable fichier_str de type str\n",
    "lignes = fichier_str.split(\"\\n\") # Construction de la liste des lignes du fichier\n",
    "print(*lignes, sep=\"\\n\") # Affichage des lignes du fichier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dates=[] # création de la liste vide des dates\n",
    "indice_conso = [] # création de la liste vide des indices de consommation\n",
    "\n",
    "for l in lignes: # lecture de chaque ligne dans la varaiable l\n",
    "    elements = l.split(\";\")\n",
    "    print(elements)\n",
    "    dates.append(elements[0]) # ajout des caractères correspondants à la date\n",
    "    indice_conso.append(int(elements[1]))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quel est le type d'un élément de la liste <i>dates</i> et de la liste <i>indice_conso</i>?  \n",
    "Tracer le graphique de l'évolution des consommation d'eau au cours du temps.  \n",
    "<u>Remarque:</u> Commencez par créer une liste x comprenant les entiers de 0 à len(indice_conso)-1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# création de la liste x\n",
    "# tracé du graphique de indice_conso en fonction de x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A partir de la liste <i>indice_conso</i>, créez la liste des indices de consommations jouralière <i>conso_quotidienne</i>:  \n",
    "conso_quotidienne[0] = 0  \n",
    "et conso_quotidienne[i] = indice_conso[i] - indice_conso[i-1] pour i>0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# création de la liste vide conso_quotidienne\n",
    "\n",
    "# boucle: i allant de 1 à len(indice_conso)-1\n",
    "    # ajout de conso_quotidienne[i]\n",
    "# tracé du graphique de conso_quotidienne en fonction de x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Créez la liste <i>absences</i> qui contient les dates et les consommations inférieures à 20 litres:  \n",
    "absences[i][0] correspond à la date du ième jour d'absence.  \n",
    "absences[i][1] correspond à la consommation de ce jour.  \n",
    "<u>Remarque:</u> Ne pas tenir compte du premier jour."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "absences = [] #intialisation de la liste absences \n",
    "# boucle: i parcours de 1 à len(indice_conso)-1\n",
    "    # test si la consommation de ce jour est < 20\n",
    "        # si oui, ajout des données dans la liste absences\n",
    "# affiche le nombre de jours d'absence"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tracé des consommations d'eau pendant les jours d'absences (fuites)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# création de la liste x allant de 1 à len(absences)-1\n",
    "y = [absences[i][1] for i in x] #  création de la liste y des consommations en jour d'absence\n",
    "# tracé de y en fonction de x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calcul de la moyenne des fuites et affichages des jours d'absence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# initialisation de la variable somme\n",
    "\n",
    "# boucle: i allant de 0 à len(y)-1\n",
    "    # affichage de la date de cette absence\n",
    "    # incrémentation de la quantité d'eau perdue\n",
    "# calcul et affichage de la moyenne des fuites"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<p style=\"font-family:Comic Sans MS; text-align: center; color:gray; font-size: x-small; \">- Eric Buonocore. Janvier 2021 -<br></p>\n",
    "\n",
    "![Licence CC BY NC SA](https://licensebuttons.net/l/by-nc-sa/3.0/88x31.png)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}