Tutorial_2_ListsTuplesDicts.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Listes, tuples et dictionnaires\n",
    "\n",
    "Nos variables, pour l'instant, sont un peu limitées. Supposons maintenant que je veuille entrer la taille de nombreuses particules ou les notes de chaque élève du dernier TD. Comment peut-on faire ? La solution réside dans de nouveaux types de données, les listes (`list`), tuples (`tuples`) et les dictionnaires (`dict`).\n",
    "\n",
    "### Les listes\n",
    "\n",
    "Elles sont des __collections d'objets ordonnés__, des nombres, des chaînes de caractère, ou même ... d'autres listes ! On les repère facilement par la présence de crochets `[` et `]` qui entourent les éléments de la liste, __qui sont séparés par des virgules (attention donc aux habitués de MATLAB !)__ :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grades_list = [18,11,7,12,13,6,10,9,11,14,16,10,11,9,13,17,12]\n",
    "song_word_list = ['a', 'gadou', 'dou', 'dou', 'pousse', 'la', 'banane']\n",
    "complex_list = ['a', 33, [22,76], 'dix-huit']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Indexation\n",
    "\n",
    "Pour l'instant, nos listes ne sont pas très utiles, car nous ne savons pas comment extraire un élément de celles-ci ! Pour cela, on va _indexer_ la liste en question. L'indice de chaque objet est son 'numéro d'ordre' dans la liste, le premier élément ayant pour indice 0. Indexer un tableau s'effectue en appelant la variable puis en mettant l'indice souhaité entre crochets, ce qui donne : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "third_grade = grades_list[2]\n",
    "third_word = song_word_list[2]\n",
    "print(third_grade)\n",
    "print(third_word)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour connaître le nombre d'éléments d'une liste, on peut utiliser la fonction native de Python [`len`](https://docs.python.org/3/library/functions.html#len). Pratique pour vérifier que vous n'avez pas oublié les notes d'un étudiant :-). Encore plus fort, vous pouvez sommer tous les éléments d'une liste avec la fonction [`sum`](https://docs.python.org/3/library/functions.html#sum). Comme cela, vous pouvez rapidement calculer la moyenne de vos élèves. Vous vous douterez bien que cela ne foncitonne qu'avec des types d'objets similaires dans la liste. En plus, tristesse, la fonction `sum` ne fonctionne pas pour les listes de chaînes de caractères ... on devra procéder autrement :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number_of_students = len(grades_list)\n",
    "average_grade = sum(grades_list)/number_of_students\n",
    "print(average_grade)\n",
    "sum(song_word_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour des longues listes, il n'est jamais très difficile d'extraire le dernier élément de celle-ci, mais cela est un petit peu fastidieux. Les programmeurs de Python étant particulièrement paresseux, ils ont mis en place un raccourci pour demander les derniers éléments d'une liste _via des indices négatifs_ ! Cela donne en pratique : \n",
    "\n",
    "grades_list     | 8  | 11 | 7  | 12 | 13 | 6  | 10 | ... | 11 | 9  | 13 | 17 | 12 |\n",
    "---------------:|---:|---:|---:|---:|---:|---:|---:|----:|---:|---:|---:|---:|---:|\n",
    "indices positifs| 0  | 1  | 2  | 3  | 4  | 5  | 6  | ... | 12 | 13 | 14 | 15 | 16 |\n",
    "indices négatifs|-17 |-16 |-15 |-14 |-13 |-12 |-11 | ... | -5 | -4 | -3 | -2 | -1 |\n",
    "\n",
    "On peut alors tout à fait demander : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grades_list[-2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Coupes\n",
    "\n",
    "Supposons maintenant que ma classe de TD était divisée en deux groupes d'étudiants (par exemple, les étudiants 0 à 8 dans un groupe, et les autres de 9 à 16), et que je veux connaître rapidement la moyenne de chaque sous-groupe. On peut demander à Python de nous retourner des sous-parties de notre tableau initial en l'indexant avec une _coupe_ [(un `slice`)](https://stackoverflow.com/questions/509211/understanding-slicing) `a:b` avec `a` l'indice de départ (inclus) et `b` l'indice final (__exclus__). \n",
    "\n",
    "_Notes_ : \n",
    "\n",
    "* On peut omettre l'indice `a` s'il correspond au premier élément de la liste initiale.\n",
    "* De même, on peut omettre l'indice `b` si on veut renvoyer les éléments jusqu'au dernier de la liste initiale.\n",
    "* Renvoyer une sous-liste qui commence à `a`, finit à `b-1` et prend un élément parmi `n` dans cet intervalle est également possible. Pour cela, on va l'indexer par `a:b:n` !\n",
    "* Il est tout à fait possible de renvoyer un sous-tableau avec des indices négatifs ! Il faudra dans ce cas faire attention à préciser que `n` vaut -1, ou n'importe quel entier négatif, à vrai dire..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "group_1_avg = sum(grades_list[:8])/len(grades_list[:8])\n",
    "group_2_avg = sum(grades_list[9:])/len(grades_list[9:])\n",
    "print(group_1_avg)\n",
    "print(group_2_avg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Opérations de base sur les listes\n",
    "\n",
    "Pour les habitués de MATLAB, les listes ne fonctionnent pas tout à fait comme les vecteurs, car si on essaie, par exemple, d'additionner des listes ou de les multiplier par un entier, voire un réel, on n'obtient pas le résultat escompté.:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = [3,2,5,1,6]\n",
    "print(my_list + 7) # Breaks down \n",
    "print(my_list*3)   # ?!?\n",
    "print(my_list*1.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si vous voulez retrouver le résultat escompté, vous devrez transformer les listes en _tableaux_ NumPy (`numpy.array()`). Vous en verrez plus sur ce module dans le [Tutoriel sur NumPy](./xxxxxx). Ces _tableaux_ sont très similaires aux listes, à part pour les opérations de base :-). On exécutera donc le code suivant : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy \n",
    "my_array = numpy.array([3,2,5,1,6])\n",
    "print(my_array + 7)\n",
    "print(my_array*3)\n",
    "print(my_array + 1.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il possible d'utiliser les 'opérateurs' `and` et `or` pour combiner les conditions associées à deux listes (de même taille).\n",
    "\n",
    "_Note_ : sachez que ce fonctionnement marche sur les listes, mais ne fonctionnera pas sur des objets qui _ressemblent_ aux listes et que nous verrons plus tard, notamment les [Tableaux Numpy](./Application_A_Numpy.ipynb) et les [Séries Pandas](./Application_D_Pandas.ipynb). Dans ce cas, il faudra utiliser d'[autres opérateurs](./Application_A_Numpy.ipynb#)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cities = ['Dubai', 'Sydney', 'Singapore', 'Detroit', 'Addis-Abeba', 'Amsterdam']\n",
    "too_hot = [True  , False   , True       , True     , False        ,  False]\n",
    "too_cold = [False, False   , False      , True     , False        ,  False ]\n",
    "bad_weather = too_hot and too_cold\n",
    "meh_weather = too_hot or too_cold\n",
    "\n",
    "print(cities)\n",
    "print(bad_weather)\n",
    "print(meh_weather)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On voit alors que la ville de Detroit a un climat vraiment difficile toute l'année, tandis que les villes de Sydney et d'Addis-Abeba ont un climat agréable à l'année."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Les tuples\n",
    "\n",
    "Les _tuples_ sont également des collections pas trop regardantes sur leur contenu. On les crée en utilisant des parenthèses simples `(` et `)` et, une fois de plus, on sépare les éléments contenus dans le tuple par des virgules : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_tuple = (13, 'toto', [1,2,3,4,5], ('abra', 'cadabra'), len(grades_list), sum)\n",
    "my_other_tuple = (1,2,3,4,5,6,7,8)\n",
    "print(len(my_tuple))\n",
    "print(sum(my_other_tuple))\n",
    "print(sum(my_tuple))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "À nouveau, `sum` ne va pas très bien fonctionner sur les tuples qui contiennent des objets différents, mais on peut toujours leur demander leur taille avec la fonction `len`, et on peut les indexer comme des listes avec des indices positifs, négatifs ou des _slices_ plus compliqués du type `a:b:n`. Pour l'instant, la différence entre un tuple et une liste n'est pas très claire, car il semblerait que les listes sont juste plus flexibles_ que ces derniers. Nous verrons plus tard que les listes permettent de faire des choses qui ne sont pas permises par les tuples. \n",
    "\n",
    "Note : à l'instar des listes qui peuvent contenir d'autres listes, les tuples peuvent eux-mêmes contenir des tuples, ce n'est pas interdit.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Les dictionnaires\n",
    "\n",
    "Revenons à notre classe d'étudiants. Pour l'instant, nous n'avons pas beaucoup d'empathie pour nos élèves qui ne sont que des numéros, ce qui n'est pas très pratique pour les identifier. Il serait pratique d'associer un nom à la note, voire à plusieurs notes de l'élève ! Pour cela, on peut utiliser des _dictionnaires_. Examinons l'exemple suivant : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_grades = {'Mathilde':8 , 'Lyes':11, 'Yacine':7, 'Xavier':12, 'Antoine':13, 'Paul':6, 'Roberto':10, 'Siddartha':9, 'Bruno':11, 'Elin':14, 'Artyom':16, 'Benjamin':10, 'Gary':11, 'Yanyan':9, 'Marco':13, 'Akaki':17, 'Diego':12}\n",
    "my_grades['Elin']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On a ici créé un dictionnaire en utilisant des accolades `{` et `}` et créé des paires entre des _clés_ (par exemple, `'Elin'`) et une _valeur_ (par exemple, 14) séparées par deux points `:`. Ces paires sont séparées, comme les éléments d'une liste ou d'un tuple, par des virgules `,` . On peut ensuite indexer le dictionnaire non plus par un nombre, mais via les clés du dictionnaire. Il faut savoir ici qu'on ne peut pas mettre deux fois la même clé dans un dictionnaire: ce qui peut poser problème dans notre cas si on a deux étudiants ayant le même prénom. \n",
    "\n",
    "Les _clés_ du dictionnaire sont ici des élèves, qu'on a choisi de représenter avec des `str` (chaînes de caractères), mais rien ne vous empêche d'utiliser des nombres comme _clés_ !\n",
    "\n",
    "```\n",
    "    my_grades[0] = 20\n",
    "```\n",
    "\n",
    "Vous pouvez également construire le dictionnaire 'dans l'autre sens', pour éviter les doublons au niveau des clés, et également pour calculer plus facilement la moyenne de la classe : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grades_list = [18,11,7,12,13,6,10,9,11,14,16,10,11,9,13,17,12]\n",
    "my_classroom = {'Students ' : ['Mathilde', 'Lyes', 'Yacine', 'Xavier', 'Antoine', 'Paul', 'Roberto', 'Siddartha', 'Bruno', 'Elin', 'Artyom', 'Benjamin', 'Gary', 'Yanyan', 'Marco', 'Akaki', 'Diego'],\n",
    "                'Grades'    : grades_list}\n",
    "\n",
    "number_of_students = len(my_classroom['Grades'])\n",
    "average_grade = sum(my_classroom['Grades'])/number_of_students\n",
    "\n",
    "print(average_grade)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Quiz__ : \n",
    "\n",
    "* Que se passe-t-il si vous essayer d'indexer des chaînes de caractères ?\n",
    "* Est-ce que je peux convertir un tuple en list, et inversement ? Comment faire ?\n",
    "* Est-il possible de de renvoyer des coupes de dictionnaires avec plusieurs éléments ? \n",
    "* Que se passe-t-il si j'essaie d'ajouter deux listes ? Et deux tuples ? Et deux dictionnaires ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercez-vous !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "--------------------------------------------\n",
    "\n",
    "## Manipuler efficacement nos variables avec leurs methodes associees\n",
    "\n",
    "### Chaînes de caractères \n",
    "\n",
    "Les chaînes de caractères, les listes, les tuples et les dictionnaires sont des types de variables (également appelés _classes_ en Python) assez sophistiqués. Ils possèdent des \"propriétés\" qui leur sont propres, qui vont nous permettre de _jouer_ avec ces objets, et qui vont nous rendre la vie bien pratique. \n",
    "\n",
    "Prenons un exemple concret avec une chaîne de caractères nommée `date_str` qui est en fait une date au format YYYY/mm/dd. Je voudrais obtenir l'année, le mois et le jour correspondant à cette chaîne de caractères. L'objet `date_str` contient en lui-même des \"fonctions\" (appelées _méthodes_) qui agissent sur l'objet qui lui est _parent_ et renvoient diverses choses qui pourront nous intéresser. L'une d'entre elles s'appelle `.split()` et elle est particulièrement intéressante, car elle permet de découper ma chaîne de caractères à chaque fois qu'on 'tombe' sur un caractère bien particulier. La méthode _split_ renvoie donc une _liste_ de chaînes de caractères à partir d'une chaîne 'simple' de caractères. Vérifions le fonctionnement de la méthode `.split()` afin de couper notre chaîne initiale à chaque fois qu'on tombe sur un _slash_ (`/`, barre oblique en bon françois) : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "date_str = '2022/12/23'\n",
    "\n",
    "# elements = date_str.split(date_str, '/') # split already \"knows\" it is applied to date_str, so \n",
    "elements = date_str.split('/')\n",
    "\n",
    "year = int(elements[0])\n",
    "month = int(elements[1])\n",
    "day = int(elements[2])\n",
    "day"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comme les méthodes s'appliquent à leur objet ou leur variable _parent_, on n'a pas besoin de re-passer `date_str` à l'intérieur de la méthode `.split()`. On n'a par exemple pas besoin d'écrire :\n",
    "```\n",
    "date_str.split(date_str, '/')\n",
    "```\n",
    "Et on peut simplement préciser la seule option qui nous intéresse, `'/'`, dans l'appel à `.split()`. \n",
    "\n",
    "On pourrait également avoir envie de mettre une chaîne de caractères en majuscules, afin de crier votre message sur les toits. Pour cela, on peut utiliser la méthode `.upper()` qui est 'disponible' pour les chaînes de caractère."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "quiet_str = 'a soft murmur ... everything is so quiet here !'\n",
    "quiet_str.upper()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La méthode `.upper()` n'a besoin que de l'objet _parent_ pour s'appliquer. On peut donc l'appeler avec deux parenthèses, mais avec rien du tout entre deux. Mais on ne peut pas faire l'économie de ces parenthèses, sinon la fonction ne s' 'exécute' pas. Même si la méthode (ou la fonction) ne prend pas d'arguments, il faut bien veiller à l'appeler avec des parenthèses. \n",
    "\n",
    "Il existe également une méthode `.lower()` qui va, elle, mettre tout en minuscule. C'est particulièrment pratique pour comparer deux chaînes entre elles en ignorant leur casse (c'est à dire que `'TeXTE'.lower()` va pouvoir être égal à `'Texte'.lower()`, pratique !)\n",
    "\n",
    "La liste complète des _méthodes_ associées aux chaînes de caractère est visible, par exemple [sur ce site](https://www.w3schools.com/python/python_ref_string.asp)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Listes\n",
    "\n",
    "Il est assez facile de modifier les listes grâce aux méthodes qui leurs sont dédiées. \n",
    "\n",
    "* Si vous avez malencontreusement oublié une note dans votre liste, vous pouvez très facilement l'ajouter \n",
    "  * avec la méthode `.append()`, qui va rajouter une valeur à la fin de la liste\n",
    "  * avec la méthode `.insert()`, qui va insérer à une position donnée (1er argument) une valeur donnée (2e argument)\n",
    "* Au contraire, si vous en avez une en trop, vous pouvez supprimer des éléments via :\n",
    "  * `.pop()`, qui supprime un élément à une position indiquée (et si on n'indique rien, supprime par défaut le dernier élément)\n",
    "  * `.remove()`, qui supprime la valeur indiquée, si elle est présente dans la liste. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grades_list = [18,11,7,12,13,6,10,9,11,14,16,10,11,9,13,16,12]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Note_ : Toutes ces méthodes modifient la liste, sans même qu'on ait besoin de ré-affecter le résultat. Ces méthodes ne 'renvoient rien' ... C'est obscur ? Voyez l'exemple suivant : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grades_list.pop() \n",
    "grades_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La méthode `pop` a _modifié en 'interne'_ l'objet `grades_list` sans qu'on écrive :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "smaller_list = grades_list.pop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "D'ailleurs, vous constaterez que smaller_list contient en fait la valeur qui a été extraite de la liste. Pratique, non ? \n",
    "\n",
    "La liste (oh oh) des méthodes qui s'appliquent aux objets `list` [est disponible ici](https://www.w3schools.com/python/python_ref_list.asp). Elles permettent notamment d'inverser et de trier celles-ci. \n",
    "\n",
    "__Mini-quiz__:\n",
    "* Essayez de supprimer le 14 de la liste en utilisant alternativement `.pop()` et `.remove()`\n",
    "* Artyom a eu 17 à l'examen, mais la liste des notes indique 16. Essayez de remplacer cette valeur dans la liste.\n",
    "* Essayez de trouver la méthode permettant de trier la liste de notes, et affichez ensuite les trois meilleures notes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuples\n",
    "\n",
    "C'est ici que nous comprenons la puissance des listes par rapport aux tuples. Les tuples ne sont pas modifiables _à la volée_ (on appelle cette notion la [_mutabilité_](https://towardsdatascience.com/an-overview-of-mutability-in-python-objects-8efce55fd08f)). Par conséquent, ils possèdent très peu de méthodes par rapport aux listes: \n",
    "* `count()` : qui renvoie le nombre de fois qu'un élément indiqué est présent dans le tuple\n",
    "* `index()` : qui renvoie la première position à laquelle l'élément indiqué est présent dans le tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_str = 'toto'\n",
    "my_tuple = (13, [1,2,3,4,5], ('abra', 'cadabra'), 'toto', len(grades_list), sum, ('toto, toto'), my_str)\n",
    "print(my_tuple.index('toto'))\n",
    "print(my_tuple.count('toto'))\n",
    "my_tuple[3] = 'tata'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionnaires \n",
    "\n",
    "Les dictionnaires, enfin, possèdent quelques atouts dans leur manche, qui permettent par exemple d'extraire toutes les _clés_, ou toutes les _valeurs_ du dictionnaire (la liste complète est disponible [ici](https://www.w3schools.com/python/python_ref_dictionary.asp)). Voyez plutôt : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_student_grades = {'Mathilde':8 , 'Lyes':11, 'Yacine':7, 'Xavier':12, 'Antoine':13, 'Paul':6, 'Roberto':10, 'Siddartha':9, 'Bruno':11, 'Elin':14, 'Artyom':16, 'Benjamin':10, 'Gary':11, 'Yanyan':9, 'Marco':13, 'Akaki':17, 'Diego':12}\n",
    "\n",
    "print(my_student_grades.keys()) # Lists all the student names\n",
    "\n",
    "grades = my_student_grades.values() # Lists all the student grades \n",
    "print(sum(grades)/len(grades))\n",
    "\n",
    "my_student_grades.pop('Paul')\n",
    "print(my_student_grades.keys()) # Lists the updated student names "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Types numériques 'simples'\n",
    "\n",
    "Vous vous en souvenez peut-être, mais les nombres complexes $z$ possédaient une _méthode_ `.conjugate()`. En fait, il existe des méthodes même pour les objets `float` et les `int` ... même si ceux-ci sont assez primitifs. Et, _à vrai dire_, même les opérations les plus simples, comme l'addition `+`, sont en fait en Python des méthodes 'déguisées', en l'occurrence ici `__add__`. Les développeurs de Python l'ont entourée de deux _underscores_ `__XX__` pour vous indiquer qu'il faut éviter de l'appeler vous-mêmes. C'est d'ailleurs peu pratique : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 8\n",
    "print(x.conjugate())\n",
    "print(x.__add__(7))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-----------\n",
    "\n",
    "## Quelques fonctions d'intérêt pour les `dict`, `list` et `tuple`\n",
    "\n",
    "En plus de leurs méthodes associées, il existe quelques fonctions et mots-clés qui sont principalement intéressants pour les trois classes que nous avons évoquées ci-dessus. Nous avons déjà vu les fonctions `len()`, qui renvoie le nombre d'éléments de ces objets, et la fonction `sum()` qui somme (si possible) ceux-ci. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Minimax\n",
    "\n",
    "Les fonctions `min()` et `max()` sont également définies, et ont généralement tendance à fonctionner si la fonction `sum()` fonctionne. Voyez donc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [0,5,1,0,-3,6,9,11]\n",
    "print('Table x : Min is ' + str(min(x)) + ' || Max is ' + str(max(x)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### L'appartenance : êtes-vous `in` ?\n",
    "\n",
    "Il est bien souvent nécessaire de savoir si un élément est bien inclus dans une liste, un dictionnaire ou un tableau. En Python, examiner si un élément `elem` appartient à une liste `mylist` (par exemple) s'effectue avec l'appel au mot-clé `in`, ce qui donne `elem in mylist`. De la même manière que [les opérateurs de comparaison, ou les combinaisons de booléens](./Tutorial_1_SimpleThings.ipynb#Comparaisons), l'expression `(elem in mylist)` va renvoyer un booléen et sera soit vraie, soit fausse."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Membership test for a list\n",
    "elem = 8\n",
    "mylist = [0,6,8,1,2,6,4,2,8]\n",
    "print(elem in mylist)\n",
    "\n",
    "# With a dict (one simple, and one more complex example)\n",
    "my_classroom = {'Mathilde':8 , 'Lyes':11, 'Yacine':7}\n",
    "print('Lyes' in my_classroom)\n",
    "\n",
    "my_other_classroom = {'Student': ['Mathilde', 'Lyes', 'Yacine'], 'Grade':[16,15,18]}\n",
    "print('Jean-René' in my_other_classroom['Student'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Notes_ : \n",
    "\n",
    "* Il n'existe pas de mot-clé `out`, mais vous pouvez toujours écrire `not in` :-)\n",
    "* Le mot-clé `in` n'est pas capable de prendre en compte l'_inclusion_ (le $\\subset$ mathématique), il n'exprime vraiment que l'appartenance (le $\\in$ mathématique). Le code suivant ne fonctionnera donc pas : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist = [0,1,2,3,4,5,6]\n",
    "print([0,1] in mylist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Un pour tous, et tous pour un : les cas `any` et `all`\n",
    "\n",
    "Nous avons vu dans le [tutoriel précédent](./Tutorial_1_SimpleThings.ipynb#-Autres-opérateurs-:-and-,-or-,-not-,-^-(XOR)) qu'il est possible de combiner des conditions (correspondant à des booléens) afin d'exprimer les notions de _ou_ (`or`) ou de _et_ (`and`) en termes informatiques. Cela est assez pratique lorsqu'il faut combiner deux, ou quelques conditions. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Any\n",
    "\n",
    "Supposons maintenant que nous souhaitions examiner si une condition parmi un _grand nombre_ vaut `True`. Disons, par exemple, que j'ai un objet `list` contenant un grand nombre de booléens, et j'aimerais 'empiler' les conditions `or` afin de savoir si au moins une des valeurs est `True`. Il n'est pas très pratique d'écrire :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "conds = [False, False, False, False, False, False, False, False, True, False, False, False, False, True]\n",
    "result = False\n",
    "\n",
    "for cond in conds:\n",
    "    result = result or cond\n",
    "\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les petits malins auront pensé à utiliser `in`, ce qui fonctionne effectivement dans ce cas :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "result = True in conds\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vous pouvez également utiliser la fonction __`any()`__, qui va vérifier si au moins un des éléments de votre liste est bien `True` : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(any(conds))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sachez que l'instruction `any(conds)` est plus flexible que `True in conds`. Voyez plutôt l'exemple suivant, sur une liste qui contient des chaînes de caractères :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist_str = ['', '', '', '', 'toto']\n",
    "print(any(mylist_str))\n",
    "\n",
    "mytup_lst = ([], [], [])\n",
    "print(any(mytup_lst))\n",
    "\n",
    "mylist_mix = [[], '', (), {}, False]\n",
    "print(any(mylist_mix))\n",
    "\n",
    "mylist_mix.append(8)\n",
    "print(any(mylist_mix))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En fait, la fonction `any()` va vérifier si au moins un des éléments des `list` ou `tuple` vaut _autre chose_ que : \n",
    "* `False`, c'est attendu\n",
    "* `0`,  qui est à peu près équivalent au `False`\n",
    "* `''`, la chaîne de caractères vide, qui est 'équivalente' à `False` en Python\n",
    "* `()`, un tuple vide (eh oui)\n",
    "* `[]`, une liste vide (tant qu'à faire)\n",
    "* `{}`, et un dictionnaire vide (afin d'être raccord avec les tuples et les listes)\n",
    "* `None`, qui est l'équivalent de _rien_ en Python, et qui a des applications _bien particulières_ que je n'évoquerai pas ici, mais vous pouvez en savoir plus [en suivant ce lien (en anglais)](https://www.pythontutorial.net/advanced-python/python-none/).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### All\n",
    "\n",
    "À l'inverse, la fonction `all()` va renvoyer `True` si et seulement si _aucun_ des éléments d'une `list` ou d'un `tuple` n'est dans la liste à puces ci-dessus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_tuple = (3, True, 'Yes', [2,3,1], '')\n",
    "print(all(my_tuple))\n",
    "\n",
    "my_list = [3,23,[3], 'OK', True]\n",
    "print(all(my_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Mini-quiz__ : \n",
    "\n",
    "* Comment se comportera ma liste alambiquée `my_convoluted_list` avec `any` et `all` ? Comment comprenez-vous le résultat ?\n",
    "* Comment se comportent `any` et `all` avec des dictionnaires ? Essayez de jouer avec `my_awkward_dict` pour obtenir différents résultats ! Sur quels éléments du dictionnaire `any` et `all` agissent-ils ?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_convoluted_list = [[[]],[],[]]       \n",
    "my_awkward_dict = {False:3}             # Who even thinks of this ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----------------------------------\n",
    "\n",
    "## Python et la mutabilite\n",
    "\n",
    "### Un peu de sorcellerie...\n",
    "\n",
    "Examinons l'exemple suivant. Nous allons créer une liste `my_list` contenant des éléments, et 'copier' cette liste et nommer le résultat `the_same_list`. Rien de plus simple, _a priori_ ! Modifions maintenant un objet de `my_list`, après avoir créé `the_same_list`, et examinons le code suivant : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = ['hey', 'oh', 'lets', 'go']\n",
    "the_same_list = my_list\n",
    "my_list[3] = 'take five'\n",
    "the_same_list # should not be modified, right ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Sorcellerie !_ diront les personnes familières de MATLAB, C ou Fortran. Pour comprendre ce que nous avons fait ici, il faut comprendre le sens de la déclaration `the_same_list = my_list`. Écrire cette ligne revient à dire que les deux noms de variable pointent vers un même objet dans la mémoire de l'ordinateur, ou identifiant, accessible en utilisant la fonction native de Python [id](https://docs.python.org/fr/3.6/library/functions.html#func-id). L'`id` est en fait l'adresse mémoire de l'objet en question, donc deux variables à `id` identiques sont en fait une seule et même 'chose' !\n",
    "\n",
    "Les `list` et les `dict` sont des objets dits _mutables_: on peut les modifier à loisir sans que leur `id` ne change. C'est pour cela que quand j'ai travaillé sur `my_list`, les changements ont été répercutés sur `the_same_list` ! Essayons maintenant de faire la même chose pour un entier : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_int = 5\n",
    "my_other_int = my_int\n",
    "my_int = 6 # A solid improvement on previous value\n",
    "print('Is ' + str(my_int) + ' equal to ' + str(my_other_int) + ' ?') "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cette fois-ci, cela ne fonctionne pas, les changements opérés sur `my_int` n'ont pas été répercutés sur `my_other_int`. Derrière tout cela, il faut comprendre qu'on ne peut pas réellement modifier les `int`, `str`, `float`, `tuple` une fois qu'ils sont créés. Ils ne sont donc pas _mutables_. En écrivant la ligne `my_int = 6`, on crée en fait une nouvelle variable à une nouvelle adresse, alors que `my_other_int` reste inchangé. On peut s'en convaincre en demandant à Python d'afficher les identifiants des objets en question : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_int = 5\n",
    "my_other_int = my_int\n",
    "print('Ids are : ' + str(id(my_int)) + ' and ' + str(id(my_other_int)))\n",
    "my_int = 6\n",
    "print('Ids are : ' + str(id(my_int)) + ' and ' + str(id(my_other_int)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Actions a distance sur les variables\n",
    "\n",
    "Revenons notre groupe de TD. Vous l'aurez peut-être remarqué, la méthode `.keys()` nous a renvoyé un drôle d'objet de type `dict_keys`. C'est une classe comme une autre, comme `str` ou `list`. On peut d'ailleurs la convertir en liste. Essayons de retirer un élément de notre dictionnaire (par exemple, un étudiant trop brillant), et examinons l'impact sur la moyenne "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_student_grades = {'Mathilde':8 , 'Lyes':11, 'Yacine':7, 'Xavier':12, 'Antoine':13, 'Paul':6, 'Roberto':10, 'Siddartha':9, 'Bruno':11, 'Elin':14, 'Artyom':16, 'Benjamin':10, 'Gary':11, 'Yanyan':9, 'Marco':13, 'Akaki':17, 'Diego':12}\n",
    "grades = my_student_grades.values()\n",
    "names = my_student_grades.keys()\n",
    "\n",
    "print(names)\n",
    "print('Average grade is : ' + str(sum(grades)/len(grades)))\n",
    "\n",
    "my_student_grades.pop('Akaki')\n",
    "\n",
    "print(names)\n",
    "print('Average grade is now : ' + str(sum(grades)/len(grades)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_A priori_, je n'ai pas touché aux variables `grades` et `names`, et pourtant elles ont bel et bien été modifiées lorsque j'ai retiré un élément de mon dictionnaire ! Ces actions sont rendues possibles car les objets de type `dict_keys` et `dict_values` (pour `.values()`) sont _mutables_ et liés au contenu du dictionnaire `my_student_grades` (c'est à dire que ces objets sont également _mis à jour_ lorsqu'on modifie l'objet `my_student_grades`). Cet effet peut être très pratique, mais peut également occasionner des gros maux de tête lorsque des variables sont modifiées 'comme par enchantement', ou à l'inverse ne sont pas modifiées du tout dans des codes plus compliqués !\n",
    "\n",
    "### Dupliquer des objets mutables : la copie\n",
    "\n",
    "#### Copie simple (de _surface_)\n",
    "\n",
    "Nous avons vu que faire `list_b = list_a` avec des listes en Python ne duplique pas vraiment le contenu de la liste en question (ou du dictionnaire en question). Il est parfois intéressant de le faire quand même, par exemple, pour comparer la version 'originale' et la version 'modifiée' d'une liste. Comment s'en sortir ? Pour cela, on utilise la méthode `copy()` présente pour les objets _mutables_. On peut se convaincre qu'on a bien deux objets distincts en examinant leur identifiant : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = {'toto' : 77}\n",
    "y = x.copy()\n",
    "print('Id match : ' + str(id(x)) + ' = ' + str(id(y)) + ' ?')\n",
    "print('Value match : ' + str(x == y))\n",
    "\n",
    "u = [3,4,5]\n",
    "v = u.copy()\n",
    "print('Id match : ' + str(id(u)) + ' = ' + str(id(v)) + ' ?')\n",
    "print('Value match : ' + str(u == v))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les deux variables sont bien _identiques_ dans leur contenu, mais elles correspondent à deux identifiants (ou adresses mémoires) distincts. On peut alors modifier l'un sans que ces changements soient répercutés sur l'autre variable... Ou est-ce bien le cas ? \n",
    "\n",
    "#### Copie en profondeur\n",
    "\n",
    "Pour comprendre encore plus en détail comment la méthode `copy()` fonctionne, essayons maintenant un cas plus retors, d'une liste contenant elle-même d'autres listes. Créons une variable `my_list`, que nous allons placer dans une liste de listes nommée adroitement `list_of_lists` et faisons une copie de `list_of_lists` avec la méthode `copy()`. Nos deux listes de listes sont distinctes ... mais que se passe-t-il si je modifie `my_list` une fois mes deux objets créés ? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = [2,3,4]\n",
    "list_of_lists = [[2,6,4], [5,6,3], my_list]\n",
    "the_same_list_of_lists = list_of_lists.copy() # This is starting to get a bit odd ...\n",
    "my_list.append('HACKED')\n",
    "print('ID : ' + str(id(list_of_lists))         + ' -> ' + str(list_of_lists))\n",
    "print('ID : ' + str(id(the_same_list_of_lists)) + ' -> ' + str(the_same_list_of_lists))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ici, en utilisant la méthode `copy()`, on a créé un nouvel objet `the_same_list_of_lists` distinct du premier, mais les deux _pointent_ vers d'autres objets, dont notamment `my_list` qui est identique aux deux listes de listes ! On peut s'en rendre compte en regardant les `id` des éléments de nos deux listes de listes :  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "id(list_of_lists[1]), id(the_same_list_of_lists[1]) # They are the same !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notre méthode `copy()` ne copie qu'en _surface_ le contenu des variables les plus complexes. Pour dupliquer complètement une variable complexe en obligeant chacun des sous-éléments a être également des copies _distinctes_ des objets initiaux ...\n",
    "\n",
    "![image](./resources/deeper.jpg)\n",
    "\n",
    "Cela n'est pas possible avec les fonctions Python de base, mais le module [copy](https://docs.python.org/3/library/copy.html#copy.deepcopy) permet d'effectuer une telle opération de copie _en profondeur_ via l'utilisation de la fonction `deepcopy()`.\n",
    "\n",
    "__Mini-quiz__ (difficile !) : \n",
    "\n",
    "* Dans le code ci-dessous, pensez-vous que `old_avg_grades` et `new_avg_grades` seront identiques ? Essayez d'interpréter le résultat, notamment en comparant le code à celui de la section [précédente](###-Actions-a-distance-sur-les-variables) !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_student_grades = {'Mathilde':8 , 'Lyes':11, 'Yacine':7, 'Xavier':12, 'Antoine':13, 'Paul':6, 'Roberto':10, 'Siddartha':9, 'Bruno':11, 'Elin':14, 'Artyom':16, 'Benjamin':10, 'Gary':11, 'Yanyan':9, 'Marco':13, 'Akaki':17, 'Diego':12}\n",
    "grades = list(my_student_grades.values()) \n",
    "old_avg_grades = sum(grades)/len(grades)\n",
    "my_student_grades.pop('Akaki')\n",
    "new_avg_grades = sum(grades)/len(grades)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Je voudrais faire une copie complètement indépendante d'une liste initiale, qui ne contient que des `tuple` et des chaînes de caractères (`str`). Est-il nécessaire de faire une copie _en profondeur_ de ma liste initiale ?"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  },
  "vscode": {
   "interpreter": {
    "hash": "cb9c252e610b593a3421828f92740a33c32c552b9658c846af1824aa6c7c0cc9"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}