ajout representation construits

representation_base/DM.md

@@ -1,126 +0,0 @@
-# Devoir maison 1ère NSI
-
-
-
-> Dans cette évaluation, vous allez être confrontés à des exercices de conversions, de représentations, ainsi que de manipulations python basiques.
-> Prenez le temps de lire les consignes des exercices, et n'oubliez pas que sur papier, vous n'avez pas la possibilité de tester votre code. Soyez donc vigilant-e-s aux détails. 
->
-> Ce devoir est à rendre pour le vendredi 12 Novembre
-
-------------
-
-
-
-## Première Partie : Numération
-
-
-
-### Exercice n°1
-
-- Prendre sa date de naissance : additionner le jour, le mois, ainsi que l'année. On obtient alors un grand nombre en base 10.
-- Représenter ce nombre en base 16 en expliquant la démarche.
-- Représenter le jour de sa date de naissance en base 2. Détailler la méthode.
-
-
-
-### Exercice n°2
-
-- Donner l'écriture en base 10 des nombres suivants en détaillant la démarche :
-  - 10011100<sub>2</sub>
-  - 01010011<sub>2</sub>
-  - 10100100<sub>2</sub>
-  - BEEF <sub>16</sub>
-  - 70E <sub>16</sub>
-
-
-
-
-
-### Exercice n°3
-
-- Écrire les nombres suivants en base 16. Détaillez votre raisonnement :
-  - 1111010100001010<sub>2</sub>
-  - 1011(10)
-  - 6887<sub>10</sub>
-
--------------
-
-
-
-## Deuxième Partie : Représentation des entiers relatifs & des nombres décimaux
-
-
-
-### Exercice n°1
-
-Soit l'écriture de l'entier relatif  **-3** sur 8 bits : 1000 0011<sub>2</sub>
-
-- S'agit-il de binaire signé ou non signé ?
-- Représenter -5,  -31, -64 et  -125 avec cette méthode
-
-On peut également représenter -3(10) sous cette forme 1111 1101(2)
-
-- Comment s'appelle la méthode de représentation utilisée ici ?
-- En appliquant la même méthode, représenter -5, -31, -64 et -125 en expliquant une fois votre méthode.
-
-
-
-
-
-### Exercice n°2
-
-
-
- **Pour convertir un réel décimal vers la base 2, on applique la méthode suivante, par exemple le nombre 12,6875** :
-
-- On commence par convertir la partie entière : 12 <sub>10</sub> = 1100 (10)
-- Puis, avec la partie décimale, on procède à des multiplications par 2 successives.
-- Après chaque multiplication, on reprte le résultat sans la partie entière.
-- Le calcul se poursuit jusqu'à ce que le résultat soit 1 :
-  - 0,6875 * 2 = 1,375
-  - 0, 375 * 2 = 0,75 
-  - 0,75 * 2 = 1,5
-  - 0,5 * 2 = 1
-- Il ne nous reste plus qu'à noter la partie entière obtenue à chaque opération, de haut en bas : 0,675(10) = 1011(2) 
-- Alors on peut écrire 12, 6875 <sub>10</sub> = 1100, 1011<sub>2</sub>
-
-
-
-**Appliquer cette méthode pour représenter les nombres suivants:**
-
-- 0,1 
-- 0,3
-- 12,4
--  32,06
-
-
-
---------------
-
-
-
-## Troisième Partie : Codage des booléens
-
-
-
-### Exercice n°1
-
-Simplifier ces équations logiques:
-
-1. $`S = (\overline{a} \lor b) \land (a \lor b)`$
-2. $`S = \overline{a} \land b \land \overline{c} \lor \overline{a} \land b \land c \lor a \land b \land \overline{c} \lor a \land b \land c`$
-3. $`S = a \land b \land c \lor b \land c \lor b \land \overline{b}`$
-4. $`S = (a \lor \overline{a} \land b) \land \overline{( a \lor b )} \lor b \land \overline{c} \lor b \land c`$
-
-
-
-### Exercice n°2
-
-
-
-Ecrire les tables de vérités des équations ci dessus.
-
-
-
-
-

representation_base/chapitre_1/cours/README.md

@@ -8,7 +8,7 @@
 <br>
 
 
-![bo_1.png](../../assets/BO_1.PNG)
+![bo_1.png](/premiere/representation_base/assets/BO_1.PNG)
 
 
 ## <span style="color:blue"> Apport de connaissances </span>
@@ -33,7 +33,7 @@ Donc 4138 peut s’écrire : 4 * 10<sup>3</sup> + 1 * 10<sup>2</sup> + 3 * 10<su
 →où 10 est appelé BASE de cette numération (ici décimale)<br>
 →où chaque chiffre (compris entre 0 et 9) est soit celui des unités, dizaines, etc…
 
-![exercice_1.png](../../assets/exercice_1.PNG)
+![exercice_1.png](/premiere/representation_base/assets/exercice_1.PNG)
 
 ✏ *Un nombre est égal à la somme des valeurs de ses rangs, et on peut décomposer n'importe quel nombre en
 puissance de sa base.* ✏
@@ -45,9 +45,9 @@ contraction de **_binary digit_**, littéralement **_chiffre binaire_**. <br>Un
 En électronique, il est facile d'obtenir un système présentant deux états stables distincts. Prenons l'exemple
 d'un interrupteur
 
-![interrupteur.png](../../assets/interrupteur.PNG)
+![interrupteur.png](/premiere/representation_base/assets/interrupteur.PNG)
 
-![exemples.png](../../assets/exemples.PNG)
+![exemples.png](/premiere/representation_base/assets/exemples.PNG)
 
 Ainsi, pour coder une information qui peut ne prendre que deux états stables, la numération binaire est la
 plus adaptée.
@@ -63,13 +63,13 @@ l’occurrence 2 et 10), nous adoptons les notations suivantes.
 → Méthode des divisions successives <br>
 Exemple: (11)<sub>d</sub> = (?)<sub>b</sub>
 
-![10_vers_2.png](../../assets/10_vers_2.PNG)
+![10_vers_2.png](/premiere/representation_base/assets/10_vers_2.PNG)
 
 (11)<sub>d</sub> => (1011)<sub>b</sub>
 
 <br>
 
-
+ 
 ✏ <span style ="color:purple"> Comment représenter des informations complexes ? </span> ✏
 
 <li>Avec 1 bit, nous pouvons coder 2 informations.
@@ -81,7 +81,7 @@ Si nous généralisons un peu : avec **_k_** bits, nous pouvons coder **_2<sup>k
 
 Compléter le tableau suivant afin de coder les 8 premiers entiers naturels (entiers positifs ou nul)
 
-![tableau.png](../../assets/tableau.PNG)
+![tableau.png](/premiere/representation_base/assets/tableau.PNG)
 
 ### À faire vous-même 
 
@@ -96,7 +96,7 @@ Un octet ((**byte** en anglais) est un regroupement de 8 bits.
 On parle aussi de mot. Il permet de coder 2<sup>8</sup> = 256 mots différents.
 Si nous codons des entiers naturels, nous coderons les nombres 0 à 255. Dans la littérature, un regroupement de 4 bits est appelé un quartet (cela nous servira plus tard).
 
-![octet.png](../../assets/octet.PNG)
+![octet.png](/premiere/representation_base/assets/octet.PNG)
 
 ### <span style="color:violet">Unités de mesure</span>
 
@@ -126,7 +126,7 @@ Méthode :
 <li>Ecrire le nombre binaire dans le tableau de correspondance <br>
 <li>Faire la somme des valeurs des rangs pour lesquels la valeur du bit vaut 1.
 
-![2_vers_10.png](../../assets/2_vers_10.PNG)
+![2_vers_10.png](/premiere/representation_base/assets/2_vers_10.PNG)
 
 Somme : ............
 
@@ -153,11 +153,11 @@ Ce sera donc un système en **base 16**.
 
 > Compléter la colonne binaire
 
-![binaire.png](../../assets/binaire.PNG)
+![binaire.png](/premiere/representation_base/assets/binaire.PNG)
 
 > Passer de la base décimale à la base hexadécimale <br> Écrire le nombre 63650 (10) en base 16
 
-![exercice_2.png](../../assets/exercice_2.PNG)
+![exercice_2.png](/premiere/representation_base/assets/exercice_2.PNG)
 
 > Faisons la conversion de la base 16 vers la base 10, écrire le nombre 2A3 (16) en base décimale
 
@@ -165,7 +165,7 @@ Méthode :
 <li>Ecrire le nombre hexadécimal dans le tableau de correspondance en positionnant le chiffre correspondant à chacun des rangs.
 <li> Faire la somme des produits des chiffres avec la pondération correspondante.
 
-![tableau-hexa.png](../../assets/tableau_hexa.PNG)
+![tableau-hexa.png](/premiere/representation_base/assets/tableau_hexa.PNG)
 
 > Passer du code binaire au code hexadécimal
 
@@ -189,7 +189,7 @@ Pour passer d'une base à une autre, on passera par la base 10 car c'est sur cet
 
 Exemple : (944)<sub>10</sub> → ( 12234)<sub>5</sub>
 
-![base_quelconque.png](../../assets/Base_quelconque.PNG)
+![base_quelconque.png](/premiere/representation_base/assets/Base_quelconque.PNG)
 
 -------------------------
 
@@ -201,24 +201,24 @@ Prenons l'exemple d'un mot de 2 octets (16 bits) comme 5BC9. Il y a deux organis
 
 <li> Le gros boutisme (ou ou « mot de poids fort en tête » ou big endian en anglais), qui consiste à placer l'octet de poids fort en premier, c'est à dire à l'adresse mémoire la plus petite.
 
-![gros_boutisme.png](../../assets/gros_boutisme.PNG)
+![gros_boutisme.png](/premiere/representation_base/assets/gros_boutisme.PNG)
 
 > Quelques architectures respectant cette règle : _les processeurs Motorola 68000, les SPARC (Sun Microsystems) ou encore les System/370 (IBM)_. De plus, tous les protocoles TCP/IP communiquent en gros-boutiste. Il en va de même pour le protocole PCI Express.
 
 <li>Le petit boutisme (ou little endian en anglais), qui au contraire place l'octet de poids faible en premier.
 
-![petit_boutisme.png](../../assets/petit_boutisme.PNG)
+![petit_boutisme.png](/premiere/representation_base/assets/petit_boutisme.PNG)
 
 > Les processeurs x86 ont une architecture petit-boutiste. Celle-ci, au prix d'une moindre lisibilité du code machine par le programmeur, simplifiait la circuiterie de décodage d'adresses courtes et longues en 1975, quand un 8086 avait 29 000 transistors. Elle est d'influence pratiquement nulle aujourd’hui.
 
 Généralisons pour 4 octets. Ainsi, le mot 5BC96AF sera représenté de la manière suivante :
 en **gros boutisme**
 
-![gros_boutisme_2.png](../../assets/gros_boutisme_2.PNG)
+![gros_boutisme_2.png](/premiere/representation_base/assets/gros_boutisme_2.PNG)
 
 en **petit boutisme**
 
-![petit_boutisme_2.png](../../assets/petit_boutisme_2.PNG)
+![petit_boutisme_2.png](/premiere/representation_base/assets/petit_boutisme_2.PNG)
 
 La représentation petit ou gros boutisme est en principe transparente à l'utilisateur car cela est géré au niveau du système d'exploitation. Cette représentation prend de l'importance quand on accède aux octets soit en mémoire, soit lors d'échanges d'informations sur un réseau.
 

representation_construits/chapitre_1/.ipynb_checkpoints/README-checkpoint.ipynb

@@ -0,0 +1,682 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "8e7931fd",
+   "metadata": {},
+   "source": [
+    "# Représentation des données : tuples, listes et itérations"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "eb82a1d6",
+   "metadata": {},
+   "source": [
+    "> ***Contenue*** : Notions introduites : le type conteneur, avec les listes, les tuples, parcours de séquences. \n",
+    "\n",
+    "> ***Compétences*** : Comprendre la différence entre une liste python et un tuple. Maîtriser la création de conteneurs sur Python."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "351877cc",
+   "metadata": {},
+   "source": [
+    "## Le programme"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "72d95029",
+   "metadata": {},
+   "source": [
+    "------\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e0891811",
+   "metadata": {},
+   "source": [
+    "![bo_tuple](../assets/bo_tuple.png)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d2f3b985",
+   "metadata": {},
+   "source": [
+    "![bo_liste](../assets/bo_liste.png)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b9d904ad",
+   "metadata": {},
+   "source": [
+    "## Apport de connaissances"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ff539106",
+   "metadata": {},
+   "source": [
+    "----"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9c9c328a",
+   "metadata": {},
+   "source": [
+    "Les types *conteneurs* comme les tuples ou les listes permettent de stocker des objets, et proposent des méthodes d'accès, de modification et d'itération sur ces mêmes objets.\n",
+    "\n",
+    "Ici nous allons voir trois types de conteneurs en particulier : les tuples, les listes, et enfin les dictionnaires. En apprenant à créer et à manipuler ces  types d'objets, cela nous permettra de travailler sur un grand nombre de données de manière rapide et efficace."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "aa48414d",
+   "metadata": {},
+   "source": [
+    "------"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3895f0e2",
+   "metadata": {},
+   "source": [
+    "### Les listes"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c4141b1e",
+   "metadata": {},
+   "source": [
+    "Pour le moment, nous n'avons appris à travailler qu'avec un nombre limité de variables. Cependant, il peut arriver que vous deviez lire, stocker, traiter et enfin imprimer des dizaines, voire des centaines ou des milliers de valeurs de données. Comment stocker et accéder efficacement à ces données ? \n",
+    "\n",
+    "Par exemple, si l'on décide de de manipuler une demi-douzaine de variables, doit on les déclarer comme ceci : "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "487520fb",
+   "metadata": {},
+   "source": [
+    "var1 = int(input())\n",
+    "var2 = int(input())\n",
+    "var3 = int(input())\n",
+    "var4 = int(input())\n",
+    "var5 = int(input())\n",
+    "var6 = int(input())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4693983f",
+   "metadata": {},
+   "source": [
+    "Nous allons voir qu'avec une liste, nous allons pouvoir déclarer une variable à valeurs multiples."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3764753e",
+   "metadata": {},
+   "source": [
+    "---------"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "888b14c9",
+   "metadata": {},
+   "source": [
+    "### Créer une liste\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "34e6d597",
+   "metadata": {},
+   "source": [
+    "Créer une liste vide :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a0b2f16b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "nom_liste = []"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0010c492",
+   "metadata": {},
+   "source": [
+    " On peut les créer par ***extension*** (comprendre *liste déclarée littéralement*) comme ceci :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ea5c9f4b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "nom_liste = [3, 8, 5, 4]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0621a32d",
+   "metadata": {},
+   "source": [
+    "Mais aussi par ***compréhension*** (itération, que l'on verra plus loin)\n",
+    "\n",
+    "On peut tester ça dans la console python "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "21bf0b13",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lst = [2, 3, 5, 7 ]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4192f777",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "type (lst)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7c8925ab",
+   "metadata": {},
+   "source": [
+    "On peut afficher la liste de la même manière qu'une variable classique :  avec la commande *print* "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9b7f5057",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print (lst)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5e01b094",
+   "metadata": {},
+   "source": [
+    "--------"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "60990b42",
+   "metadata": {},
+   "source": [
+    "### Accéder aux élèments d'une liste"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f2572686",
+   "metadata": {},
+   "source": [
+    "Les élèments d'une liste peuvent être comparé à des élèments d'une séquence : chaque élèment a une position précise dans la liste, comme nous l'avons vu pour les chaînes de caractères (*str*)\n",
+    "\n",
+    "On appelle cette position *indice*, c'est cet indice qui nous permet d'accéder à un élèment en particulier.\n",
+    "\n",
+    "Le premier élèment d'une liste a pour indice **0**\n",
+    "\n",
+    "Tout comme avec les chaînes de caractères, un indice négatif permet d'accéder l'élèment en partant de la fin\n",
+    "\n",
+    "Pour connaître le nombre total d'élèments dans une liste, on utilise la fonction ***len***"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "903af397",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lst = [2,4,6,8]\n",
+    "len (lst)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "68933336",
+   "metadata": {},
+   "source": [
+    "On peut désigner une **tranche** en indiquant l'indice du premier élèment, ainsi que celui du dernier ***non inclus***"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d8368df4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lst [1:3]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1ff6aae5",
+   "metadata": {},
+   "source": [
+    "Attention : Un indice qui dépasse la valeur *longueur de la liste - 1* provoquera une erreur dans votre code"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3284e1b0",
+   "metadata": {},
+   "source": [
+    "---------"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e4e3c049",
+   "metadata": {},
+   "source": [
+    "### Parcours d'une liste"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3a0de921",
+   "metadata": {},
+   "source": [
+    "Comme indiqué plus haut, il est possible de créer et de parcourir une liste par une méthode dite *de compréhension* ou *itération*\n",
+    "\n",
+    "Celà signifie qu'on construit une liste à partir d'élèments itérables : que l'on peut répétèr. Par exemple :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "289a75cf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "liste = [x for x in range(5)]\n",
+    "print(liste)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1f8399fe",
+   "metadata": {},
+   "source": [
+    "Que vous affiche la console ?\n",
+    "\n",
+    "L'intérêt des listes par compréhension, c'est que l'on peut utiliser les structures conditionnelles, à l'aide de boucles...\n",
+    "\n",
+    "On peut également initialiser une liste à partir d'une autre liste "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a3360286",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "liste = [1, 2, 3, 4]\n",
+    "nouvelle_liste = [2 * x for x in liste]\n",
+    "print(nouvelle_liste)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d7262a39",
+   "metadata": {},
+   "source": [
+    "Une fois que la liste est crée, on peut la parcourir :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a9e9e9ec",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for elt in lst:\n",
+    "    print (elt, end='')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bded0a4f",
+   "metadata": {},
+   "source": [
+    "Ici, on va afficher chaque élèment de la liste lst\n",
+    "\n",
+    "On peut également utiliser une boucle en itérant l'indice i des élèments :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "26be31c2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for i in range (len(lst)):\n",
+    "    print(lst[i], end='')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "78dc79dd",
+   "metadata": {},
+   "source": [
+    "Ici, pour i compris entre 0 et longueur de lst, on va affichier l'élèment correspondant à l'indice valant i.\n",
+    "\n",
+    " À faire : \n",
+    "\n",
+    "- créer une liste par extension, puis par itération\n",
+    "- afficher les élèments d'une liste"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e4e5f08f",
+   "metadata": {},
+   "source": [
+    "-------\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "baa22c54",
+   "metadata": {},
+   "source": [
+    "### Propriétés d'une liste"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ab2684f4",
+   "metadata": {},
+   "source": [
+    "Une liste peut être modifiable : on parle d'un objet *mutable*\n",
+    "\n",
+    "- On peut donc supprimer un élèment d'une liste avec le mot clé *del*\t"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "afc4143f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lst = [1,2,3,4,5]\n",
+    "del lst[0]\n",
+    "print(lst)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "72921eae",
+   "metadata": {},
+   "source": [
+    "Il faut noter qu'en supprimant l'élèment situé à l'indice 0, j'ai donc fait changer tous les indices des élèments de la liste !\n",
+    "On peut également ajouter un élèment à la liste : "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3e6aeb54",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lst = [1,2,3,4,5]\n",
+    "lst.append(6)\n",
+    "print (lst)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c2ae9958",
+   "metadata": {},
+   "source": [
+    "L'élèment ajouté se positionne donc à la *fin* de la liste\n",
+    "\n",
+    "Pour modifier un élèment en particulier, on lui affecte une nouvelle valeur :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3e5d91ec",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lst = [1,2,3,4,5]\n",
+    "lst[1] = 8\n",
+    "print (lst)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "744a1b5f",
+   "metadata": {},
+   "source": [
+    "Il est préférable de ne stocker que des données de même type dans une liste\n",
+    "\n",
+    "Une liste peut être passée comme paramètre d'une fonction"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0752a875",
+   "metadata": {},
+   "source": [
+    "--------"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c3334da3",
+   "metadata": {},
+   "source": [
+    "## Les tuples (ou p-uplets)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "950ac9c0",
+   "metadata": {},
+   "source": [
+    " À la différence des listes, les tuples ne sont ***pas mutables***. On ne peut donc plus les modifier une fois créés, leur taille est fixe.\n",
+    "\n",
+    "Mais ils peuvent néanmoins contenir des données de différents types.\n",
+    "\n",
+    "Pour initialiser un tuple, on utilise cette syntaxe :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c9650c65",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tuple = (1, 3)\n",
+    "print (tuple)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6696bdfa",
+   "metadata": {},
+   "source": [
+    "Ici, de la même manière que les listes, on pourra accéder à un élèment en particulier via son indice"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6bf823b5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tuple = (1, 3, 5, 7, 9)\n",
+    "tuple[-1]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "38639578",
+   "metadata": {},
+   "source": [
+    "De plus, on peut tout à fait utiliser l'itération pour construire ou parcourir une structure tuple.\n",
+    "\n",
+    "Enfin, il est courant, dans une fonction, de renvoyer plusieurs valeurs. Par exemple, via ce type de syntaxe :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fc1d8a8a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "return a, b"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "13f8b5ab",
+   "metadata": {},
+   "source": [
+    "En réalité, cette syntaxe signifie : return (a, b) : on a donc un tuple composé des variables a et b qui est renvoyé."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ad602ab2",
+   "metadata": {},
+   "source": [
+    "-----"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e758cc26",
+   "metadata": {},
+   "source": [
+    "### À retenir:"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b3e871a6",
+   "metadata": {},
+   "source": [
+    "***Pour les listes et tuples :***"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "735fd28c",
+   "metadata": {},
+   "source": [
+    "| Opération  | Résultat                                                     |\n",
+    "| ---------- | ------------------------------------------------------------ |\n",
+    "| x in t     | Renvoie True si un élément de t est égal à x                 |\n",
+    "| x not in t | Renvoie True si aucun élément de t n'est égal à x, False sinon |\n",
+    "| len(t)     | Renvoie le nombre d'éléments de t                            |\n",
+    "| t == t1    | Renvoie True si t et t1 sont de même type, ont la même longueur, et ont des éléments égaux 2 à 2 |"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "58ea35dc",
+   "metadata": {},
+   "source": [
+    "| Opération  | Résultat                                                     |\n",
+    "| ---------- | ------------------------------------------------------------ |\n",
+    "| t[i]       | Renvoie l'élément d'indice i de t                            |\n",
+    "| t[i:j]     | Renvoie une partie de t de l'indice i à j non inclus         |\n",
+    "| t.index(x) | Renvoie l'indice de la première apparition de x dans t       |\n",
+    "| t.count(x) | Renvoie le nombre d'apparitions de x dans t                  |\n",
+    "| s + t      | Renvoie une nouvelle séquence qui correspond à la concaténation de s et de t (seulement si s et t ont le même type |"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2e470d2f",
+   "metadata": {},
+   "source": [
+    "***Uniquement pour les listes :*** "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7844385e",
+   "metadata": {},
+   "source": [
+    "| Opération      | Résultat                                                     |\n",
+    "| -------------- | ------------------------------------------------------------ |\n",
+    "| l.append(x)    | Ajoute l'élément x à la fin de la liste l                    |\n",
+    "| l[i] = x       | Modifie la liste et affecte la valeur x à la case d'indice i |\n",
+    "| l.insert(i, x) | Insère l'élément x dans la liste l à la position de l'indice i |\n",
+    "| l.remove(x)    | Supprime de la liste le premier élément dont la valeur est égale à x |\n",
+    "| l.pop(i)       | Enlève de la liste l'élément à la position i et renvoie sa valeur |\n",
+    "\n"
+   ]
+  }
+ ],
+ "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.8.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

representation_construits/chapitre_1/README.ipynb

@@ -0,0 +1,682 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "8e7931fd",
+   "metadata": {},
+   "source": [
+    "# Représentation des données : tuples, listes et itérations"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "eb82a1d6",
+   "metadata": {},
+   "source": [
+    "> ***Contenue*** : Notions introduites : le type conteneur, avec les listes, les tuples, parcours de séquences. \n",
+    "\n",
+    "> ***Compétences*** : Comprendre la différence entre une liste python et un tuple. Maîtriser la création de conteneurs sur Python."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "351877cc",
+   "metadata": {},
+   "source": [
+    "## Le programme"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "72d95029",
+   "metadata": {},
+   "source": [
+    "------\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e0891811",
+   "metadata": {},
+   "source": [
+    "![bo_tuple](../assets/bo_tuple.png)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d2f3b985",
+   "metadata": {},
+   "source": [
+    "![bo_liste](../assets/bo_liste.png)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b9d904ad",
+   "metadata": {},
+   "source": [
+    "## Apport de connaissances"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ff539106",
+   "metadata": {},
+   "source": [
+    "----"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9c9c328a",
+   "metadata": {},
+   "source": [
+    "Les types *conteneurs* comme les tuples ou les listes permettent de stocker des objets, et proposent des méthodes d'accès, de modification et d'itération sur ces mêmes objets.\n",
+    "\n",
+    "Ici nous allons voir trois types de conteneurs en particulier : les tuples, les listes, et enfin les dictionnaires. En apprenant à créer et à manipuler ces  types d'objets, cela nous permettra de travailler sur un grand nombre de données de manière rapide et efficace."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "aa48414d",
+   "metadata": {},
+   "source": [
+    "------"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3895f0e2",
+   "metadata": {},
+   "source": [
+    "### Les listes"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c4141b1e",
+   "metadata": {},
+   "source": [
+    "Pour le moment, nous n'avons appris à travailler qu'avec un nombre limité de variables. Cependant, il peut arriver que vous deviez lire, stocker, traiter et enfin imprimer des dizaines, voire des centaines ou des milliers de valeurs de données. Comment stocker et accéder efficacement à ces données ? \n",
+    "\n",
+    "Par exemple, si l'on décide de de manipuler une demi-douzaine de variables, doit on les déclarer comme ceci : "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "487520fb",
+   "metadata": {},
+   "source": [
+    "var1 = int(input())\n",
+    "var2 = int(input())\n",
+    "var3 = int(input())\n",
+    "var4 = int(input())\n",
+    "var5 = int(input())\n",
+    "var6 = int(input())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4693983f",
+   "metadata": {},
+   "source": [
+    "Nous allons voir qu'avec une liste, nous allons pouvoir déclarer une variable à valeurs multiples."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3764753e",
+   "metadata": {},
+   "source": [
+    "---------"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "888b14c9",
+   "metadata": {},
+   "source": [
+    "### Créer une liste\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "34e6d597",
+   "metadata": {},
+   "source": [
+    "Créer une liste vide :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a0b2f16b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "nom_liste = []"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0010c492",
+   "metadata": {},
+   "source": [
+    " On peut les créer par ***extension*** (comprendre *liste déclarée littéralement*) comme ceci :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ea5c9f4b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "nom_liste = [3, 8, 5, 4]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0621a32d",
+   "metadata": {},
+   "source": [
+    "Mais aussi par ***compréhension*** (itération, que l'on verra plus loin)\n",
+    "\n",
+    "On peut tester ça dans la console python "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "21bf0b13",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lst = [2, 3, 5, 7 ]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4192f777",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "type (lst)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7c8925ab",
+   "metadata": {},
+   "source": [
+    "On peut afficher la liste de la même manière qu'une variable classique :  avec la commande *print* "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9b7f5057",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print (lst)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5e01b094",
+   "metadata": {},
+   "source": [
+    "--------"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "60990b42",
+   "metadata": {},
+   "source": [
+    "### Accéder aux élèments d'une liste"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f2572686",
+   "metadata": {},
+   "source": [
+    "Les élèments d'une liste peuvent être comparé à des élèments d'une séquence : chaque élèment a une position précise dans la liste, comme nous l'avons vu pour les chaînes de caractères (*str*)\n",
+    "\n",
+    "On appelle cette position *indice*, c'est cet indice qui nous permet d'accéder à un élèment en particulier.\n",
+    "\n",
+    "Le premier élèment d'une liste a pour indice **0**\n",
+    "\n",
+    "Tout comme avec les chaînes de caractères, un indice négatif permet d'accéder l'élèment en partant de la fin\n",
+    "\n",
+    "Pour connaître le nombre total d'élèments dans une liste, on utilise la fonction ***len***"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "903af397",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lst = [2,4,6,8]\n",
+    "len (lst)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "68933336",
+   "metadata": {},
+   "source": [
+    "On peut désigner une **tranche** en indiquant l'indice du premier élèment, ainsi que celui du dernier ***non inclus***"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d8368df4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lst [1:3]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1ff6aae5",
+   "metadata": {},
+   "source": [
+    "Attention : Un indice qui dépasse la valeur *longueur de la liste - 1* provoquera une erreur dans votre code"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3284e1b0",
+   "metadata": {},
+   "source": [
+    "---------"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e4e3c049",
+   "metadata": {},
+   "source": [
+    "### Parcours d'une liste"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3a0de921",
+   "metadata": {},
+   "source": [
+    "Comme indiqué plus haut, il est possible de créer et de parcourir une liste par une méthode dite *de compréhension* ou *itération*\n",
+    "\n",
+    "Celà signifie qu'on construit une liste à partir d'élèments itérables : que l'on peut répétèr. Par exemple :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "289a75cf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "liste = [x for x in range(5)]\n",
+    "print(liste)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1f8399fe",
+   "metadata": {},
+   "source": [
+    "Que vous affiche la console ?\n",
+    "\n",
+    "L'intérêt des listes par compréhension, c'est que l'on peut utiliser les structures conditionnelles, à l'aide de boucles...\n",
+    "\n",
+    "On peut également initialiser une liste à partir d'une autre liste "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a3360286",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "liste = [1, 2, 3, 4]\n",
+    "nouvelle_liste = [2 * x for x in liste]\n",
+    "print(nouvelle_liste)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d7262a39",
+   "metadata": {},
+   "source": [
+    "Une fois que la liste est crée, on peut la parcourir :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a9e9e9ec",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for elt in lst:\n",
+    "    print (elt, end='')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bded0a4f",
+   "metadata": {},
+   "source": [
+    "Ici, on va afficher chaque élèment de la liste lst\n",
+    "\n",
+    "On peut également utiliser une boucle en itérant l'indice i des élèments :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "26be31c2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for i in range (len(lst)):\n",
+    "    print(lst[i], end='')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "78dc79dd",
+   "metadata": {},
+   "source": [
+    "Ici, pour i compris entre 0 et longueur de lst, on va affichier l'élèment correspondant à l'indice valant i.\n",
+    "\n",
+    " À faire : \n",
+    "\n",
+    "- créer une liste par extension, puis par itération\n",
+    "- afficher les élèments d'une liste"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e4e5f08f",
+   "metadata": {},
+   "source": [
+    "-------\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "baa22c54",
+   "metadata": {},
+   "source": [
+    "### Propriétés d'une liste"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ab2684f4",
+   "metadata": {},
+   "source": [
+    "Une liste peut être modifiable : on parle d'un objet *mutable*\n",
+    "\n",
+    "- On peut donc supprimer un élèment d'une liste avec le mot clé *del*\t"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "afc4143f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lst = [1,2,3,4,5]\n",
+    "del lst[0]\n",
+    "print(lst)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "72921eae",
+   "metadata": {},
+   "source": [
+    "Il faut noter qu'en supprimant l'élèment situé à l'indice 0, j'ai donc fait changer tous les indices des élèments de la liste !\n",
+    "On peut également ajouter un élèment à la liste : "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3e6aeb54",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lst = [1,2,3,4,5]\n",
+    "lst.append(6)\n",
+    "print (lst)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c2ae9958",
+   "metadata": {},
+   "source": [
+    "L'élèment ajouté se positionne donc à la *fin* de la liste\n",
+    "\n",
+    "Pour modifier un élèment en particulier, on lui affecte une nouvelle valeur :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3e5d91ec",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lst = [1,2,3,4,5]\n",
+    "lst[1] = 8\n",
+    "print (lst)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "744a1b5f",
+   "metadata": {},
+   "source": [
+    "Il est préférable de ne stocker que des données de même type dans une liste\n",
+    "\n",
+    "Une liste peut être passée comme paramètre d'une fonction"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0752a875",
+   "metadata": {},
+   "source": [
+    "--------"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c3334da3",
+   "metadata": {},
+   "source": [
+    "## Les tuples (ou p-uplets)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "950ac9c0",
+   "metadata": {},
+   "source": [
+    " À la différence des listes, les tuples ne sont ***pas mutables***. On ne peut donc plus les modifier une fois créés, leur taille est fixe.\n",
+    "\n",
+    "Mais ils peuvent néanmoins contenir des données de différents types.\n",
+    "\n",
+    "Pour initialiser un tuple, on utilise cette syntaxe :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c9650c65",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tuple = (1, 3)\n",
+    "print (tuple)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6696bdfa",
+   "metadata": {},
+   "source": [
+    "Ici, de la même manière que les listes, on pourra accéder à un élèment en particulier via son indice"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6bf823b5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tuple = (1, 3, 5, 7, 9)\n",
+    "tuple[-1]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "38639578",
+   "metadata": {},
+   "source": [
+    "De plus, on peut tout à fait utiliser l'itération pour construire ou parcourir une structure tuple.\n",
+    "\n",
+    "Enfin, il est courant, dans une fonction, de renvoyer plusieurs valeurs. Par exemple, via ce type de syntaxe :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fc1d8a8a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "return a, b"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "13f8b5ab",
+   "metadata": {},
+   "source": [
+    "En réalité, cette syntaxe signifie : return (a, b) : on a donc un tuple composé des variables a et b qui est renvoyé."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ad602ab2",
+   "metadata": {},
+   "source": [
+    "-----"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e758cc26",
+   "metadata": {},
+   "source": [
+    "### À retenir:"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b3e871a6",
+   "metadata": {},
+   "source": [
+    "***Pour les listes et tuples :***"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "735fd28c",
+   "metadata": {},
+   "source": [
+    "| Opération  | Résultat                                                     |\n",
+    "| ---------- | ------------------------------------------------------------ |\n",
+    "| x in t     | Renvoie True si un élément de t est égal à x                 |\n",
+    "| x not in t | Renvoie True si aucun élément de t n'est égal à x, False sinon |\n",
+    "| len(t)     | Renvoie le nombre d'éléments de t                            |\n",
+    "| t == t1    | Renvoie True si t et t1 sont de même type, ont la même longueur, et ont des éléments égaux 2 à 2 |"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "58ea35dc",
+   "metadata": {},
+   "source": [
+    "| Opération  | Résultat                                                     |\n",
+    "| ---------- | ------------------------------------------------------------ |\n",
+    "| t[i]       | Renvoie l'élément d'indice i de t                            |\n",
+    "| t[i:j]     | Renvoie une partie de t de l'indice i à j non inclus         |\n",
+    "| t.index(x) | Renvoie l'indice de la première apparition de x dans t       |\n",
+    "| t.count(x) | Renvoie le nombre d'apparitions de x dans t                  |\n",
+    "| s + t      | Renvoie une nouvelle séquence qui correspond à la concaténation de s et de t (seulement si s et t ont le même type |"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2e470d2f",
+   "metadata": {},
+   "source": [
+    "***Uniquement pour les listes :*** "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7844385e",
+   "metadata": {},
+   "source": [
+    "| Opération      | Résultat                                                     |\n",
+    "| -------------- | ------------------------------------------------------------ |\n",
+    "| l.append(x)    | Ajoute l'élément x à la fin de la liste l                    |\n",
+    "| l[i] = x       | Modifie la liste et affecte la valeur x à la case d'indice i |\n",
+    "| l.insert(i, x) | Insère l'élément x dans la liste l à la position de l'indice i |\n",
+    "| l.remove(x)    | Supprime de la liste le premier élément dont la valeur est égale à x |\n",
+    "| l.pop(i)       | Enlève de la liste l'élément à la position i et renvoie sa valeur |\n",
+    "\n"
+   ]
+  }
+ ],
+ "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.8.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

representation_construits/chapitre_1/README.md

@@ -0,0 +1,261 @@
+## Représentation des données : tuples, listes et itérations
+
+-------------
+
+> ***Contenue*** : Notions introduites : le type conteneur, avec les listes, les tuples, parcours de séquences. 
+> ***Compétences*** : Comprendre la différence entre une liste python et un tuple. Maîtriser la création de conteneurs sur Python.
+
+## Le programme
+
+-----------
+
+![bo_tuple](../assets/bo_tuple.png)
+
+![bo_liste](../assets/bo_liste.png)
+
+## Apport de connaissances
+
+----------
+
+Les types *conteneurs* comme les tuples ou les listes permettent de stocker des objets, et proposent des méthodes d'accès, de modification et d'itération sur ces mêmes objets.
+
+Ici nous allons voir trois types de conteneurs en particulier : les tuples, les listes, et enfin les dictionnaires. En apprenant à créer et à manipuler ces  types d'objets, cela nous permettra de travailler sur un grand nombre de données de manière rapide et efficace.
+
+--------
+
+### Les listes
+
+Pour le moment, nous n'avons appris à travailler qu'avec un nombre limité de variables. Cependant, il peut arriver que vous deviez lire, stocker, traiter et enfin imprimer des dizaines, voire des centaines ou des milliers de valeurs de données. Comment stocker et accéder efficacement à ces données ? 
+
+Par exemple, si l'on décide de de manipuler une demi-douzaine de variables, doit on les déclarer comme ceci : 
+
+```python
+var1 = int(input())
+var2 = int(input())
+var3 = int(input())
+var4 = int(input())
+var5 = int(input())
+var6 = int(input())
+```
+
+Nous allons voir qu'avec une liste, nous allons pouvoir déclarer une variable à valeurs multiples.
+
+-----------------
+
+### Créer une liste
+
+Liste vide :
+
+```python
+nom_liste = [ ] 
+```
+
+ On peut les créer par ***extension*** (comprendre *liste déclarée littéralement*) comme ceci :
+
+```python
+nom_liste = [3, 8, 5, 4]
+```
+
+Mais aussi par ***compréhension*** (itération, que l'on verra plus loin)
+
+On peut tester ça dans la console python 
+
+```python
+lst = [2, 3, 5, 7 ]
+type (lst)
+```
+
+Que retournent ces lignes python ?
+
+On peut afficher la liste de la même manière qu'une variable classique :  avec la commande *print* 
+
+```python
+print(lst)
+```
+
+--------------
+
+### Accéder aux élèments d'une liste
+
+Les élèments d'une liste peuvent être comparé à des élèments d'une séquence : chaque élèment a une position précise dans la liste, comme nous l'avons vu pour les chaînes de caractères (*str*)
+
+On appelle cette position *indice*, c'est cet indice qui nous permet d'accéder à un élèment en particulier.
+
+Le premier élèment d'une liste a pour indice **0**
+
+Tout comme avec les chaînes de caractères, un indice négatif permet d'accéder l'élèment en partant de la fin
+
+Pour connaître le nombre total d'élèments dans une liste, on utilise la fonction ***len***
+
+```python
+lst = [2,4,6,8]
+len (lst)
+```
+
+On peut désigner une **tranche** en indiquant l'indice du premier élèment, ainsi que celui du dernier ***non inclus***
+
+```py
+lst [1:3]
+```
+
+Attention : Un indice qui dépasse la valeur *longueur de la liste - 1* provoquera une erreur dans votre code
+
+----------
+
+### Parcours d'une liste
+
+Comme indiqué plus haut, il est possible de créer et de parcourir une liste par une méthode dite *de compréhension* ou *itération*
+
+Celà signifie qu'on construit une liste à partir d'élèments itérables : que l'on peut répétèr. Par exemple :
+
+```pyth
+liste = [x for x in range(5)]
+print(liste)
+```
+
+Que vous affiche la console ?
+
+L'intérêt des listes par compréhension, c'est que l'on peut utiliser les structures conditionnelles, à l'aide de boucles...
+
+On peut également initialiser une liste à partir d'une autre liste 
+
+```pytho
+liste = [1, 2, 3, 4]
+nouvelle_liste = [2 * x for x in liste]
+print(nouvelle_liste)
+```
+
+Une fois que la liste est crée, on peut la parcourir :
+
+```pyth
+for elt in lst:
+	print (elt, end='')
+```
+
+Ici, on va afficher chaque élèment de la liste lst
+
+On peut également utiliser une boucle en itérant l'indice i des élèments :
+
+```python
+for i in range (len(lst)):
+	print(lst[i], end='')
+```
+
+Ici, pour i compris entre 0 et longueur de lst, on va affichier l'élèment correspondant à l'indice valant i.
+
+ À faire : 
+
+- créer une liste par extension, puis par itération
+- afficher les élèments d'une liste
+
+-----------
+
+### Propriétés d'une liste
+
+Une liste peut être modifiable : on parle d'un objet *mutable*
+
+- On peut donc supprimer un élèment d'une liste avec le mot clé *del*	
+
+  ```pyth
+  lst = [1,2,3,4,5]
+  del lst[0]
+  print(lst)
+  [2,3,4,5]
+  ```
+
+  Il faut noter qu'en supprimant l'élèment situé à l'indice 0, j'ai donc fait changer tous les indices des élèments de la liste !
+
+  
+
+- On peut également ajouter un élèment à la liste : 
+
+  ```py
+  lst = [1,2,3,4,5]
+  lst.append(6)
+  print (lst)
+  [1,2,3,4,5,6]
+  ```
+
+  L'élèment ajouté se positionne donc à la *fin* de la liste
+
+  
+
+- Pour modifier un élèment en particulier, on lui affecte une nouvelle valeur
+
+```pyth
+lst = [1,2,3,4,5]
+lst[1] = 8
+print (lst)
+[1,8,3,4,5,6]
+```
+
+Il est préférable de ne stocker que des données de même type dans une liste
+
+Une liste peut être passée comme paramètre d'une fonction
+
+--------
+
+
+
+## Les tuples (ou p-uplets)
+
+ À la différence des listes, les tuples ne sont ***pas mutables***. On ne peut donc plus les modifier une fois créés, leur taille est fixe.
+
+Mais ils peuvent néanmoins contenir des données de différents types.
+
+Pour initialiser un tuple, on utilise cette syntaxe :
+
+```pyth
+tuple = (1, 3)
+print (tuple)
+(1, 3)
+```
+
+Ici, de la même manière que les listes, on pourra accéder à un élèment en particulier via son indice
+
+```python
+tuple = (1, 3, 5, 7, 9)
+tuple[-1]
+9
+```
+
+De plus, on peut tout à fait utiliser l'itération pour construire ou parcourir une structure tuple.
+
+Enfin, il est courant, dans une fonction, de renvoyer plusieurs valeurs. Par exemple, via ce type de syntaxe :
+
+```pyth
+return a, b
+```
+
+En réalité, cette syntaxe signifie : return (a, b) : on a donc un tuple composé des variables a et b qui est renvoyé.
+
+----------
+
+### À retenir:
+
+***Pour les listes et tuples :***
+
+| Opération  | Résultat                                                     |
+| ---------- | ------------------------------------------------------------ |
+| x in t     | Renvoie True si un élément de t est égal à x                 |
+| x not in t | Renvoie True si aucun élément de t n'est égal à x, False sinon |
+| len(t)     | Renvoie le nombre d'éléments de t                            |
+| t == t1    | Renvoie True si t et t1 sont de même type, ont la même longueur, et ont des éléments égaux 2 à 2 |
+
+| Opération  | Résultat                                                     |
+| ---------- | ------------------------------------------------------------ |
+| t[i]       | Renvoie l'élément d'indice i de t                            |
+| t[i:j]     | Renvoie une partie de t de l'indice i à j non inclus         |
+| t.index(x) | Renvoie l'indice de la première apparition de x dans t       |
+| t.count(x) | Renvoie le nombre d'apparitions de x dans t                  |
+| s + t      | Renvoie une nouvelle séquence qui correspond à la concaténation de s et de t (seulement si s et t ont le même type |
+
+***Uniquement pour les listes :*** 
+
+| Opération      | Résultat                                                     |
+| -------------- | ------------------------------------------------------------ |
+| l.append(x)    | Ajoute l'élément x à la fin de la liste l                    |
+| l[i] = x       | Modifie la liste et affecte la valeur x à la case d'indice i |
+| l.insert(i, x) | Insère l'élément x dans la liste l à la position de l'indice i |
+| l.remove(x)    | Supprime de la liste le premier élément dont la valeur est égale à x |
+| l.pop(i)       | Enlève de la liste l'élément à la position i et renvoie sa valeur |

representation_construits/chapitre_1/TABLEAUX.md

@@ -0,0 +1,40 @@
+# Tableaux Python
+
+
+
+En python, un tableau est une liste de listes
+
+```python
+tableau = [[2,4,3,7],[1,3,6,7],[5,7,0,2],[1,8,9,3]]
+```
+
+On peut représenter le tableau suivant de cette manière :
+
+| 2    | 4    | 3    | 7    |
+| ---- | ---- | ---- | ---- |
+| 1    | 3    | 6    | 7    |
+| 5    | 7    | 0    | 2    |
+| 1    | 8    | 9    | 3    |
+
+Pour accéder à un élèment d'un tableau, puisqu'il s'agit d'une liste de liste, on utilisera deux *indices* :
+
+- L'indice de la liste contenant l'élèment
+- L'indice de l'élèment dans la liste
+
+On accède donc à l'élèment situé en ligne n°i et colonne n° j par 
+
+```pyth
+tab [i][j]
+```
+
+Par exemple si l'on reprend le tableau ci dessus :
+
+```python
+tableau [2][3]
+2
+```
+
+Soit le tableau t = [["a","b"],["c","d"],["e","f"],["g","h"]]
+
+Comment accéder à l'élément "e" ?
+

representation_construits/chapitre_1/projet/README.md

@@ -0,0 +1,139 @@
+# Projet - Désamorceur de bombes
+
+![bombe](./assets/bomb.png)
+
+## 1. Contexte
+
+Ce jeu est une adaptation du jeu ___[Keep Talking and nobody explodes](https://keeptalkinggame.com/)___, de l'éditeur steelcrategames.com où l'objectif est de désamorcer une bombe en coupant le bon fil.
+
+Cette adaptation a pour but de mettre en oeuvre les connaissances acquises en python, notamment les types construits, les boucles, les structures conditionnelles et les fonctions.
+
+## 2. Description
+
+### 2.1. Règles
+
+- Une bombe peut contenir entre 3 et 6 fils.
+- Seul un fil a besoin d'être coupé pour désarmer la bombe.
+- Les fils sont ordonnés de haut en bas.
+- A l'armement de la bombe, l'utilisateur est invité à indiquer l'indice du fil qu'il souhaite couper.
+
+Les règles complètes de désamorçage sont décrites en annexe. Pour __3 fils__, les règles sont les suivantes
+
+```txt
+S'il n'y a pas de fil rouge, couper le deuxième fil.
+Sinon, si le dernier fil est blanc, couper le dernier fil.
+Sinon, s'il y a plus d'un fil bleu, couper le dernier fil bleu.
+Sinon, couper le dernier fil.
+```
+
+### 2.2. Exemples
+
+| Exemple | Explication |
+| :--: | :-- |
+| ![](./assets/exemple_1.png) | Le fil à couper est celui à l'indice 1, soit le deuxième fil.<br />La règle qui le justifie : il n'y a pas de fil rouge. |
+| ![](./assets/exemple_2.png) | Le fil à couper est celui à l'indice 2, soit le dernier fil.<br />La règle qui le justifie : Toutes les règles ne sont pas satisfaites, c'est le dernier sinon qui s'applique. |
+
+## 3. Consignes
+
+Vous devez créer un module `desamorceur` qui va permettre de :
+
+- créer une combinaison aléatoire de couleur pour $`n`$ fils,
+- créer une bombe de $`n`$ fils,
+- afficher une bombe,
+- créer un numéro de série sur 8 chiffres,
+- déterminer si le fil choisi désarme la bombe ou non,
+- ... ainsi que d'autres fonctions nécessaires à l'implantation du jeu (Cf. Partie "Petit manuel du désamorceur de bombes").
+
+L'algorithme principal est le suivant :
+```python
+bombe = creer_bombe(creer_combinaison(combinaison))
+numero_serie = creer_numero_serie()
+
+print(f"n°{numero_serie}")
+
+afficher_bombe(bombe)
+
+indice = input('Indice du fils à couper : ')
+
+if est_bon_fil_a_couper(bombe, int(indice), numero_serie):
+	print('Sauvé !!!')
+else:
+	print('Perdu, la bombe a explosé')
+```
+***N.B : Vous devez, pour chaque fonction y adjoindre les docstrings et doctests nécessaires***
+
+Le module sera exécutable de la manière suivante :
+
+> python3 desamorceur.py 4
+
+où le 2ème paramètres correspond au nombre de fils de la bombe
+
+## 4. Matériel fourni
+
+Le module `paint` dispose de :
+
+- 5 variables : `ROUGE, VERT, JAUNE, BLEU, BLANC`, qui permettent de matérialiser les couleurs des fils,
+- d'une méthode `dessiner` qui permet d'afficher une matrice passée en paramètre.
+
+<figure>
+  <center><img src='./assets/utilisation_paint.png'/></center>
+  <figcaption style='text-align:center;'>Fig 2. Exemple d'utilisation du module paint</figcaption>
+</figure>
+
+## 5. Rendu
+
+- un script `desamorceur.py`,
+- un fichier `README.md` qui présente vos choix de structures de données, les autres fonctions implantées..., ainsi qu'un extrait de codes ou le decriptif d'un problème rencontré et la solution mise en place.
+
+## 6. Annexe - Petit manuel du désamorceur de bombes
+
+Voici les règles pour désamorcer la bombe :
+
+__3 fils__ :
+
+S'il n'y a pas de fil rouge, couper le deuxième fil.
+
+Sinon, si le dernier fil est blanc, couper le dernier fil.
+
+Sinon, s'il y a plus d'un fil bleu, couper le dernier fil bleu.
+
+Sinon, couper le dernier fil.
+
+__4 fils__ :
+
+S'il y a plus d'un fil rouge et si le dernier chiffre du numéro de série est impair, couper le dernier fil rouge.
+
+Sinon, si le dernier fil est jaune et s'il n'y a pas de fil rouge, couper le premier fil.
+
+Sinon, s'il y a exactement un fil bleu, couper le premier fil.
+
+Sinon, s'il y a plus d'un fil jaune, couper le dernier fil.
+
+Sinon, couper le deuxième fil.
+
+__5 fils__ :
+
+Si le dernier fil est vert et si le dernier chiffre du numéro de série est impair, couper le quatrième fil.
+
+Sinon, s'il y a exactement un fil rouge et plus d'un fil jaune, couper le premier fil.
+
+Sinon, s'il n'y a pas de fil vert, couper le deuxième fil.
+
+Sinon, couper le premier fil.
+
+__6 fils__ :
+
+S'il n'y a pas de fil jaune et si le dernier chiffre du numéro de série est impair, couper le troisième fil.
+
+Sinon, s'il y a exactement un fil jaune et plus d'un fil blanc, couper le quatrième fil.
+
+Sinon, s'il n'y a pas de fil rouge, couper le dernier fil.
+
+Sinon, couper le quatrième fil.
+
+## 7. Pour aller plus loin
+
+Dans le cas où les éléments du projet sont finalisés, vous pouvez le compléter avec les éléments suivants :
+- En cas d'explosion de la bombe, afficher à l'utilisateur l'indice du fil qu'il fallait couper pour désarmer la bombe,
+- Mettre en place un numéro de série alphanumérique, qui comporte au moins 1 chiffre qui n'est pas forcément en dernière position,
+- Doter le projet d'une interface graphique, via le module `pygame`.

representation_construits/chapitre_1/projet/correction.py

@@ -0,0 +1,161 @@
+#! /usr/bin/env python3
+# -*- coding : utf-8 -*-
+# Author : Philippe BODDAERT
+# Date : 01/08/2021
+# License : CC-BY-NC-SA
+
+import random, sys
+from paint import dessiner, ROUGE, JAUNE, BLANC, BLEU, VERT
+
+def creer_fils(couleur, longueur = 10):
+    '''
+    Créé un fils d'une longueur donnée
+    :param couleur: (int) la couleur du fils
+    :param longueur: (int) la longueur du fils
+    :return: (list) Un fils sous la forme d'un tableau
+    '''
+    return [couleur] * longueur
+
+def creer_bombe(couleurs):
+    '''
+    Créé une bombe de fils
+    :param couleurs: (list) les couleurs des fils
+    :return: (list) Un tableau de fils
+    '''
+    bombe = []
+    for c in couleurs:
+        bombe.append(creer_fils(c, 20))
+    return bombe
+
+def creer_combinaison(longueur):
+    '''
+    Créé une combinaison de couleurs de fils
+    :param longueur: (int) le nombre de fils
+    :return: (list) Un tableau de couleurs
+    '''
+    return [ random.choice([ROUGE, VERT, JAUNE, BLEU, BLANC]) for _ in range(longueur)]
+
+def creer_numero_serie(longueur = 8):
+    '''
+    Créé un numéro de série d'une longueur donnée
+    :param longueur: (int) longueur du numéro
+    :return: (str) un numéro de longueurdonnée
+    '''
+    return str(random.randrange(0, 10**longueur)).zfill(8)
+
+def afficher_bombe(bombe):
+    '''
+    Affiche une bombe de fils
+    :param bombe: (list) une bombe de fils
+    '''
+    dessiner(bombe)
+
+def couleur_fils(fils):
+    '''
+    Obtient la couleur d'un fils
+    :param fils: (list) Un fil
+    :return: (int) la couleur du fil
+    '''
+    return fils[0]
+
+def compter_fils(bombe, couleur):
+    '''
+    Compte le nombre de fils de la couleur donnée
+    :param bombe: (list) un tableau de fils
+    :pram couleur: (int) une couleur
+    :return: (int) Le nombre de fils de la couleur donnée
+    '''
+    nb = 0
+    for fils in bombe:
+        if couleur_fils(fils) == couleur:
+            nb += 1
+    return nb
+
+def indice_dernier_fils(bombe, couleur):
+    '''
+    Détermine le dernier indice du fils de la couleur donnée
+    :param bombe: (list) une bombe de fils
+    :param couleur: (int) une couleur
+    :return: (int) l'indice du fils, -1 sinon
+    '''
+    i = len(bombe) - 1
+    while i >= 0 and couleur_fils(bombe[i]) != couleur:
+        i -= 1
+    return i
+
+def est_dernier_chiffre_impair(numero):
+    '''
+    Détermine si le dernier chiffre du numéro de série est impair
+    :param numero: (str) un numéro de série
+    :return: (bool) True si le dernier chiffre est impair, False sinon
+    '''
+    return int(numero) % 2 == 1
+
+def est_bon_fil_a_couper(bombe, indice, numero_serie=None):
+    '''
+    Détermine si le fil  à l'indice donné est celui à couper
+    :param bombe: (list) une bombe de fils
+    :param indice: (int) l'indice du fils à couper
+    :return: (bool) True si le fils est le bon, False sinon
+    '''
+    n = len(bombe)
+    if n == 3:
+        if compter_fils(bombe, ROUGE) == 0:
+            return indice == 1
+        elif couleur_fils(bombe[n - 1]) == BLANC:
+            return indice == n - 1
+        elif compter_fils(bombe, BLEU) > 1:
+            return indice == indice_dernier_fils(bombe, BLEU)
+        else:
+            return indice == n - 1
+    elif n == 4:
+        if compter_fils(bombe, ROUGE) > 1 and est_dernier_chiffre_impair(numero_serie):
+            return indice == indice_dernier_fils(bombe, ROUGE)
+        elif couleur_fils(bombe[n - 1]) == JAUNE and compter_fils(bombe, ROUGE) == 0:
+            return indice == 0
+        elif compter_fils(bombe, BLEU) == 1:
+            return indice == 0
+        elif compter_fils(bombe, JAUNE) > 1:
+            return indice == n - 1
+        else:
+            return indice == 1
+    elif n == 5:
+        if couleur_fils(bombe[n - 1]) == VERT and est_dernier_chiffre_impair(numero_serie):
+            return indice == 3
+        elif compter_fils(bombe, ROUGE) == 1 and compter_fils(bombe, JAUNE) > 1:
+            return indice == 0
+        elif compter_fils(bombe, VERT) == 0:
+            return indice == 1
+        else:
+            return indice == 0
+    else:
+        if compter_fils(bombe, JAUNE) == 0 and est_dernier_chiffre_impair(numero_serie):
+            return indice == 2
+        elif compter_fils(bombe, JAUNE) == 1 and compter_fils(bombe, BLANC) > 1:
+            return indice == 3
+        elif compter_fils(bombe, ROUGE) == 0:
+            return indice == n - 1
+        else:
+            return indice == 3
+
+if __name__ == '__main__':
+    combinaison = 3
+    numero_serie = None
+    if len(sys.argv) > 1:
+        combinaison = int(sys.argv[1])
+        if combinaison > 3:
+            numero_serie = creer_numero_serie()
+
+    bombe = creer_bombe(creer_combinaison(combinaison))
+
+    if numero_serie is not None:
+        print(f"n°{numero_serie}")
+
+    afficher_bombe(bombe)
+
+    indice = input('Indice du fils à couper : ')
+
+    if est_bon_fil_a_couper(bombe, int(indice), numero_serie):
+        print('Sauvé !!!')
+    else:
+        print('Perdu, la bombe a explosé')

representation_construits/chapitre_1/projet/paint.py

@@ -0,0 +1,44 @@
+#! /usr/bin/env python3
+# -*- coding : utf-8 -*-
+# Author : Philippe BODDAERT
+# Date : 28/12/2020
+# License : CC-BY-NC-SA
+''' Affichage en couleur '''
+
+NOIR = 0
+ROUGE = 1
+VERT = 2
+JAUNE = 3
+BLEU = 4
+MAGENTA = 5
+CYAN = 6
+BLANC = 7
+
+def case_couleur(back = 9):
+    '''
+    Renvoi le texte d'un espace dont la couleur de fond est celle donnée
+    :param back: (int) le code couleur du fond du texte
+    '''
+    return couleur(' ', back)
+
+def couleur(texte, back = 9, fore = 9):
+    '''
+    Renvoi le texte dans la couleur donnée
+    :param fore: (int) le code couleur du texte
+    :param back: (int) le code couleur de fond du texte
+    :param texte: (str) texte à mettre en couleur
+    :return: (str) le texte mis en couleur pour affichage
+    '''
+    return f'\033[3{fore}m\033[4{back}m{texte}\033[39m\033[49m'
+
+def dessiner(matrice):
+    '''
+    Affiche le contenu de la matrice sous la forme de cases colorées
+    :param matrice: (list) un tableau de tableaux
+    :return: None
+    :CU: les valeurs de la matrice doivent être comprises entre 0 et 7 inclus
+    '''
+    for ligne in matrice:
+        for colonne in ligne:
+            print(case_couleur(colonne), sep = '', end = '')
+        print('')

representation_construits/chapitre_1/td/TD.ipynb

@@ -0,0 +1,572 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# TD : Les Tableaux\n",
+    "\n",
+    "Ce TD va nous permettre de manipuler les tableaux en Python."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1. Rappel\n",
+    "\n",
+    "Pour créer un tableau en python, la syntaxe est la suivante :\n",
+    "\n",
+    "```python\n",
+    ">>> tableau = []\n",
+    "```\n",
+    "\n",
+    "Pour ajouter un élément à un tableau, on utilise la méthode `append` :\n",
+    "\n",
+    "```python\n",
+    ">>> tableau.append('NSI')\n",
+    ">>> tableau.append('ANGLAIS')\n",
+    ">>> tableau\n",
+    "['NSI', 'ANGLAIS']\n",
+    "```\n",
+    "\n",
+    "Pour accéder à un élément, on utilise son **indice** :\n",
+    "\n",
+    "```python\n",
+    ">>> tableau[0]\n",
+    "'NSI'\n",
+    ">>> tableau[1]\n",
+    "'ANGLAIS'\n",
+    "```\n",
+    "\n",
+    "Il est également possible de créer un tableau avec un ensemble d'éléments :\n",
+    "\n",
+    "```python\n",
+    ">>> tableau = ['NSI', 'ANGLAIS', 'PHYSIQUE']\n",
+    ">>> tableau\n",
+    "['NSI', 'ANGLAIS', 'PHYSIQUE']\n",
+    "```\n",
+    "\n",
+    "Il est possible d'obtenir la taille du tableau, i.e le nombre d'éléments grâce à la méthode `len` :\n",
+    "\n",
+    "```python\n",
+    ">>> len(tableau)\n",
+    "3\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. Exercices"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Exercice 1 : Création de tableaux\n",
+    "\n",
+    "1. Créer un tableau contenant l'ensemble des noms des personnes dans la salle de TP\n",
+    "2. Créer un tableau contenant l'ensemble des entiers pairs entre 0 et 20 inclus,\n",
+    "3. Afficher uniquement les entiers du tableau, construit à la question 2, qui sont multiples de 4.\n",
+    "4. Créer une fonction `aleatoire` qui renvoie un tableau de valeurs aléatoires. Elle prend 3 entiers en paramètre :\n",
+    "    - $n$ : le nombre d'éléments du tableau\n",
+    "    - $min$ : la valeur minimale possible\n",
+    "    - $max$ : la valeur maximale possible"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 3"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 4"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Exercice 2 : Parcours et Recherche\n",
+    "\n",
+    "```python\n",
+    ">>> groupe_1 = ['Alan', 'Brice', 'Chloé', 'Damien', 'Eléonore', 'Farid']\n",
+    ">>> groupe_2 = ['Damien', 'Killian', 'Margot', 'Tom', 'Hugo', 'Killian']\n",
+    "```\n",
+    "\n",
+    "1. Écrire une fonction `indice` qui prend en paramètre un tableau de noms et un nom et permet d'obtenir l'indice du nom dans le tableau.\n",
+    "2. Écrire une fonction `est_present` qui prend en paramètre un tableau et un nom et renvoie True si le nom est présent dans le tableau, False sinon.\n",
+    "3. Écrire une fonction `indices` qui prend en paramètre un tableau de noms et un nom et permet d'obtenir l'ensemble des indices du nom dans le tableau.\n",
+    "4. Écrire une fonction `compte` qui prend en paramètre un tableau de noms et un nom et permet d'obtenir le nombre d'occurrences du nom dans le tableau."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 3"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 4"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Exercice 3 : Agrégation\n",
+    "\n",
+    "```python\n",
+    ">>> notes = [14.5, 13, 7, 10.25, 16, 12.5, 9.5]\n",
+    "```\n",
+    "\n",
+    "1. Écrire une fonction `somme` qui prend en paramètre un tableau de flottants et renvoie la somme des valeurs du tableau.\n",
+    "2. Écrire une fonction `moyenne` qui prend en paramètre un tableau de flottants et renvoie la valeur moyenne du tableau.\n",
+    "3. Écrire une fonction `maximum` qui prend en paramètre un tableau de flottants et renvoie la valeur maximale du tableau.  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 3"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Exercice 4 : Manipulations sur les tableaux\n",
+    "\n",
+    "Pour tester les fonctions de manipulations, nous utiliserons le Code Konami<sup>[wikipédia](https://fr.wikipedia.org/wiki/Code_Konami)</sup>\n",
+    "\n",
+    "```python\n",
+    ">>> code = [\"↑\", \"↑\", \"↓\",\"↓\", \"←\", \"→\", \"←\", \"→\", \"B\", \"A\"]\n",
+    "```\n",
+    "\n",
+    "1. Écrire une méthode `inverser` qui prend en paramètre un tableau et a pour effet de bord d'inverser l'ensemble des valeurs du tableau.\n",
+    "2. Écrire une fonction `copie` qui prend en paramètre un tableau et renvoie une copie du tableau.\n",
+    "3. Écrire une méthode `dedoublonner` qui prend en paramètre un tableau et a pour effet de bord de supprimer les doublons d'une même valeur. \n",
+    "4. Écrire une fonction `tranche` qui prend en paramètre un tableau et deux entiers $min$ et $max$, et renvoie le sous-tableau entre $min$ et $max$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 3"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 4"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Exercice 5 : Matrice\n",
+    "\n",
+    "1. Écrire une fonction `ligne` qui prend en paramètre une matrice et un indice de ligne en entrées et renvoie un tableau avec l'ensemble des valeurs de la ligne.\n",
+    "2. Écrire une fonction `colonne` qui prend en paramètre une matrice et un indice de colonne en entrées et renvoie un tableau avec l'ensemble des valeurs de la colonne.\n",
+    "3. Écrire une fonction `diagonale_nord_ouest` qui prend en paramètre une matrice et renvoie un tableau avec l'ensemble des valeurs de la diagonale. La première valeur est celle à l'indice \\[0]\\[0] et la dernière celle correspondant à l'indice \\[len(matrice) - 1]\\[len(matrice) - 1].\n",
+    "4. Écrire une fonction `diagonale_nord_est` qui prend en paramètre une matrice et renvoie un tableau avec l'ensemble des valeurs de la diagonale. La première valeur est celle à l'indice \\[0]\\[len(matrice) - 1] et la dernière celle correspondant à l'indice \\[len(matrice) - 1]\\[0]."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 3"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 4"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Application - Carré magique\n",
+    "\n",
+    "<table style=\"margin : 0 auto 0 auto; width:100px;text-align:center;\">\n",
+    "<caption style=\"caption-side:bottom;\">Fig 1. - Carré d'ordre 4</caption>\n",
+    "<tr style=\"border:none;\"><td>16</td><td>3</td><td>2</td><td>13</td></tr>\n",
+    "<tr style=\"border:none;\"><td>5</td><td>10</td><td>11</td><td>8</td></tr>\n",
+    "<tr style=\"border:none;\"><td>9</td><td>6</td><td>7</td><td>12</td></tr>\n",
+    "<tr style=\"border:none;\"><td>4</td><td>15</td><td>14</td><td>1</td></tr>\n",
+    "</table>\n",
+    "\n",
+    "\n",
+    "En mathématiques, un ***carré magique*** d’ordre $n$ est composé de $n^2$ entiers strictement positifs, écrits sous la forme d’un tableau carré. Ces nombres sont disposés de sorte que leurs sommes sur chaque rangée, sur chaque colonne et sur chaque diagonale principale soient égales. On nomme alors ***constante magique*** la valeur de ces sommes.\n",
+    "\n",
+    "<table style=\"margin : 0 auto 0 auto; width:100px;text-align:center;\">\n",
+    "  <caption style=\"caption-side:bottom;\">Fig 1.1 - Carré magique avec sa constante égale à 34</caption>\n",
+    "<tr style=\"border:none;\"><th style=\"border : none;\"></th><td>16</td><td>3</td><td>2</td><td>13</td><th style=\"border : none;padding-left:.5em;\">&rightarrow;34</th></tr>\n",
+    "<tr style=\"border:none;\"><th style=\"border : none;\"></th><td>5</td><td>10</td><td>11</td><td>8</td><th style=\"border : none;padding-left:.5em;\">&rightarrow;34</th></tr>\n",
+    "<tr style=\"border:none;\"><th style=\"border : none;\"></th><td>9</td><td>6</td><td>7</td><td>12</td><th style=\"border : none;padding-left:.5em;\">&rightarrow;34</th></tr>\n",
+    "<tr style=\"border:none;\"><th style=\"border : none;\"></th><td>4</td><td>15</td><td>14</td><td>1</td><th style=\"border : none;padding-left:.5em;\">&rightarrow;34</th></tr>\n",
+    "<tr style=\"border:none;\"><th style=\"border : none;\">&swarr; 34</th><th style=\"border:none;\">&downarrow; 34</th><th style=\"border:none;\">&downarrow; 34</th><th style=\"border:none;\">&downarrow; 34</th><th style=\"border:none;\">&downarrow; 34</th><th style=\"border:none;\">&searr; 34</th></tr>\n",
+    "</table>\n",
+    "\n",
+    "\n",
+    "> Écrire un prédicat `est_magique` qui prend une matrice d'entiers en paramètre et indique si le carré est magique ou non."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Carré magique de lettres\n",
+    "\n",
+    "Un ***carré magique de lettres***, également appelé « ***mots carrés*** », est une forme de mots croisés disposé en carré, ne comportant pas de case noire et constitué de mots valides dans une langue définie. Ils peuvent, par définition, être lus horizontalement et verticalement et présentent dans ces deux sens les mêmes mots.\n",
+    "\n",
+    "<table style=\"margin : 0 auto 0 auto; width : 100px;text-align:center;\">\n",
+    "  <caption style=\"caption-side:bottom;\">Fig.2.1 - Carré magique de lettres d'ordre 3</caption>\n",
+    "<tr><td>T</td><td>E</td><td>L</td></tr>\n",
+    "<tr><td>E</td><td>T</td><td>E</td></tr>\n",
+    "<tr><td>L</td><td>E</td><td>S</td></tr>\n",
+    "</table>\n",
+    "\n",
+    "<table style=\"margin : 0 auto 0 auto; width : 100px;text-align:center;\">\n",
+    "  <caption style=\"caption-side:bottom;\">Fig.2.2 - Carré magique de lettres d'ordre 5</caption>\n",
+    "<tr><td>C</td><td>U</td><td>L</td><td>T</td><td>E</td></tr>\n",
+    "<tr><td>U</td><td>N</td><td>I</td><td>E</td><td>S</td></tr>\n",
+    "<tr><td>L</td><td>I</td><td>O</td><td>N</td><td>S</td></tr>\n",
+    "<tr><td>T</td><td>E</td><td>N</td><td>T</td><td>A</td></tr>\n",
+    "<tr><td>E</td><td>S</td><td>S</td><td>A</td><td>I</td></tr>\n",
+    "</table>\n",
+    "\n",
+    "> Écrire un prédicat `est_magique_lettres` qui prend une matrice de caractères en paramètre et indique si le carré est magique de lettres ou non."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Application - Pour aller plus loin\n",
+    "\n",
+    "<table style=\"margin : 0 auto 0 auto; width : 100px;text-align:center;\">\n",
+    "  <caption style=\"caption-side:bottom;\">Fig.3 - Dessin d'une maison</caption>\n",
+    "<tr><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td></tr>\n",
+    "<tr><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td></tr>\n",
+    "<tr><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td></tr>\n",
+    "<tr><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td></tr>\n",
+    "<tr><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td></tr>\n",
+    "<tr><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td></tr>\n",
+    "</table>\n",
+    "\n",
+    "Déclaration de la matrice correspondante à la Fig.1 :\n",
+    "```python\n",
+    "matrice = [\n",
+    "  ['⚪', '⚪', '⚪', '⚫', '⚪', '⚪'],\n",
+    "  ['⚪', '⚪', '⚫', '⚪', '⚫', '⚪'],\n",
+    "  ['⚪', '⚫', '⚪', '⚪', '⚪', '⚫'],\n",
+    "  ['⚫', '⚫', '⚫', '⚫', '⚫', '⚫'],\n",
+    "  ['⚫', '⚪', '⚫', '⚪', '⚪', '⚫'],\n",
+    "  ['⚫', '⚫', '⚫', '⚫', '⚫', '⚫']\n",
+    "]\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "1. Écrire une méthode `miroir_vertical` qui prend en paramètre une matrice et a pour effet de bord de réaliser l'effet miroir vertical sur les valeurs de la matrice.\n",
+    "\n",
+    "<table style=\"margin : 0 auto 0 auto; width : 100px;text-align:center;\">\n",
+    "  <caption style=\"caption-side:bottom;\">Fig.3.1 - Effet miroir vertical de la Fig.4</caption>\n",
+    "<tr><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td></tr>\n",
+    "<tr><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td></tr>\n",
+    "<tr><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td></tr>\n",
+    "<tr><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td></tr>\n",
+    "<tr><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td></tr>\n",
+    "<tr><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td></tr>\n",
+    "</table>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "2. Écrire une méthode `miroir_horizontal` qui prend en paramètre une matrice et a pour effet de bord de réaliser l'effet miroir horizontal sur les valeurs de la matrice.\n",
+    "\n",
+    "<table style=\"margin : 0 auto 0 auto; width : 100px;text-align:center;\">\n",
+    "  <caption style=\"caption-side:bottom;\">Fig.3.2 - Effet miroir horizontal de la Fig.4</caption>\n",
+    "<tr><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td></tr>\n",
+    "<tr><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td></tr>\n",
+    "<tr><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td></tr>\n",
+    "<tr><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td></tr>\n",
+    "<tr><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td></tr>\n",
+    "<tr><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td></tr>\n",
+    "</table>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "3. Écrire une fonction `rotation_horaire` qui prend en paramètre une matrice et renvoie une matrice dont les valeurs correspondent à la rotation dans le sens horaire des valeurs de la matrice.\n",
+    "\n",
+    "<table style=\"margin : 0 auto 0 auto; width : 100px;text-align:center;\">\n",
+    "  <caption style=\"caption-side:bottom;\">Fig.3.3 - Roration horaire de la Fig.4</caption>\n",
+    "<tr><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td></tr>\n",
+    "<tr><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td></tr>\n",
+    "<tr><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td></tr>\n",
+    "<tr><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td></tr>\n",
+    "<tr><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td></tr>\n",
+    "<tr><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td></tr>\n",
+    "</table>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 3"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "4. Écrire une fonction `rotation_anti_horaire` qui prend en paramètre une matrice et renvoie une matrice dont les valeurs correspondent à la rotation dans le sens anti-horaire des valeurs de la matrice.\n",
+    "\n",
+    "<table style=\"margin : 0 auto 0 auto; width : 100px;text-align:center;\">\n",
+    "  <caption style=\"caption-side:bottom;\">Fig.3.4 - Roration anti-horaire de la Fig.4</caption>\n",
+    "<tr><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td></tr>\n",
+    "<tr><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td></tr>\n",
+    "<tr><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td></tr>\n",
+    "<tr><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td></tr>\n",
+    "<tr><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td></tr>\n",
+    "<tr><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td></tr>\n",
+    "</table>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 4"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Pour valider vos fonctions, vous pouvez réaliser sur papier les opérations miroir et de rotation sur la Fig.4 et vérifier que les résultats obtenus sont conformes.\n",
+    "\n",
+    "<table style=\"margin : 0 auto 0 auto; width : 100px;text-align:center;\">\n",
+    "  <caption style=\"caption-side:bottom;\">Fig.4 - Dessin d'un bateau avec une mouette</caption>\n",
+    "<tr><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td></tr>\n",
+    "<tr><td>&#9898;</td><td>&#9899;</td><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td></tr>\n",
+    "<tr><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td></tr>\n",
+    "<tr><td>&#9898;</td><td>&#9899;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td></tr>\n",
+    "<tr><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td></tr>\n",
+    "<tr><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td></tr>\n",
+    "<tr><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td></tr>\n",
+    "<tr><td>&#9898;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9898;</td></tr>\n",
+    "</table>\n",
+    "\n",
+    "Déclaration de la matrice correspondante à la Fig.4 :\n",
+    "```python\n",
+    "matrice = [\n",
+    "  ['⚪', '⚪', '⚫', '⚪', '⚪', '⚪', '⚪'],\n",
+    "  ['⚪', '⚫', '⚫', '⚪', '⚫', '⚪', '⚫'],\n",
+    "  ['⚫', '⚪', '⚫', '⚪', '⚪', '⚫', '⚪'],\n",
+    "  ['⚪', '⚫', '⚫', '⚪', '⚪', '⚪', '⚪'],\n",
+    "  ['⚪', '⚪', '⚫', '⚪', '⚪', '⚪', '⚪'],\n",
+    "  ['⚫', '⚫', '⚫', '⚫', '⚫', '⚫', '⚫'],\n",
+    "  ['⚫', '⚪', '⚪', '⚪', '⚪', '⚪', '⚫'],\n",
+    "  ['⚪', '⚫', '⚫', '⚫', '⚫', '⚫', '⚪']\n",
+    "]\n",
+    "```"
+   ]
+  }
+ ],
+ "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.9.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

representation_construits/chapitre_1/td/correction.ipynb

@@ -0,0 +1,940 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# TD : Les Tableaux\n",
+    "\n",
+    "Ce TD va nous permettre de manipuler les tableaux en Python."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1. Rappel\n",
+    "\n",
+    "Pour créer un tableau en python, la syntaxe est la suivante :\n",
+    "\n",
+    "```python\n",
+    ">>> tableau = []\n",
+    "```\n",
+    "\n",
+    "Pour ajouter un élément à un tableau, on utilise la méthode `append` :\n",
+    "\n",
+    "```python\n",
+    ">>> tableau.append('NSI')\n",
+    ">>> tableau.append('ANGLAIS')\n",
+    ">>> tableau\n",
+    "['NSI', 'ANGLAIS']\n",
+    "```\n",
+    "\n",
+    "Pour accéder à un élément, on utilise son **indice** :\n",
+    "\n",
+    "```python\n",
+    ">>> tableau[0]\n",
+    "'NSI'\n",
+    ">>> tableau[1]\n",
+    "'ANGLAIS'\n",
+    "```\n",
+    "\n",
+    "Il est également possible de créer un tableau avec un ensemble d'éléments :\n",
+    "\n",
+    "```python\n",
+    ">>> tableau = ['NSI', 'ANGLAIS', 'PHYSIQUE']\n",
+    ">>> tableau\n",
+    "['NSI', 'ANGLAIS', 'PHYSIQUE']\n",
+    "```\n",
+    "\n",
+    "Il est possible d'obtenir la taille du tableau, i.e le nombre d'éléments grâce à la méthode `len` :\n",
+    "\n",
+    "```python\n",
+    ">>> len(tableau)\n",
+    "3\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. Exercices"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Exercice 1 : Création de tableaux\n",
+    "\n",
+    "1. Créer un tableau contenant l'ensemble des noms des personnes dans la salle de TP\n",
+    "2. Créer un tableau contenant l'ensemble des entiers pairs entre 0 et 20 inclus,\n",
+    "3. Afficher uniquement les entiers du tableau, construit à la question 2, qui sont multiples de 4.\n",
+    "4. Créer une fonction `aleatoire` qui renvoie un tableau de valeurs aléatoires. Elle prend 3 entiers en paramètre :\n",
+    "    - $n$ : le nombre d'éléments du tableau\n",
+    "    - $min$ : la valeur minimale possible\n",
+    "    - $max$ : la valeur maximale possible"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 1\n",
+    "personnes = ['Albert', 'Bertrand', 'Camille']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 2\n",
+    "pairs = [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 3\n",
+    "for entier in pairs:\n",
+    "    if entier % 4 == 0:\n",
+    "        print(entier)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 4\n",
+    "import random\n",
+    "def aleatoire(n, min, max):\n",
+    "    tableau = []\n",
+    "    for i in range(n):\n",
+    "        tableau.append(random.randint(min, max))\n",
+    "    return tableau"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Exercice 2 : Parcours et Recherche\n",
+    "\n",
+    "```python\n",
+    ">>> groupe_1 = ['Alan', 'Brice', 'Chloé', 'Damien', 'Eléonore', 'Farid']\n",
+    ">>> groupe_2 = ['Damien', 'Killian', 'Margot', 'Tom', 'Hugo', 'Killian']\n",
+    "```\n",
+    "\n",
+    "1. Écrire une fonction `indice` qui prend en paramètre un tableau de noms et un nom et permet d'obtenir l'indice du nom dans le tableau.\n",
+    "2. Écrire une fonction `est_present` qui prend en paramètre un tableau et un nom et renvoie True si le nom est présent dans le tableau, False sinon.\n",
+    "3. Écrire une fonction `indices` qui prend en paramètre un tableau de noms et un nom et permet d'obtenir l'ensemble des indices du nom dans le tableau.\n",
+    "4. Écrire une fonction `compte` qui prend en paramètre un tableau de noms et un nom et permet d'obtenir le nombre d'occurrences du nom dans le tableau."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 1\n",
+    "def indice(tableau, element):\n",
+    "    '''\n",
+    "    Indique l'indice où se situe l'élément dans le tableau\n",
+    "    :param tableau: (list) un tableau\n",
+    "    :param element: (any) un élément\n",
+    "    :return: (int) le premier indice de l'élément dans le tableau, None sinon\n",
+    "    :doctest:\n",
+    "        >>> indice([0, 1, 2, 3], 1)\n",
+    "        1\n",
+    "        >>> indice([], 1) is None\n",
+    "        True\n",
+    "        >>> indice([3, 2, 0, 1], 1)\n",
+    "        3\n",
+    "        >>> indice([3, 2, 1, 1], 1)\n",
+    "        2\n",
+    "    '''\n",
+    "    i = 0\n",
+    "    while i < len(tableau) and tableau[i] != element:\n",
+    "        i += 1\n",
+    "    if i == len(tableau):\n",
+    "        return None\n",
+    "    return i"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 2\n",
+    "def est_present(tableau, element):\n",
+    "    '''\n",
+    "    Indique si l'élément est dans la liste\n",
+    "    :param tableau: (list) un tableau\n",
+    "    :param element: (any) un élément\n",
+    "    :return: (bool) True si l'élément est dans la liste, False sinon\n",
+    "    :doctest;\n",
+    "        >>> est_present([0, 1, 2, 3], 1)\n",
+    "        True\n",
+    "        >>> est_present([], 1)\n",
+    "        False\n",
+    "        >>> est_present(['Belgique', 'Pays-Bas', 'Luxembourg'], 'France')\n",
+    "        False\n",
+    "        >>> est_present([3, 2, 1, 1], 1)\n",
+    "        True\n",
+    "    '''\n",
+    "    return indice(tableau, element) is not None"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 3\n",
+    "def indices(tableau, element):\n",
+    "    '''\n",
+    "    Indique les indices où se situent l'élément dans le tableau\n",
+    "    :param tableau: (list) un tableau\n",
+    "    :param element: (any) un élément\n",
+    "    :return: (list) les indices de l'élément dans le tableau\n",
+    "    :doctest:\n",
+    "        >>> indices([0, 1, 2, 3], 1)\n",
+    "        [1]\n",
+    "        >>> indices([], 1)\n",
+    "        []\n",
+    "        >>> indices([3, 2, 0, 1], 1)\n",
+    "        [3]\n",
+    "        >>> indices([3, 1, 2, 1], 1)\n",
+    "        [1, 3]\n",
+    "    '''\n",
+    "    i = []\n",
+    "    for j in range(len(tableau)):\n",
+    "        if tableau[j] == element:\n",
+    "            i.append(j)\n",
+    "    return i"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 4\n",
+    "def compte(tableau, element):\n",
+    "    '''\n",
+    "    Compte le nombre d'occurrences de l'élément dans le tableau\n",
+    "    :param tableau: (list) Un tableau\n",
+    "    :param element: (any) un élément\n",
+    "    ;return: (int) le nombre d'occurrences de l'élément dans le tableau\n",
+    "    :doctest:\n",
+    "        >>> compte([], 1)\n",
+    "        0\n",
+    "        >>> compte([1], 1)\n",
+    "        1\n",
+    "        >>> compte([0], 1)\n",
+    "        0\n",
+    "        >>> compte([1, 0, 1, 0], 1)\n",
+    "        2\n",
+    "    '''\n",
+    "    occurrences = 0\n",
+    "    for x in tableau:\n",
+    "        if x == element:\n",
+    "            occurrences += 1\n",
+    "    return occurrences"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Exercice 3 : Agrégation\n",
+    "\n",
+    "```python\n",
+    ">>> notes = [14.5, 13, 7, 10.25, 16, 12.5, 9.5]\n",
+    "```\n",
+    "\n",
+    "1. Écrire une fonction `somme` qui prend en paramètre un tableau de flottants et renvoie la somme des valeurs du tableau.\n",
+    "2. Écrire une fonction `moyenne` qui prend en paramètre un tableau de flottants et renvoie la valeur moyenne du tableau.\n",
+    "3. Écrire une fonction `maximum` qui prend en paramètre un tableau de flottants et renvoie la valeur maximale du tableau.  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 1\n",
+    "def somme(tableau):\n",
+    "    '''\n",
+    "    Calcule la somme des éléments du tableau\n",
+    "    :param tableau: (list) une tableau\n",
+    "    :return: (int) la somme\n",
+    "    :doctest:\n",
+    "        >>> somme([1, 2, 3])\n",
+    "        6\n",
+    "        >>> somme([1, -2, 3])\n",
+    "        2\n",
+    "        >>> somme([])\n",
+    "        0\n",
+    "    '''\n",
+    "    _somme = 0\n",
+    "    for element in tableau:\n",
+    "        _somme += element\n",
+    "    return _somme"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 2\n",
+    "def moyenne(tableau):\n",
+    "    '''\n",
+    "    Calcule la moyenne des éléments du tableau\n",
+    "    :param tableau: (list) un tableau\n",
+    "    :return: (float) la moyenne des éléments du tableau\n",
+    "    :doctest:\n",
+    "        >>> moyenne([1, 1, 1])\n",
+    "        1.0\n",
+    "        >>> moyenne([1, 2, 3])\n",
+    "        2.0\n",
+    "        >>> moyenne([])\n",
+    "        Traceback (most recent call last):\n",
+    "        ...\n",
+    "        ZeroDivisionError: division by zero\n",
+    "    '''\n",
+    "    return somme(tableau) / len(tableau)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 3\n",
+    "def maximum(tableau):\n",
+    "    '''\n",
+    "    Trouve l'élément avec la valeur maximale du tableau\n",
+    "    :param tableau: (list) un tableau\n",
+    "    :return: (int) l'élément de valeur maximale\n",
+    "    :doctest:\n",
+    "        >>> maximum([1, 2, 3])\n",
+    "        3\n",
+    "        >>> maximum([-1, -2, -3])\n",
+    "        -1\n",
+    "        >>> maximum([]) is None\n",
+    "        True\n",
+    "    '''\n",
+    "    if len(tableau) == 0:\n",
+    "        return None\n",
+    "    max = tableau[0]\n",
+    "    for element in tableau:\n",
+    "        if element > max:\n",
+    "            max = element\n",
+    "    return max"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Exercice 4 : Manipulations sur les tableaux\n",
+    "\n",
+    "Pour tester les fonctions de manipulations, nous utiliserons le Code Konami<sup>[wikipédia](https://fr.wikipedia.org/wiki/Code_Konami)</sup>\n",
+    "\n",
+    "```python\n",
+    ">>> code = [\"↑\", \"↑\", \"↓\",\"↓\", \"←\", \"→\", \"←\", \"→\", \"B\", \"A\"]\n",
+    "```\n",
+    "\n",
+    "1. Écrire une méthode `inverser` qui prend en paramètre un tableau et a pour effet de bord d'inverser l'ensemble des valeurs du tableau.\n",
+    "2. Écrire une fonction `copie` qui prend en paramètre un tableau et renvoie une copie du tableau.\n",
+    "3. Écrire une méthode `dedoublonner` qui prend en paramètre un tableau et a pour effet de bord de supprimer les doublons d'une même valeur. \n",
+    "4. Écrire une fonction `tranche` qui prend en paramètre un tableau et deux entiers $min$ et $max$, et renvoie le sous-tableau entre $min$ et $max$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 1\n",
+    "def inverser(tableau):\n",
+    "    '''\n",
+    "    Inverse les éléments du tableau\n",
+    "    :param tableau: (list) un tableau\n",
+    "    :doctest:\n",
+    "        >>> t = [1, 2, 3]\n",
+    "        >>> inverser(t)\n",
+    "        >>> t\n",
+    "        [3, 2, 1]\n",
+    "        >>> t = ['b', 'o', 'n', 'j', 'o', 'u', 'r']\n",
+    "        >>> inverser(t)\n",
+    "        >>> t\n",
+    "        ['r', 'u', 'o', 'j', 'n', 'o', 'b']\n",
+    "    '''\n",
+    "    debut = 0\n",
+    "    fin = len(tableau) - 1\n",
+    "    \n",
+    "    while debut < fin:\n",
+    "        tableau[debut], tableau[fin] = tableau[fin], tableau[debut]\n",
+    "        debut += 1\n",
+    "        fin -= 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 2\n",
+    "def copie(tableau):\n",
+    "    '''\n",
+    "    Renvoie une copie du tableau\n",
+    "    :param tableau: (list) un tableau\n",
+    "    :return: (list) une copie du tableau\n",
+    "    :doctest:\n",
+    "        >>> copie([1, 1, 1, 1])\n",
+    "        [1, 1, 1, 1]\n",
+    "        >>> copie([1, 2, 3, 4])\n",
+    "        [1, 2, 3, 4]\n",
+    "        >>> copie([])\n",
+    "        []\n",
+    "    '''\n",
+    "    resultat = []\n",
+    "    for element in tableau:\n",
+    "        resultat.append(element)\n",
+    "    return resultat"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 3\n",
+    "def dedoublonner(tableau):\n",
+    "    '''\n",
+    "    Renvoie un tableau sans doublant\n",
+    "    :param tableau: (list) un tableau\n",
+    "    :return: (list) le tableau sans doublon\n",
+    "    :doctest:\n",
+    "        >>> dedoublonner([1, 1, 1, 1])\n",
+    "        [1]\n",
+    "        >>> dedoublonner([1, 2, 3, 4])\n",
+    "        [1, 2, 3, 4]\n",
+    "        >>> dedoublonner([1, 2, 1, 4])\n",
+    "        [1, 2, 4]\n",
+    "    '''\n",
+    "    resultat = []\n",
+    "    for element in tableau:\n",
+    "        if not est_present(resultat, element):\n",
+    "            resultat.append(element)\n",
+    "    return resultat"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 4\n",
+    "def tranche(tableau, debut, fin):\n",
+    "    '''\n",
+    "    Obtient une tranche du tableau\n",
+    "    :param tableau: (list) un tableau\n",
+    "    :param debut: (int) l'indice du début de la tranche\n",
+    "    :param fin: (int) l'indice de fin de la tranche\n",
+    "    :return: (list) un tableau contenant les éléments entre début et fin non inclus\n",
+    "    :doctest:\n",
+    "        >>> tranche([ i for i in range(10)], 0, 10)\n",
+    "        [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
+    "        >>> tranche([ i for i in range(10)], 0, 5)\n",
+    "        [0, 1, 2, 3, 4]\n",
+    "        >>> tranche([ i for i in range(10)], 5, 10)\n",
+    "        [5, 6, 7, 8, 9]\n",
+    "    '''\n",
+    "    sous_tableau = []\n",
+    "    for i in range(debut, fin):\n",
+    "        sous_tableau.append(tableau[i])\n",
+    "    return sous_tableau"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Exercice 5 : Matrice\n",
+    "\n",
+    "1. Écrire une fonction `ligne` qui prend en paramètre une matrice et un indice de ligne en entrées et renvoie un tableau avec l'ensemble des valeurs de la ligne.\n",
+    "2. Écrire une fonction `colonne` qui prend en paramètre une matrice et un indice de colonne en entrées et renvoie un tableau avec l'ensemble des valeurs de la colonne.\n",
+    "3. Écrire une fonction `diagonale_nord_ouest` qui prend en paramètre une matrice et renvoie un tableau avec l'ensemble des valeurs de la diagonale. La première valeur est celle à l'indice \\[0]\\[0] et la dernière celle correspondant à l'indice \\[len(matrice) - 1]\\[len(matrice) - 1].\n",
+    "4. Écrire une fonction `diagonale_nord_est` qui prend en paramètre une matrice et renvoie un tableau avec l'ensemble des valeurs de la diagonale. La première valeur est celle à l'indice \\[0]\\[len(matrice) - 1] et la dernière celle correspondant à l'indice \\[len(matrice) - 1]\\[0]."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 1\n",
+    "def ligne(matrice, indice):\n",
+    "    '''\n",
+    "    Obtient un tableau comportant l'ensemble des valeurs de la ligne indice de la matrice\n",
+    "    :param matrice: (list) une matrice\n",
+    "    :param indice: (int) un entier\n",
+    "    :return: (list) un tableau de valeurs de la ligne indice\n",
+    "    :doctest:\n",
+    "        >>> ligne([[1, 2],[3, 4]], 0)\n",
+    "        [1, 2]\n",
+    "        >>> ligne([[1, 2],[3, 4]], 1)\n",
+    "        [3, 4]\n",
+    "    '''\n",
+    "    return matrice[indice]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 2\n",
+    "def colonne(matrice, indice):\n",
+    "    '''\n",
+    "    Obtient un tableau comportant l'ensemble des valeurs de la colonne indice de la matrice\n",
+    "    :param matrice: (list) une matrice\n",
+    "    :param indice: (int) un entier\n",
+    "    :return: (list) un tableau de valeurs de la colonne indice\n",
+    "    :doctest:\n",
+    "        >>> colonne([[1, 2],[3, 4]], 0)\n",
+    "        [1, 3]\n",
+    "        >>> colonne([[1, 2],[3, 4]], 1)\n",
+    "        [2, 4]\n",
+    "    '''\n",
+    "    return [ matrice[i][indice] for i in range(len(matrice[0]))]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 3\n",
+    "def diagonale_nord_ouest(matrice):\n",
+    "    '''\n",
+    "    Obtient les valeurs de la diagonale de la matrice, dont l'origine est la valeur correspondant à l'indice [0][0]\n",
+    "    :param matrice: (list) une matrice\n",
+    "    :return: (list) un tableau de valeurs de la diagonale\n",
+    "    :doctest:\n",
+    "        >>> diagonale_nord_ouest([[1, 2], [3, 4]])\n",
+    "        [1, 4]\n",
+    "        >>> diagonale_nord_ouest([['A', 'D', 'C'], ['B', 'F', 'E'], ['H', 'I', 'G']])\n",
+    "        ['A', 'F', 'G']\n",
+    "    '''\n",
+    "    return [matrice[i][i] for i in range(0, len(matrice))]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 4\n",
+    "def diagonale_nord_est(matrice):\n",
+    "    '''\n",
+    "    Obtient les valeurs de la diagonale de la matrice, dont l'origine est la valeur correspondant à l'indice [0][len(matrice) - 1]\n",
+    "    :param matrice: (list) une matrice\n",
+    "    :return: (list) un tableau de valeurs de la diagonale\n",
+    "    :doctest:\n",
+    "        >>> diagonale_nord_est([[1, 2], [3, 4]])\n",
+    "        [2, 3]\n",
+    "        >>> diagonale_nord_est([['A', 'D', 'C'], ['B', 'F', 'E'], ['H', 'I', 'G']])\n",
+    "        ['C', 'F', 'H']\n",
+    "    '''\n",
+    "    return [matrice[i][len(matrice[0]) - 1 - i] for i in range(0, len(matrice))]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Application - Carré magique\n",
+    "\n",
+    "<table style=\"margin : 0 auto 0 auto; width:100px;text-align:center;\">\n",
+    "<caption style=\"caption-side:bottom;\">Fig 1. - Carré d'ordre 4</caption>\n",
+    "<tr style=\"border:none;\"><td>16</td><td>3</td><td>2</td><td>13</td></tr>\n",
+    "<tr style=\"border:none;\"><td>5</td><td>10</td><td>11</td><td>8</td></tr>\n",
+    "<tr style=\"border:none;\"><td>9</td><td>6</td><td>7</td><td>12</td></tr>\n",
+    "<tr style=\"border:none;\"><td>4</td><td>15</td><td>14</td><td>1</td></tr>\n",
+    "</table>\n",
+    "\n",
+    "\n",
+    "En mathématiques, un ***carré magique*** d’ordre $n$ est composé de $n^2$ entiers strictement positifs, écrits sous la forme d’un tableau carré. Ces nombres sont disposés de sorte que leurs sommes sur chaque rangée, sur chaque colonne et sur chaque diagonale principale soient égales. On nomme alors ***constante magique*** la valeur de ces sommes.\n",
+    "\n",
+    "<table style=\"margin : 0 auto 0 auto; width:100px;text-align:center;\">\n",
+    "  <caption style=\"caption-side:bottom;\">Fig 1.1 - Carré magique avec sa constante égale à 34</caption>\n",
+    "<tr style=\"border:none;\"><th style=\"border : none;\"></th><td>16</td><td>3</td><td>2</td><td>13</td><th style=\"border : none;padding-left:.5em;\">&rightarrow;34</th></tr>\n",
+    "<tr style=\"border:none;\"><th style=\"border : none;\"></th><td>5</td><td>10</td><td>11</td><td>8</td><th style=\"border : none;padding-left:.5em;\">&rightarrow;34</th></tr>\n",
+    "<tr style=\"border:none;\"><th style=\"border : none;\"></th><td>9</td><td>6</td><td>7</td><td>12</td><th style=\"border : none;padding-left:.5em;\">&rightarrow;34</th></tr>\n",
+    "<tr style=\"border:none;\"><th style=\"border : none;\"></th><td>4</td><td>15</td><td>14</td><td>1</td><th style=\"border : none;padding-left:.5em;\">&rightarrow;34</th></tr>\n",
+    "<tr style=\"border:none;\"><th style=\"border : none;\">&swarr; 34</th><th style=\"border:none;\">&downarrow; 34</th><th style=\"border:none;\">&downarrow; 34</th><th style=\"border:none;\">&downarrow; 34</th><th style=\"border:none;\">&downarrow; 34</th><th style=\"border:none;\">&searr; 34</th></tr>\n",
+    "</table>\n",
+    "\n",
+    "\n",
+    "> Écrire un prédicat `est_magique` qui prend une matrice d'entiers en paramètre et indique si le carré est magique ou non."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def est_magique(matrice):\n",
+    "    '''\n",
+    "    Indique si le carré est magique ou non\n",
+    "    :param matrice: (list) un carré d'entiers\n",
+    "    :return: (bool) True si les sommes de chaque ligne, colonne et diagonale sont égales.\n",
+    "    :doctest:\n",
+    "        >>> est_magique([[2, 7, 6], [9, 5, 1], [4, 3, 8]])\n",
+    "        True\n",
+    "        >>> est_magique([[2, 7, 6], [9, 1, 5], [4, 3, 8]])\n",
+    "        False\n",
+    "        >>> est_magique([[16, 3, 2, 13], [5, 10, 11, 8], [9, 6, 7, 12], [4, 15, 14, 1]])\n",
+    "        True\n",
+    "    '''\n",
+    "    constante = somme(matrice[0])\n",
+    "    return (\n",
+    "        all([somme(ligne(matrice, i)) == constante for i in range(1, len(matrice))]) and\n",
+    "        all([somme(colonne(matrice, i)) == constante for i in range(0, len(matrice[0]))]) and\n",
+    "        somme(diagonale_nord_ouest(matrice)) == constante and\n",
+    "        somme(diagonale_nord_est(matrice)) == constante\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Carré magique de lettres\n",
+    "\n",
+    "Un ***carré magique de lettres***, également appelé « ***mots carrés*** », est une forme de mots croisés disposé en carré, ne comportant pas de case noire et constitué de mots valides dans une langue définie. Ils peuvent, par définition, être lus horizontalement et verticalement et présentent dans ces deux sens les mêmes mots.\n",
+    "\n",
+    "<table style=\"margin : 0 auto 0 auto; width : 100px;text-align:center;\">\n",
+    "  <caption style=\"caption-side:bottom;\">Fig.2.1 - Carré magique de lettres d'ordre 3</caption>\n",
+    "<tr><td>T</td><td>E</td><td>L</td></tr>\n",
+    "<tr><td>E</td><td>T</td><td>E</td></tr>\n",
+    "<tr><td>L</td><td>E</td><td>S</td></tr>\n",
+    "</table>\n",
+    "\n",
+    "<table style=\"margin : 0 auto 0 auto; width : 100px;text-align:center;\">\n",
+    "  <caption style=\"caption-side:bottom;\">Fig.2.2 - Carré magique de lettres d'ordre 5</caption>\n",
+    "<tr><td>C</td><td>U</td><td>L</td><td>T</td><td>E</td></tr>\n",
+    "<tr><td>U</td><td>N</td><td>I</td><td>E</td><td>S</td></tr>\n",
+    "<tr><td>L</td><td>I</td><td>O</td><td>N</td><td>S</td></tr>\n",
+    "<tr><td>T</td><td>E</td><td>N</td><td>T</td><td>A</td></tr>\n",
+    "<tr><td>E</td><td>S</td><td>S</td><td>A</td><td>I</td></tr>\n",
+    "</table>\n",
+    "\n",
+    "> Écrire un prédicat `est_magique_lettres` qui prend une matrice de caractères en paramètre et indique si le carré est magique de lettres ou non."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def est_magique_lettres(matrice):\n",
+    "    '''\n",
+    "    Indique si une matrice de caractères est un carré magique ou non\n",
+    "    :param matrice: (list) une matrice de caractères\n",
+    "    :return: (bool) True si la matrice est un carré magique de lettres, False sinon\n",
+    "    :doctest:\n",
+    "        >>> est_magique_lettres([['T', 'E', 'L'], ['E', 'T', 'E'], ['L', 'E', 'S']])\n",
+    "        True\n",
+    "        >>> est_magique_lettres([['T', 'E', 'L'], ['E', 'R', 'E'], ['L', 'A', 'S']])\n",
+    "        False\n",
+    "        >>> est_magique_lettres([['S', 'A', 'T', 'O', 'R'], ['A', 'R', 'E', 'P', 'O'], ['T', 'E', 'N', 'E', 'T'], ['O', 'P', 'E', 'R', 'A'], ['R', 'O', 'T', 'A', 'S']])\n",
+    "        True\n",
+    "    '''\n",
+    "    return all([ ligne(matrice, i) == colonne(matrice, i) for i in range(len(matrice))])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Application - Pour aller plus loin\n",
+    "\n",
+    "<table style=\"margin : 0 auto 0 auto; width : 100px;text-align:center;\">\n",
+    "  <caption style=\"caption-side:bottom;\">Fig.3 - Dessin d'une maison</caption>\n",
+    "<tr><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td></tr>\n",
+    "<tr><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td></tr>\n",
+    "<tr><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td></tr>\n",
+    "<tr><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td></tr>\n",
+    "<tr><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td></tr>\n",
+    "<tr><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td></tr>\n",
+    "</table>\n",
+    "\n",
+    "Déclaration de la matrice correspondante à la Fig.1 :\n",
+    "```python\n",
+    "matrice = [\n",
+    "  ['⚪', '⚪', '⚪', '⚫', '⚪', '⚪'],\n",
+    "  ['⚪', '⚪', '⚫', '⚪', '⚫', '⚪'],\n",
+    "  ['⚪', '⚫', '⚪', '⚪', '⚪', '⚫'],\n",
+    "  ['⚫', '⚫', '⚫', '⚫', '⚫', '⚫'],\n",
+    "  ['⚫', '⚪', '⚫', '⚪', '⚪', '⚫'],\n",
+    "  ['⚫', '⚫', '⚫', '⚫', '⚫', '⚫']\n",
+    "]\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "1. Écrire une méthode `miroir_vertical` qui prend en paramètre une matrice et a pour effet de bord de réaliser l'effet miroir vertical sur les valeurs de la matrice.\n",
+    "\n",
+    "<table style=\"margin : 0 auto 0 auto; width : 100px;text-align:center;\">\n",
+    "  <caption style=\"caption-side:bottom;\">Fig.3.1 - Effet miroir vertical de la Fig.4</caption>\n",
+    "<tr><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td></tr>\n",
+    "<tr><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td></tr>\n",
+    "<tr><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td></tr>\n",
+    "<tr><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td></tr>\n",
+    "<tr><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td></tr>\n",
+    "<tr><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td></tr>\n",
+    "</table>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 1\n",
+    "def miroir_vertical(matrice):\n",
+    "    '''\n",
+    "    Applique l'effet miroir par rapport à l'axe vertical sur une matrice\n",
+    "    :param matrice: (list) une matrice\n",
+    "    :doctest:\n",
+    "        >>> matrice = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
+    "        >>> miroir_vertical(matrice)\n",
+    "        >>> matrice\n",
+    "        [[3, 2, 1], [6, 5, 4], [9, 8, 7]]\n",
+    "        >>> matrice = [['⚫', '⚪', '⚫'], ['⚪', '⚪', '⚫'], ['⚪', '⚫', '⚪']]\n",
+    "        >>> miroir_vertical(matrice)\n",
+    "        >>> matrice\n",
+    "        [['⚫', '⚪', '⚫'], ['⚫', '⚪', '⚪'], ['⚪', '⚫', '⚪']]\n",
+    "    '''\n",
+    "    for tableau in matrice:\n",
+    "        inverser(tableau)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "2. Écrire une méthode `miroir_horizontal` qui prend en paramètre une matrice et a pour effet de bord de réaliser l'effet miroir horizontal sur les valeurs de la matrice.\n",
+    "\n",
+    "<table style=\"margin : 0 auto 0 auto; width : 100px;text-align:center;\">\n",
+    "  <caption style=\"caption-side:bottom;\">Fig.3.2 - Effet miroir horizontal de la Fig.4</caption>\n",
+    "<tr><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td></tr>\n",
+    "<tr><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td></tr>\n",
+    "<tr><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td></tr>\n",
+    "<tr><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td></tr>\n",
+    "<tr><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td></tr>\n",
+    "<tr><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td></tr>\n",
+    "</table>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 2\n",
+    "def miroir_horizontal(matrice):\n",
+    "    '''\n",
+    "    Applique l'effet miroir par rapport à l'axe horizontal sur une matrice\n",
+    "    :param matrice: (list) une matrice\n",
+    "    :doctest:\n",
+    "        >>> matrice = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
+    "        >>> miroir_horizontal(matrice)\n",
+    "        >>> matrice\n",
+    "        [[7, 8, 9], [4, 5, 6], [1, 2, 3]]\n",
+    "        >>> matrice = [['⚫', '⚪', '⚫'], ['⚪', '⚪', '⚫'], ['⚪', '⚫', '⚪']]\n",
+    "        >>> miroir_horizontal(matrice)\n",
+    "        >>> matrice\n",
+    "        [['⚪', '⚫', '⚪'], ['⚪', '⚪', '⚫'], ['⚫', '⚪', '⚫']]\n",
+    "    '''\n",
+    "    inverser(matrice)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "3. Écrire une fonction `rotation_horaire` qui prend en paramètre une matrice et renvoie une matrice dont les valeurs correspondent à la rotation dans le sens horaire des valeurs de la matrice.\n",
+    "\n",
+    "<table style=\"margin : 0 auto 0 auto; width : 100px;text-align:center;\">\n",
+    "  <caption style=\"caption-side:bottom;\">Fig.3.3 - Roration horaire de la Fig.4</caption>\n",
+    "<tr><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td></tr>\n",
+    "<tr><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td></tr>\n",
+    "<tr><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td></tr>\n",
+    "<tr><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td></tr>\n",
+    "<tr><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td></tr>\n",
+    "<tr><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td></tr>\n",
+    "</table>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 3\n",
+    "def rotation_horaire(matrice):\n",
+    "    '''\n",
+    "    :param matrice: (list) une matrice\n",
+    "    :doctest:\n",
+    "        >>> matrice = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
+    "        >>> rotation_horaire(matrice)\n",
+    "        [[7, 4, 1], [8, 5, 2], [9, 6, 3]]\n",
+    "        >>> matrice = [['⚫', '⚪', '⚫'], ['⚪', '⚪', '⚫'], ['⚪', '⚫', '⚪']]\n",
+    "        >>> rotation_horaire(matrice)\n",
+    "        [['⚪', '⚪', '⚫'], ['⚫', '⚪', '⚪'], ['⚪', '⚫', '⚫']]\n",
+    "    '''\n",
+    "    resultat = []\n",
+    "    for i in range(len(matrice[0])):\n",
+    "        resultat.append(colonne(matrice, i))\n",
+    "    miroir_vertical(resultat)\n",
+    "    return resultat"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "4. Écrire une fonction `rotation_anti_horaire` qui prend en paramètre une matrice et renvoie une matrice dont les valeurs correspondent à la rotation dans le sens anti-horaire des valeurs de la matrice.\n",
+    "\n",
+    "<table style=\"margin : 0 auto 0 auto; width : 100px;text-align:center;\">\n",
+    "  <caption style=\"caption-side:bottom;\">Fig.3.4 - Roration anti-horaire de la Fig.4</caption>\n",
+    "<tr><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td></tr>\n",
+    "<tr><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td></tr>\n",
+    "<tr><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td></tr>\n",
+    "<tr><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td></tr>\n",
+    "<tr><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td></tr>\n",
+    "<tr><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td></tr>\n",
+    "</table>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 4\n",
+    "def rotation_anti_horaire(matrice):\n",
+    "    '''\n",
+    "    :param matrice: (list) une matrice\n",
+    "    :doctest:\n",
+    "        >>> matrice = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
+    "        >>> rotation_anti_horaire(matrice)\n",
+    "        [[3, 6, 9], [2, 5, 8], [1, 4, 7]]\n",
+    "        >>> matrice = [['⚫', '⚪', '⚫'], ['⚪', '⚪', '⚫'], ['⚪', '⚫', '⚪']]\n",
+    "        >>> rotation_anti_horaire(matrice)\n",
+    "        [['⚫', '⚫', '⚪'], ['⚪', '⚪', '⚫'], ['⚫', '⚪', '⚪']]\n",
+    "    '''\n",
+    "    resultat = []\n",
+    "    for i in range(len(matrice[0]) - 1, -1, -1):\n",
+    "        resultat.append(colonne(matrice, i))\n",
+    "    return resultat"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Pour valider vos fonctions, vous pouvez réaliser sur papier les opérations miroir et de rotation sur la Fig.4 et vérifier que les résultats obtenus sont conformes.\n",
+    "\n",
+    "<table style=\"margin : 0 auto 0 auto; width : 100px;text-align:center;\">\n",
+    "  <caption style=\"caption-side:bottom;\">Fig.4 - Dessin d'un bateau avec une mouette</caption>\n",
+    "<tr><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td></tr>\n",
+    "<tr><td>&#9898;</td><td>&#9899;</td><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td></tr>\n",
+    "<tr><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td></tr>\n",
+    "<tr><td>&#9898;</td><td>&#9899;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td></tr>\n",
+    "<tr><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td></tr>\n",
+    "<tr><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td></tr>\n",
+    "<tr><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td></tr>\n",
+    "<tr><td>&#9898;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9898;</td></tr>\n",
+    "</table>\n",
+    "\n",
+    "Déclaration de la matrice correspondante à la Fig.4 :\n",
+    "```python\n",
+    "matrice = [\n",
+    "  ['⚪', '⚪', '⚫', '⚪', '⚪', '⚪', '⚪'],\n",
+    "  ['⚪', '⚫', '⚫', '⚪', '⚫', '⚪', '⚫'],\n",
+    "  ['⚫', '⚪', '⚫', '⚪', '⚪', '⚫', '⚪'],\n",
+    "  ['⚪', '⚫', '⚫', '⚪', '⚪', '⚪', '⚪'],\n",
+    "  ['⚪', '⚪', '⚫', '⚪', '⚪', '⚪', '⚪'],\n",
+    "  ['⚫', '⚫', '⚫', '⚫', '⚫', '⚫', '⚫'],\n",
+    "  ['⚫', '⚪', '⚪', '⚪', '⚪', '⚪', '⚫'],\n",
+    "  ['⚪', '⚫', '⚫', '⚫', '⚫', '⚫', '⚪']\n",
+    "]\n",
+    "```"
+   ]
+  }
+ ],
+ "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.9.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

representation_construits/chapitre_1/tp/README.md

@@ -0,0 +1,108 @@
+---
+title : Les Drapeaux
+author: M. BODDAERT
+license: CC-BY-NC-SA
+---
+# TP : Les Drapeaux
+
+<img src='./assets/france.png'/> 
+
+Fig 1. Drapeau français
+
+## 1. Contexte
+
+Un drapeau peut être vu comme une matrice, i.e un tableau de tableaux, de dimension $n \times m$.
+
+Soient les codes couleurs suivants :
+
+| Code | Couleur associée |
+| :--: | :----------------: |
+| 0    | NOIR             |
+| 1    | ROUGE             |
+| 2    | VERT             |
+| 3    | JAUNE             |
+| 4    | BLEU             |
+| 5    | MAGENTA             |
+| 6    | CYAN             |
+| 7    | BLANC             |
+
+Il est dès lors possible de représenter le drapeau français de la Fig.1 , en python, par la matrice $15 \times 7$ suivante :
+
+```python
+>>> drapeau = [
+  [4, 4, 4, 4, 4, 7, 7, 7, 7, 7, 1, 1, 1, 1, 1],
+  [4, 4, 4, 4, 4, 7, 7, 7, 7, 7, 1, 1, 1, 1, 1],
+  [4, 4, 4, 4, 4, 7, 7, 7, 7, 7, 1, 1, 1, 1, 1],
+  [4, 4, 4, 4, 4, 7, 7, 7, 7, 7, 1, 1, 1, 1, 1],
+  [4, 4, 4, 4, 4, 7, 7, 7, 7, 7, 1, 1, 1, 1, 1],
+  [4, 4, 4, 4, 4, 7, 7, 7, 7, 7, 1, 1, 1, 1, 1],
+  [4, 4, 4, 4, 4, 7, 7, 7, 7, 7, 1, 1, 1, 1, 1]
+]
+```
+
+En utilisant le formalisme par compréhension :
+
+```python
+>>> drapeau = [ [4] * 5 + [7] * 5 + [1] * 5 for _ in range(7)]
+```
+
+Ce formalisme compact traduit le fait que le drapeau français est constitué de ***5 cases bleues, 5 cases blanches et 5 cases rouges, et cela sur 7 lignes***.
+
+## 2. Matériel fourni
+
+Le module `paint` dispose de :
+
+- 8 variables : `NOIR, ROUGE, VERT, JAUNE, BLEU, MAGENTA, CYAN, BLANC`, qui permettent de matérialiser les couleurs,
+- d'une méthode `dessiner` qui permet d'afficher un drapeau, à partir d'une matrice passée en paramètre, dans la console de l'interpréteur python.
+
+<figure>
+  <center><img src='./assets/utilisation_paint.png'/></center>
+  <figcaption style='text-align:center;'>Fig 2. Exemple d'utilisation du module paint</figcaption>
+</figure>
+
+## 3. Consignes
+
+Vous devez créer un module `drapeau`.
+
+Pour chaque drapeau de la liste fournie en Annexe, vous devez :
+
+- Formaliser la matrice modélisant le drapeau,
+
+- Identifier la structure algorithmique,
+
+- Écrire une fonction, dans le module `drapeau` qui permette de créer la matrice modélisant le drapeau.
+
+***N.B : Vous devez utiliser le formalisme par compréhension ou l'utilisation de boucle mais il est interdit d'utiliser l'affectation par valeur, case par case.***
+
+Le module sera exécutable de la manière suivante :
+
+> python3 drapeau.py france
+
+Le résultat attendu étant l'affichage du drapeau du pays passé en paramètre.
+
+## 4. Annexe : Liste des pays et drapeaux
+
+|  Pays    | Drapeau     | Consigne |
+| :--: | :--: | :-- |
+|  Belgique    |  <img src='./assets/belgique.png'/> | Le drapeau est de dimension $ 15 \times 7$ |
+| Pays-Bas |<img src='./assets/pays_bas.png'/> | Le drapeau est de dimension $ 15 \times 6$ |
+| Suède | <img src='./assets/suede.png'/>| Le drapeau est de dimension $ 15 \times 7$ |
+| Finlande | <img src='./assets/finlande.png'/> | Le drapeau est de dimension $ 15 \times 7$ |
+| Irlande | <img src='./assets/irlande.png'/>| Le drapeau est de dimension $ 15 \times 7$ |
+| Côte d'Ivoire |<img src='./assets/cote_ivoire.png'/> | Vous devez utiliser la fonction de création du drapeau d'Irlande. |
+| Bénin | <img src='./assets/benin.png'/>| Le drapeau est de dimension $ 15 \times 6$ |
+| Suisse | <img src='./assets/suisse.png'/>| Le drapeau est de dimension $ 15 \times 7$ |
+| Guinée | <img src='./assets/guinee.png'/>| Le drapeau est de dimension $ 15 \times 7$ |
+| Mali |<img src='./assets/mali.png'/> | Vous devez utiliser la fonction de création du drapeau de Guinée. |
+| Botswana | <img src='./assets/botswana.png'/> | Le drapeau est de dimension $ 15 \times 7$ |
+| Monaco | <img src='./assets/monaco.png'/>| Le drapeau est de dimension $ 15 \times 6$ |
+| Pologne | <img src='./assets/pologne.png'/>| Vous devez utiliser la fonction de création du drapeau de Monaco. |
+| Japon | <img src='./assets/japon.png'/>| Le drapeau est de dimension $ 15 \times 7$ |
+| Hongrie | <img src='./assets/hongrie.png'/>| Le drapeau est de dimension $ 15 \times 7$ |
+| Iran | <img src='./assets/iran.png'/>| Vous devez utiliser la fonction de création du drapeau de Hongrie. |
+| Palaos | <img src='./assets/palaos.png'/>| Le drapeau est de dimension $ 15 \times 7$ |
+| Grèce |<img src='./assets/grece.png'/> | Le drapeau est de dimension $ 15 \times 6$ |
+| Etats-Unis |<img src='./assets/etats_unis.png'/> | Le drapeau est de dimension $ 15 \times 6$ |
+| République du Congo | <img src='./assets/republique_congo.png'/>| Le drapeau est de dimension $ 15 \times 7$ |
+| Trinidad et Tobago |<img src='./assets/trinidad.png'/> | Le drapeau est de dimension $ 15 \times 7$ |
+| Jamaique |<img src='./assets/jamaique.png'/> | Le drapeau est de dimension $ 15 \times 7$ |

representation_construits/chapitre_1/tp/correction.py

@@ -0,0 +1,276 @@
+#!/usr/bin/env python3
+# -*- coding : utf-8 -*-
+# Author : Philippe BODDAERT
+# Date : 28/12/2020
+# License : CC-BY-NC-SA
+''' Module de génération de Drapeaux '''
+
+import sys, copy
+from paint import NOIR, ROUGE, VERT, JAUNE, BLEU, CYAN, BLANC, dessiner
+
+def miroir_vertical(matrice):
+    '''
+    Inverse une matrice verticalment
+    '''
+    for ligne in matrice:
+        ligne.reverse()
+
+def miroir_horizontal(matrice):
+    '''
+    Inverse une matrice horizontalment
+    '''
+    matrice.reverse()
+
+def creer_drapeau_france():
+    '''
+    Génère la matrice relative au drapeau de la France
+    :return: (list) la matrice de codes couleurs
+    '''
+    return [ [BLEU] * 5 + [BLANC] * 5 + [ROUGE] * 5 for _ in range(7)]
+
+def creer_drapeau_irlande():
+    '''
+    Génère la matrice relative au drapeau de l'Irlande
+    :return: (list) la matrice de codes couleurs
+    '''
+    return [ [VERT] * 5 + [BLANC] * 5 + [ROUGE] * 5 for _ in range(7)]
+
+def creer_drapeau_cote_ivoire():
+    '''
+    Génère la matrice relative au drapeau de la Côte d'Ivoire
+    :return: (list) la matrice de codes couleurs
+    '''
+    drapeau = creer_drapeau_irlande()
+    miroir_vertical(drapeau)
+    return drapeau
+
+def creer_drapeau_belgique():
+    '''
+    Génère la matrice relative au drapeau de la Belgique
+    :return: (list) la matrice de codes couleurs
+    '''
+    return [ [NOIR] * 5 + [JAUNE] * 5 + [ROUGE] * 5 for _ in range(7)]
+
+def creer_drapeau_pays_bas():
+    '''
+    Génère la matrice relative au drapeau des Pays-Bas
+    :return: (list) la matrice de codes couleurs
+    '''
+    return [[BLEU] * 15] * 2  + [[BLANC] * 15] * 2 + [[ROUGE] * 15] * 2
+
+def creer_drapeau_suede():
+    '''
+    Génère la matrice relative au drapeau de la Suède
+    :return: (list) la matrice de codes couleurs
+    '''
+    bloc = [[BLEU] * 4 + [JAUNE] * 2 + [BLEU] * 9] * 3
+
+    return bloc + [[JAUNE] * 15] + bloc
+
+def creer_drapeau_finlande():
+    '''
+    Génère la matrice relative au drapeau de la Finlande
+    :return: (list) la matrice de codes couleurs
+    '''
+    bloc = [[BLANC] * 4 + [BLEU] * 2 + [BLANC] * 9] * 3
+    return bloc + [[BLEU] * 15] + bloc
+
+def creer_drapeau_guinee():
+    '''
+    Génère la matrice relative au drapeau de la Guinée
+    :return: (list) la matrice de codes couleurs
+    '''
+    return [ [ROUGE] * 5 + [JAUNE] * 5 + [VERT] * 5 for _ in range(7)]
+
+def creer_drapeau_mali():
+    '''
+    Génère la matrice relative au drapeau du Mali
+    :return: (list) la matrice de codes couleurs
+    '''
+    drapeau = creer_drapeau_guinee()
+    miroir_vertical(drapeau)
+    return drapeau
+
+def creer_drapeau_monaco():
+    '''
+    Génère la matrice relative au drapeau de Monaco
+    :return: (list) la matrice de codes couleurs
+    '''
+    return [[ROUGE] * 15] * 3 + [[BLANC] * 15] * 3
+
+def creer_drapeau_pologne():
+    '''
+    Génère la matrice relative au drapeau de la Pologne
+    :return: (list) la matrice de codes couleurs
+    '''
+    drapeau = creer_drapeau_monaco()
+    miroir_horizontal(drapeau)
+    return drapeau
+
+def creer_drapeau_hongrie():
+    '''
+    Génère la matrice relative au drapeau de la Hongrie
+    :return: (list) la matrice de codes couleurs
+    '''
+    return [[ROUGE] * 15] * 2 + [[BLANC] * 15] * 2 + [[VERT] * 15] * 2
+
+def creer_drapeau_iran():
+    '''
+    Génère la matrice relative au drapeau d'Iran
+    :return: (list) la matrice de codes couleurs
+    '''
+    drapeau = creer_drapeau_hongrie()
+    miroir_horizontal(drapeau)
+    return drapeau
+
+def creer_drapeau_rc():
+    '''
+    Génère la matrice relative au drapeau de la République du Congo
+    :return: (list) la matrice de codes couleurs
+    '''
+    drapeau = []
+    for i in range(7):
+        drapeau.append([VERT] * (12 - (i * 2)) + [JAUNE] * 3 + [ROUGE] * (i * 2))
+    return drapeau
+
+def creer_drapeau_trinidad():
+    '''
+    Génère la matrice relative au drapeau de Trinidad et Tobago
+    :return: (list) la matrice de codes couleurs
+    '''
+    drapeau = []
+    for i in range(7):
+        drapeau.append([ROUGE] * (7 - i) + [BLANC] + [NOIR] * 4 + [BLANC] + [ROUGE] * (i + 2))
+    miroir_vertical(drapeau)
+    return drapeau
+
+def creer_drapeau_etats_unis():
+    '''
+    Génère la matrice relative au drapeau des Etats-Unis
+    :return: (list) la matrice de codes couleurs
+    '''
+    return  ([[BLEU, BLANC] * 3 + [BLEU] + [ROUGE] * 8] +
+             [[BLEU, BLEU, BLANC, BLEU, BLANC, BLEU, BLEU] + [BLANC] * 8] +
+             [[BLEU, BLANC] * 3 + [BLEU] + [ROUGE] * 8] +
+             [[BLANC] * 15] + [[ROUGE] * 15] + [[BLANC] * 15])
+
+def creer_drapeau_benin():
+    '''
+    Génère la matrice relative au drapeau du Bénin
+    :return: (list) la matrice de codes couleurs
+    '''
+    return [[VERT] * 6 + [JAUNE] * 9 ] * 3 + [[VERT] * 6 + [ROUGE] * 9 ] * 3
+
+def creer_drapeau_botswana():
+    '''
+    Génère la matrice relative au drapeau du Botswana
+    :return: (list) la matrice de codes couleurs
+    '''
+    haut = [[CYAN] * 15] * 2 + [[BLANC] * 15]
+    bas = haut.copy()
+    miroir_horizontal(bas)
+    return  haut + [[NOIR] * 15] + bas
+
+def creer_drapeau_grece():
+    '''
+    Génère la matrice relative au drapeau de la Grèce
+    :return: (list) la matrice de codes couleurs
+    '''
+    return  ([[BLEU] * 2 + [BLANC] + [BLEU] * 2 + [BLANC] * 10] +
+             [[BLANC] * 5 + [BLEU] * 10] +
+             [[BLEU] * 2 + [BLANC] + [BLEU] * 2 + [BLANC] * 10] +
+             [[BLEU] * 15] + [[BLANC] * 15] + [[BLEU] * 15])
+
+def creer_drapeau_suisse():
+    '''
+    Génère la matrice relative au drapeau de la Suisse
+    :return: (list) la matrice de codes couleurs
+    '''
+    haut = [[ROUGE] * 15] + [[ROUGE] * 6 + [BLANC] * 3 + [ROUGE] * 6] * 2
+    bas = haut.copy()
+    miroir_horizontal(bas)
+    return haut + [[ROUGE] * 3 + [BLANC] * 9 + [ROUGE] * 3] + bas
+
+def creer_drapeau_japon():
+    '''
+    Génère la matrice relative au drapeau du Japon
+    :return: (list) la matrice de codes couleurs
+    '''
+    haut = ([[BLANC] * 15] +
+            [[BLANC] * 6 + [ROUGE] * 3 + [BLANC] * 6 ] +
+            [[BLANC] * 4 + [ROUGE] * 7 + [BLANC] * 4 ])
+    bas = haut.copy()
+    miroir_horizontal(bas)
+    return haut + [[BLANC] * 3 + [ROUGE] * 9 + [BLANC] * 3 ] + bas
+
+def creer_drapeau_jamaique():
+    '''
+    Génère la matrice relative au drapeau de la Jamaique
+    :return: (list) la matrice de codes couleurs
+    '''
+    haut = [[JAUNE] * 2 + [VERT] * 11 + [JAUNE] * 2,
+        [NOIR] * 2 + [JAUNE] * 2 + [VERT] * 7 + [JAUNE] * 2 + [NOIR] * 2,
+        [NOIR] * 4 + [JAUNE] * 2 + [VERT] * 3 + [JAUNE] * 2 + [NOIR] * 4]
+    bas = haut.copy()
+    miroir_horizontal(bas)
+    return  haut + [[NOIR] * 6 + [JAUNE] * 3 + [NOIR] * 6] + bas
+
+def creer_drapeau_palaos():
+    '''
+    Génère la matrice relative au drapeau du Palaos
+    :return: (list) la matrice de codes couleurs
+    '''
+    haut = [[CYAN] * 15] + [[CYAN] * 5 + [JAUNE] * 3 + [CYAN] * 7 ] + [[CYAN] * 3 + [JAUNE] * 7 + [CYAN] * 5 ]
+    bas = haut.copy()
+    miroir_horizontal(bas)
+    return haut + [[CYAN] * 2 + [JAUNE] * 9 + [CYAN] * 4 ] + bas
+
+def creer_drapeau_republique_dominicaine():
+    '''
+    Génère la matrice relative au drapeau de la République Dominicaine
+    :return: (list) la matrice de codes couleurs
+    '''
+    haut = [[BLEU] * 6 + [BLANC] * 3 + [ROUGE] * 6] * 3
+    bas = copy.deepcopy(haut)
+    miroir_horizontal(bas)
+    miroir_vertical(bas)
+    return haut + [[BLANC] * 7 + [BLEU] + [BLANC] * 7] + bas
+
+DRAPEAUX = {
+    'france' : creer_drapeau_france,
+    'belgique' : creer_drapeau_belgique,
+    'pays_bas' : creer_drapeau_pays_bas,
+    'irlande' : creer_drapeau_irlande,
+    'cote_ivoire' : creer_drapeau_cote_ivoire,
+    'suede' : creer_drapeau_suede,
+    'finlande' : creer_drapeau_finlande,
+    'guinee' : creer_drapeau_guinee,
+    'mali' : creer_drapeau_mali,
+    'monaco' : creer_drapeau_monaco,
+    'pologne' : creer_drapeau_pologne,
+    'hongrie' : creer_drapeau_hongrie,
+    'trinidad' : creer_drapeau_trinidad,
+    'iran' : creer_drapeau_iran,
+    'etats_unis' : creer_drapeau_etats_unis,
+    'republique_congo' : creer_drapeau_rc,
+    'benin' : creer_drapeau_benin,
+    'botswana' : creer_drapeau_botswana,
+    'grece' : creer_drapeau_grece,
+    'suisse' : creer_drapeau_suisse,
+    'japon' : creer_drapeau_japon,
+    'jamaique' : creer_drapeau_jamaique,
+    'palaos' : creer_drapeau_palaos,
+    'dominique' : creer_drapeau_republique_dominicaine
+    }
+
+if __name__ == '__main__':
+    if len(sys.argv) >= 2:
+        if sys.argv[1] == 'all':
+            for nom, fonction in DRAPEAUX.items():
+                print(nom)
+                dessiner(fonction())
+                print('')
+        elif sys.argv[1] in DRAPEAUX:
+            dessiner(DRAPEAUX[sys.argv[1]]())
+        else:
+            print(f'Le pays doit être dans la liste {list(DRAPEAUX.keys())}')

representation_construits/chapitre_1/tp/paint.py

@@ -0,0 +1,44 @@
+#! /usr/bin/env python3
+# -*- coding : utf-8 -*-
+# Author : Philippe BODDAERT
+# Date : 28/12/2020
+# License : CC-BY-NC-SA
+''' Affichage en couleur '''
+
+NOIR = 0
+ROUGE = 1
+VERT = 2
+JAUNE = 3
+BLEU = 4
+MAGENTA = 5
+CYAN = 6
+BLANC = 7
+
+def case_couleur(back = 9):
+    '''
+    Renvoi le texte d'un espace dont la couleur de fond est celle donnée
+    :param back: (int) le code couleur du fond du texte
+    '''
+    return couleur(' ', back)
+
+def couleur(texte, back = 9, fore = 9):
+    '''
+    Renvoi le texte dans la couleur donnée
+    :param fore: (int) le code couleur du texte
+    :param back: (int) le code couleur de fond du texte
+    :param texte: (str) texte à mettre en couleur
+    :return: (str) le texte mis en couleur pour affichage
+    '''
+    return f'\033[3{fore}m\033[4{back}m{texte}\033[39m\033[49m'
+
+def dessiner(matrice):
+    '''
+    Affiche le contenu de la matrice sous la forme de cases colorées
+    :param matrice: (list) un tableau de tableaux
+    :return: None
+    :CU: les valeurs de la matrice doivent être comprises entre 0 et 7 inclus
+    '''
+    for ligne in matrice:
+        for colonne in ligne:
+            print(case_couleur(colonne), sep = '', end = '')
+        print('')

representation_construits/chapitre_2/.ipynb_checkpoints/README-checkpoint.ipynb

@@ -0,0 +1,478 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "bb1cfae9",
+   "metadata": {},
+   "source": [
+    "## Représentation des données : Les Dictionnaires "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c09a37ee",
+   "metadata": {},
+   "source": [
+    "-------------"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "38d1e9f4",
+   "metadata": {},
+   "source": [
+    "> ***Contenue*** : Notions introduites : le type dictionnaire\n",
+    "\n",
+    "> ***Compétences*** : Construire une entrée de dictionnaire, savoir itérer sur es élèments d'un dictionnaire, connaître les méthodes."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0beaa407",
+   "metadata": {},
+   "source": [
+    "## Le programme"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dcbf1fd3",
+   "metadata": {},
+   "source": [
+    "-----"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "57421c29",
+   "metadata": {},
+   "source": [
+    "![bo_tuple](../assets/bo_dico.png)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "401edcc8",
+   "metadata": {},
+   "source": [
+    "## Apport de connaissances"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "717cce94",
+   "metadata": {},
+   "source": [
+    "--------"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0fc298dc",
+   "metadata": {},
+   "source": [
+    "Les dictionnaires Python permettent d'associer des valeurs à des clés : À partir d'une clé, on peut alors accéder directement à la valeur qui lui est associée."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "607fa703",
+   "metadata": {},
+   "source": [
+    "### Propriétés"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9e023220",
+   "metadata": {},
+   "source": [
+    "Les dictionnaires sont des conteneurs, comme les listes et tuples, vus précédemment, et sont mutables : *on peut donc modifier, ajouter ou supprimer du contenu.*\n",
+    "\n",
+    "Par contre, contrairement aux types de conteneurs précédémment étudiés, on ne peut pas accéder au contenu d'un dictionnaire à l'aide d'un indice : un dictionnaire n'est pas une séquence.\n",
+    "\n",
+    "Si on peut bien modifier les valeurs dans un dictionnaire, chaque clé est *unique et non mutable*. Elle peut être une chaîne de caractères, un nombre, un tulle de nombre...\n",
+    "\n",
+    "Enfin, les valeurs, quant à elles, peuvent être quelconques."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "555ca300",
+   "metadata": {},
+   "source": [
+    "------"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "21761a39",
+   "metadata": {},
+   "source": [
+    "### Création et accès"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e219df29",
+   "metadata": {},
+   "source": [
+    "Pour initialiser un dictionnaire vide : "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "09f0144b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dico = {}\n",
+    "#ou\n",
+    "dico = dict()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "766eeca7",
+   "metadata": {},
+   "source": [
+    "Pour initialiser un dictionnaire avec des valeurs :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "8523655d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "perso = {\"prenom\" : \"Bilbo\", \"age\" : 111}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7f350ef3",
+   "metadata": {},
+   "source": [
+    "On a donc la clé en premier, ici, prenom & age sont deux chaines de caractères faisant office de clés.\n",
+    "\n",
+    "Accéder à une valeur d'un dictionnaire : on donne la clé à laquelle est associée la valeur recherchée (il faut donc que la clé existe)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "c1124575",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Bilbo'"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "perso [\"prenom\"]\n",
+    "'Bilbo'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "094043d5",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "KeyError",
+     "evalue": "'taille'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
+      "\u001b[0;32m/var/folders/nb/7k573f_13zj2tnc5xd0020l40000gn/T/ipykernel_27744/399847934.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mperso\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"taille\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[0;31mKeyError\u001b[0m: 'taille'"
+     ]
+    }
+   ],
+   "source": [
+    "perso[\"taille\"]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a29f8a7f",
+   "metadata": {},
+   "source": [
+    "Tout comme les listes, on peut utiliser la fonction ***len*** pour connaître le nombre de couples stockés."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "1e8c5e32",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "2"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(perso)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "865d51b5",
+   "metadata": {},
+   "source": [
+    "-----"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a1984b3d",
+   "metadata": {},
+   "source": [
+    "### Modification et parcours"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dfd2f41e",
+   "metadata": {},
+   "source": [
+    " On ajoute très simplement un couple clé / valeur :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "24211303",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'prenom': 'Bilbo', 'age': 111, 'taille': 112}"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "perso [\"taille\"] = 112\n",
+    "perso"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "24fbdfae",
+   "metadata": {},
+   "source": [
+    " Pour modifier une valeur, c'est la même méthode : on ajoute un couple deja existant, et cela va écraser la valeur précédente :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "83ad4a74",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'prenom': 'Bilbo', 'age': 131, 'taille': 112}"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "perso[\"age\"] = 131\n",
+    "perso"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4fa255d5",
+   "metadata": {},
+   "source": [
+    "Pour supprimer une clé et sa valeur associée, on peut utiliser la fonction ***del***:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "fc43064d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "del perso[\"age\"]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c9021bee",
+   "metadata": {},
+   "source": [
+    "------"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "225cf727",
+   "metadata": {},
+   "source": [
+    "Comme les listes et les tuples, les dictionnaires sont intérables : on itère sur les clés, les valeurs, ou les couples clé / valeur\n",
+    "\n",
+    "- Itération sur les clés :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "2be77c4a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "prenom\n",
+      "taille\n"
+     ]
+    }
+   ],
+   "source": [
+    "for cle in perso.keys():\n",
+    "  print (cle)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6a0ddd68",
+   "metadata": {},
+   "source": [
+    "- Itération sur les valeurs :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "534dbdba",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Bilbo\n",
+      "112\n"
+     ]
+    }
+   ],
+   "source": [
+    "for val in perso.values():\n",
+    "  print(val)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d77a9b92",
+   "metadata": {},
+   "source": [
+    "- Itération sur les couples clé / valeur:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "21a715ba",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "prenom -> Bilbo\n",
+      "taille -> 112\n"
+     ]
+    }
+   ],
+   "source": [
+    "for (cle, val) in perso.items():\n",
+    "  print(cle, \"->\", val)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "222e7ae8",
+   "metadata": {},
+   "source": [
+    "✏ Par défaut, on itère sur les clés."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c310b73d",
+   "metadata": {},
+   "source": [
+    "### À retenir"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "65893b5c",
+   "metadata": {},
+   "source": [
+    "| Opération              | Résultat                                                     |\n",
+    "| ---------------------- | ------------------------------------------------------------ |\n",
+    "| dico[k]                | renvoie la valeur associée à la clé k                        |\n",
+    "| x in dico.values()     | renvoie True si une valeur de dico est égale à x, False sinon |\n",
+    "| x not in dico.values() | renvoie True si aucune valeur de dico n'est égale à x, False sinon |\n",
+    "| x in dico.keys()       | renvoie True si une clé de dico est égale à x, False sinon   |\n",
+    "| dico[k] = v            | Modifie la valeur v associée à la clé k ou l'ajoute si elle n'existe pas |\n",
+    "| dico.get(k, v)         | Renvoie la valeur associé à la clé k. Si la clé k n'existe pas, renvoie la valeur v |\n",
+    "| del dico(k)            | Enlève du dictionnaire la clé k                              |"
+   ]
+  }
+ ],
+ "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.8.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

representation_construits/chapitre_2/README.ipynb

@@ -0,0 +1,478 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "bb1cfae9",
+   "metadata": {},
+   "source": [
+    "## Représentation des données : Les Dictionnaires "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c09a37ee",
+   "metadata": {},
+   "source": [
+    "-------------"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "38d1e9f4",
+   "metadata": {},
+   "source": [
+    "> ***Contenue*** : Notions introduites : le type dictionnaire\n",
+    "\n",
+    "> ***Compétences*** : Construire une entrée de dictionnaire, savoir itérer sur es élèments d'un dictionnaire, connaître les méthodes."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0beaa407",
+   "metadata": {},
+   "source": [
+    "## Le programme"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dcbf1fd3",
+   "metadata": {},
+   "source": [
+    "-----"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "57421c29",
+   "metadata": {},
+   "source": [
+    "![bo_tuple](../assets/bo_dico.png)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "401edcc8",
+   "metadata": {},
+   "source": [
+    "## Apport de connaissances"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "717cce94",
+   "metadata": {},
+   "source": [
+    "--------"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0fc298dc",
+   "metadata": {},
+   "source": [
+    "Les dictionnaires Python permettent d'associer des valeurs à des clés : À partir d'une clé, on peut alors accéder directement à la valeur qui lui est associée."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "607fa703",
+   "metadata": {},
+   "source": [
+    "### Propriétés"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9e023220",
+   "metadata": {},
+   "source": [
+    "Les dictionnaires sont des conteneurs, comme les listes et tuples, vus précédemment, et sont mutables : *on peut donc modifier, ajouter ou supprimer du contenu.*\n",
+    "\n",
+    "Par contre, contrairement aux types de conteneurs précédémment étudiés, on ne peut pas accéder au contenu d'un dictionnaire à l'aide d'un indice : un dictionnaire n'est pas une séquence.\n",
+    "\n",
+    "Si on peut bien modifier les valeurs dans un dictionnaire, chaque clé est *unique et non mutable*. Elle peut être une chaîne de caractères, un nombre, un tulle de nombre...\n",
+    "\n",
+    "Enfin, les valeurs, quant à elles, peuvent être quelconques."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "555ca300",
+   "metadata": {},
+   "source": [
+    "------"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "21761a39",
+   "metadata": {},
+   "source": [
+    "### Création et accès"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e219df29",
+   "metadata": {},
+   "source": [
+    "Pour initialiser un dictionnaire vide : "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "09f0144b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dico = {}\n",
+    "#ou\n",
+    "dico = dict()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "766eeca7",
+   "metadata": {},
+   "source": [
+    "Pour initialiser un dictionnaire avec des valeurs :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "8523655d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "perso = {\"prenom\" : \"Bilbo\", \"age\" : 111}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7f350ef3",
+   "metadata": {},
+   "source": [
+    "On a donc la clé en premier, ici, prenom & age sont deux chaines de caractères faisant office de clés.\n",
+    "\n",
+    "Accéder à une valeur d'un dictionnaire : on donne la clé à laquelle est associée la valeur recherchée (il faut donc que la clé existe)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "c1124575",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Bilbo'"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "perso [\"prenom\"]\n",
+    "'Bilbo'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "094043d5",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "KeyError",
+     "evalue": "'taille'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
+      "\u001b[0;32m/var/folders/nb/7k573f_13zj2tnc5xd0020l40000gn/T/ipykernel_27744/399847934.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mperso\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"taille\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[0;31mKeyError\u001b[0m: 'taille'"
+     ]
+    }
+   ],
+   "source": [
+    "perso[\"taille\"]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a29f8a7f",
+   "metadata": {},
+   "source": [
+    "Tout comme les listes, on peut utiliser la fonction ***len*** pour connaître le nombre de couples stockés."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "1e8c5e32",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "2"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(perso)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "865d51b5",
+   "metadata": {},
+   "source": [
+    "-----"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a1984b3d",
+   "metadata": {},
+   "source": [
+    "### Modification et parcours"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dfd2f41e",
+   "metadata": {},
+   "source": [
+    " On ajoute très simplement un couple clé / valeur :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "24211303",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'prenom': 'Bilbo', 'age': 111, 'taille': 112}"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "perso [\"taille\"] = 112\n",
+    "perso"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "24fbdfae",
+   "metadata": {},
+   "source": [
+    " Pour modifier une valeur, c'est la même méthode : on ajoute un couple deja existant, et cela va écraser la valeur précédente :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "83ad4a74",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'prenom': 'Bilbo', 'age': 131, 'taille': 112}"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "perso[\"age\"] = 131\n",
+    "perso"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4fa255d5",
+   "metadata": {},
+   "source": [
+    "Pour supprimer une clé et sa valeur associée, on peut utiliser la fonction ***del***:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "fc43064d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "del perso[\"age\"]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c9021bee",
+   "metadata": {},
+   "source": [
+    "------"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "225cf727",
+   "metadata": {},
+   "source": [
+    "Comme les listes et les tuples, les dictionnaires sont intérables : on itère sur les clés, les valeurs, ou les couples clé / valeur\n",
+    "\n",
+    "- Itération sur les clés :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "2be77c4a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "prenom\n",
+      "taille\n"
+     ]
+    }
+   ],
+   "source": [
+    "for cle in perso.keys():\n",
+    "  print (cle)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6a0ddd68",
+   "metadata": {},
+   "source": [
+    "- Itération sur les valeurs :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "534dbdba",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Bilbo\n",
+      "112\n"
+     ]
+    }
+   ],
+   "source": [
+    "for val in perso.values():\n",
+    "  print(val)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d77a9b92",
+   "metadata": {},
+   "source": [
+    "- Itération sur les couples clé / valeur:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "21a715ba",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "prenom -> Bilbo\n",
+      "taille -> 112\n"
+     ]
+    }
+   ],
+   "source": [
+    "for (cle, val) in perso.items():\n",
+    "  print(cle, \"->\", val)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "222e7ae8",
+   "metadata": {},
+   "source": [
+    "✏ Par défaut, on itère sur les clés."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c310b73d",
+   "metadata": {},
+   "source": [
+    "### À retenir"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "65893b5c",
+   "metadata": {},
+   "source": [
+    "| Opération              | Résultat                                                     |\n",
+    "| ---------------------- | ------------------------------------------------------------ |\n",
+    "| dico[k]                | renvoie la valeur associée à la clé k                        |\n",
+    "| x in dico.values()     | renvoie True si une valeur de dico est égale à x, False sinon |\n",
+    "| x not in dico.values() | renvoie True si aucune valeur de dico n'est égale à x, False sinon |\n",
+    "| x in dico.keys()       | renvoie True si une clé de dico est égale à x, False sinon   |\n",
+    "| dico[k] = v            | Modifie la valeur v associée à la clé k ou l'ajoute si elle n'existe pas |\n",
+    "| dico.get(k, v)         | Renvoie la valeur associé à la clé k. Si la clé k n'existe pas, renvoie la valeur v |\n",
+    "| del dico(k)            | Enlève du dictionnaire la clé k                              |"
+   ]
+  }
+ ],
+ "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.8.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

representation_construits/chapitre_2/README.md

@@ -0,0 +1,131 @@
+## Représentation des données : Les Dictionnaires 
+
+-------------
+
+> ***Contenue*** : Notions introduites : le type dictionnaire
+> ***Compétences*** : Construire une entrée de dictionnaire, savoir itérer sur es élèments d'un dictionnaire, connaître les méthodes.
+
+## Le programme
+
+-----------
+
+![bo_tuple](../assets/bo_dico.png)
+
+## Apport de connaissances
+
+--------
+
+Les dictionnaires Python permettent d'associer des valeurs à des clés : À partir d'une clé, on peut alors accéder directement à la valeur qui lui est associée.
+
+### Propriétés
+
+Les dictionnaires sont des conteneurs, comme les listes et tuples, vus précédemment, et sont mutables : *on peut donc modifier, ajouter ou supprimer du contenu.*
+
+Par contre, contrairement aux types de conteneurs précédémment étudiés, on ne peut pas accéder au contenu d'un dictionnaire à l'aide d'un indice : un dictionnaire n'est pas une séquence.
+
+Si on peut bien modifier les valeurs dans un dictionnaire, chaque clé est *unique et non mutable*. Elle peut être une chaîne de caractères, un nombre, un tulle de nombre...
+
+Enfin, les valeurs, quant à elles, peuvent être quelconques.
+
+-----------------
+
+### Création et accès 
+
+Pour initialiser un dictionnaire vide : 
+
+```python
+dico = {}
+#ou
+dico = dict()
+```
+
+Pour initialiser un dictionnaire avec des valeurs :
+
+```pytho
+perso = {"prenom" : "Bilbo", "age" : 111}
+```
+
+On a donc la clé en premier, ici, prenom & age sont deux chaines de caractères faisant office de clés.
+
+Accéder à une valeur d'un dictionnaire : on donne la clé à laquelle est associée la valeur recherchée (il faut donc que la clé existe)
+
+```python
+perso ["prenom"]
+'Bilbo'
+perso["taille"]
+KeyError "taille"
+```
+
+Tout comme les listes, on peut utiliser la fonction ***len*** pour connaître le nombre de couples stockés.
+
+```python
+len(perso)
+2
+```
+
+--------------
+
+### Modification et parcours
+
+ On ajoute très simplement un couple clé / valeur :
+
+```python
+perso ["taille"] = 112
+perso 
+{"prenom" : 'Bilbo', 'age' : 111, 'taille' : 112}
+```
+
+ Pour modifier une valeur, c'est la même méthode : on ajoute un couple deja existant, et cela va écraser la valeur précédente :
+
+```python
+perso["age"] = 131
+perso
+{'prenom' : 'Bilbo', 'age' : 131, 'taille' : 112}
+```
+
+Pour supprimer une clé et sa valeur associée, on peut utiliser la fonction ***del***:
+
+```python
+del perso["age"]
+```
+
+-----
+
+Comme les listes et les tuples, les dictionnaires sont intérables : on itère sur les clés, les valeurs, ou les couples clé / valeur
+
+- Itération sur les clés :
+
+```python
+for cle in perso.keys():
+  print (cle)
+```
+
+- Itération sur les valeurs :
+
+```python
+for val in perso.values():
+  print(val)
+```
+
+- Itération sur les couples clé / valeur:
+
+```python
+for (cle, val) in perso.items():
+  print(cle, "->", val)
+```
+
+✏ Par défaut, on itère sur les clés.
+
+--------
+
+### À retenir
+
+| Opération              | Résultat                                                     |
+| ---------------------- | ------------------------------------------------------------ |
+| dico[k]                | renvoie la valeur associée à la clé k                        |
+| x in dico.values()     | renvoie True si une valeur de dico est égale à x, False sinon |
+| x not in dico.values() | renvoie True si aucune valeur de dico n'est égale à x, False sinon |
+| x in dico.keys()       | renvoie True si une clé de dico est égale à x, False sinon   |
+| dico[k] = v            | Modifie la valeur v associée à la clé k ou l'ajoute si elle n'existe pas |
+| dico.get(k, v)         | Renvoie la valeur associé à la clé k. Si la clé k n'existe pas, renvoie la valeur v |
+| del dico(k)            | Enlève du dictionnaire la clé k                              |

representation_construits/chapitre_2/exercices/CORRECTION.md

@@ -0,0 +1,166 @@
+## Exercice
+
+### Itérer sur les éléments d'un dictionnaire
+
+Au zoo de Beauval, il y a 5 éléphants d'Asie, 17 écureuils d'Asie, 7 hippopotames d'Afrique...
+
+On représente cet inventaire à l'aide d'un dictionnaire, de la façon suivante:
+
+```python
+zoo_Beauval = {
+'elephant' : ('Asie', 5),
+'ecureuil' : ('Asie', 17),
+'panda' : ('Asie', 2),
+'hippopotame' : ('Afrique', 7),
+'girafe' : ('Afrique', 4)
+}
+```
+
+De la même manière, on peut représenter le zoo de La Flèche :
+
+```python
+zoo_LaFleche = {
+  'ours' : ('Europe', 4),
+  'tigre' : ('Asie', 7),
+  'girafe' : ('Afrique', 11),
+  'hippopotame' : ('Afrique', 3)
+  }
+```
+
+
+
+#### Question n°1
+
+On souhaite créer une fonction *plus_grand_nombre* ( ) qui prend un zoo en paramètre et renvoie le nom de l'animal le plus présent au sein du zoo.
+
+Exemples :
+
+```python
+>> plus_grand_nombre(zoo_LaFleche)
+>> 'girafe'
+```
+
+```python
+>> plus_grand_nombre(zoo_Beauval)
+>> 'ecureuil'
+```
+
+On aura besoin d'une boucle utilisant 
+
+```python
+for (cle, valeur) in dico.items()
+```
+
+À votre avis, pourquoi ?
+
+**Nous avons besoin à la fois des clés ainsi que des valeurs**
+
+Écrire la fonction :
+
+```python
+def plus_grand_nombre(zoo):
+  """
+  :param: zoo est un dictionnaire dont les clés sont des str (noms des animaux) 
+  :param: les valeurs de ces clés sont des tuples (origine, nombre) avec origine : str et nombre : int
+  :return: le nom de l'animal le plus représenté dans le zoo, sous la forme d'une chaîne de caractères
+  """
+  
+  nom_max = 0
+  nombre_max = 0
+  for (nom, (x, nombre)) in zoo.items():
+    if nombre > nombre_max:
+      nom_max = nom
+      nombre_max = nombre
+  return nom_max 
+```
+
+
+
+Note : ici, la variable **x** fait référence à une donnée que nous n'utilisons pas.
+
+#### Question n°2
+
+On souhaite se doter d'une fonction *nombre_total* ( ) qui prend un zoo ainsi que le nom d'un continent en paramètre, et qui renvoie le nombre d'animaux originaires de ce continent dans le zoo.
+
+Exemples :
+
+```python
+>> nombre_total(zoo_LaFleche, 'Afrique')
+>> 14
+```
+
+```python
+>> nombre_total(zoo_Beauval, 'Asie')
+>> 24
+```
+
+On utilisera une boucle 
+
+```python
+for valeur in dico.values()
+```
+
+Pourquoi ?
+
+**Parce que l'on a uniquement besoin des valeurs, l'espèce animal n'est pas importante**
+
+Écrire la fonction :
+
+```python
+def nombre_total(zoo, continent):
+  """
+  :param: zoo est un dictionnaire dont les clés sont des chaines, correspondantes aux noms des animaux
+  :param: et dont les valeurs sont des tuples (origine, nombre), origine étant une chaine, nombre un int
+  :param: continent est une chaine comprenant le nom d'un continent d'où sont originaires les animaux
+  :return: la fonction renvoie le nombre d'animaux originaires de 'continent' dans ce zoo
+  """
+  
+  
+  total = 0
+  for (origine, nombre) in zoo.values():
+    if continent == origine:
+      total = total + nombre
+  return total
+```
+
+
+
+#### Question n°3
+
+Enfin, on souhaite écrire une fonction nombre, qui prendun zoo ainsi qu'un nom d'animal en paramètre, et qui renvoie le nombre de représentants de cet animal dans le zoo.
+
+Exemples :
+
+````python
+>> nombre(zoo_LaFleche, 'panda')
+>> 0
+````
+
+```python
+>> nombre(zoo_Beauval, 'panda')
+>> 2
+```
+
+
+
+Quel type de boucle va t-on utiliser ici ?
+
+**Aucune, car nous n'avons uniquement besoin que de la clé, qui est un paramètre de la fonction.**
+
+Écrire la fonction
+
+```python
+def nombre(zoo, animal):
+  """
+  :param: zoo est un dictionnaire dont les clés sont des chaines, correspondantes aux noms des animaux
+  :param: et dont les valeurs sont des tuples (origine, nombre), origine étant une chaine, nombre un int
+  :param: animal est une chaine comprenant le nom d'un animal
+  :return: la fonction renvoie le nombre de représentants du paramètre 'animal' dans ce zoo
+  """
+  
+  if animal not in zoo.keys():
+    return 0
+  else:
+    return zoo[animal][1]
+```
+

representation_construits/chapitre_2/exercices/CORRECTION_2.md

@@ -0,0 +1,80 @@
+## Exercice n°2
+
+
+
+Pour remplir le pokedex de Sacha, on modélise les informations sur les Pokemons de la façon suivante :
+
+```python
+liste_pokemons = {
+  'Bulbizarre' : (70, 7),
+  'Herbizarre' : (100,13),
+  'Abo' : (200, 7),
+  'Pikachu' : (40, 6)
+}
+```
+
+Les tuples représentent la taille en centimètres, ainsi que le poids en kilogramme du Pokemon.
+
+#### Questions :
+
+- Quel est le type de *liste_pokemons* ?
+  - **Il s'agit d'un dictionnaire, dont les clés sont des chaines de caractères représentant les nomsdes Pokemons, et les valeurs des tuples de deux entiers correspondant à la taille en cm et au poids en kg**
+
+- Quelle instruction permet d'ajouter à cette structure de données le Pokemon Goupil qui mesure 60 cm et pèse 10 kg ?
+  - **liste_pokemons["Goupix"] = (60, 10)**
+
+On donne le code suivant :
+
+```python
+def le_plus_grand(pokemons):
+  grand = None
+  taille_max = None
+  for (nom,(taille, poids)) in pokemons.items():
+    taille_max = taille
+    grand = nom
+  return(grand,taille_max)
+```
+
+- Quelle est la valeur de *le_plus_grand(liste_pokemons)* ?
+  - **Il s'agira du nom et de la taille du Pokemon le plus grand rencontré dans le dictionnaire (en cas d'égalité, il s'agira du premier Pokémon rencontré) sous la forme d'un tuple**
+
+- Écrire le code d'une fonction *le_plus_leger(liste_pokemons)* qui prend des Pokémons en paramètre et renvoie un tuple correspondant au nom ainsi qu'au poids de Pokémon le plus léger.
+
+```python
+>> le_plus_leger(liste_pokemons)
+>> ('Pikachu', 6)
+```
+
+```python
+def le_plus_leger(liste_pokemons):
+  leger = None
+  poids_min = None
+  for (nom, (taille, poids)) in liste_pokemons.items():
+    if poids_min > poids
+    poids_min = poids
+    leger = nom
+  return (leger, poids_min)
+```
+
+
+
+- Écrire une fonction *taille* qui prend en paramère un dictionnaire de Pokémons ainsi que le nom d'un Pokémon, et qui renvoie la taille de ce Pokémon.
+
+```python
+>> taille(liste_pokemons, 'Abo')
+>> 200
+```
+
+```python
+>> taille(liste_pokemons, 'Dracaufeu')
+>> None
+```
+
+```python
+def taille(liste_pokemons, nom):
+  if noms in liste_pokemons:
+    return pokemon[nom][0]
+  else:
+    return None
+```
+

representation_construits/chapitre_2/exercices/README.md

@@ -0,0 +1,148 @@
+## Exercice
+
+### Itérer sur les éléments d'un dictionnaire
+
+Au zoo de Beauval, il y a 5 éléphants d'Asie, 17 écureuils d'Asie, 7 hippopotames d'Afrique...
+
+On représente cet inventaire à l'aide d'un dictionnaire, de la façon suivante:
+
+```python
+zoo_Beauval = {
+'elephant' : ('Asie', 5),
+'ecureuil' : ('Asie', 17),
+'panda' : ('Asie', 2),
+'hippopotame' : ('Afrique', 7),
+'girafe' : ('Afrique', 4)
+}
+```
+
+De la même manière, on peut représenter le zoo de La Flèche :
+
+```python
+zoo_LaFleche = {
+  'ours' : ('Europe', 4),
+  'tigre' : ('Asie', 7),
+  'girafe' : ('Afrique', 11),
+  'hippopotame' : ('Afrique', 3)
+  }
+```
+
+
+
+#### Question n°1
+
+On souhaite créer une fonction *plus_grand_nombre* ( ) qui prend un zoo en paramètre et renvoie le nom de l'animal le plus présent au sein du zoo.
+
+Exemples :
+
+```python
+>> plus_grand_nombre(zoo_LaFleche)
+>> 'girafe'
+```
+
+```python
+>> plus_grand_nombre(zoo_Beauval)
+>> 'ecureuil'
+```
+
+On aura besoin d'une boucle utilisant 
+
+```python
+for (cle, valeur) in dico.items()
+```
+
+À votre avis, pourquoi ?
+
+
+
+Écrire la fonction :
+
+```python
+def plus_grand_nombre(zoo):
+  """
+  :param: zoo est un dictionnaire dont les clés sont des str (noms des animaux) 
+  :param: les valeurs de ces clés sont des tuples (origine, nombre) avec origine : str et nombre : int
+  :return: le nom de l'animal le plus représenté dans le zoo, sous la forme d'une chaîne de caractères
+  """
+  
+  pass
+```
+
+
+
+#### Question n°2
+
+On souhaite se doter d'une fonction *nombre_total* ( ) qui prend un zoo ainsi que le nom d'un continent en paramètre, et qui renvoie le nombre d'animaux originaires de ce continent dans le zoo.
+
+Exemples :
+
+```python
+>> nombre_total(zoo_LaFleche, 'Afrique')
+>> 14
+```
+
+```python
+>> nombre_total(zoo_Beauval, 'Asie')
+>> 24
+```
+
+On utilisera une boucle 
+
+```python
+for valeur in dico.values()
+```
+
+Pourquoi ?
+
+
+
+Écrire la fonction :
+
+```python
+def nombre_total(zoo, continent):
+  """
+  :param: zoo est un dictionnaire dont les clés sont des chaines, correspondantes aux noms des animaux
+  :param: et dont les valeurs sont des tuples (origine, nombre), origine étant une chaine, nombre un int
+  :param: continent est une chaine comprenant le nom d'un continent d'où sont originaires les animaux
+  :return: la fonction renvoie le nombre d'animaux originaires de 'continent' dans ce zoo
+  """
+  
+  pass
+```
+
+
+
+#### Question n°3
+
+Enfin, on souhaite écrire une fonction nombre, qui prendun zoo ainsi qu'un nom d'animal en paramètre, et qui renvoie le nombre de représentants de cet animal dans le zoo.
+
+Exemples :
+
+````python
+>> nombre(zoo_LaFleche, 'panda')
+>> 0
+````
+
+```python
+>> nombre(zoo_Beauval, 'panda')
+>> 2
+```
+
+
+
+Quel type de boucle va t-on utiliser ici ?
+
+Écrire la fonction
+
+```python
+def nombre(zoo, animal):
+  """
+  :param: zoo est un dictionnaire dont les clés sont des chaines, correspondantes aux noms des animaux
+  :param: et dont les valeurs sont des tuples (origine, nombre), origine étant une chaine, nombre un int
+  :param: animal est une chaine comprenant le nom d'un animal
+  :return: la fonction renvoie le nombre de représentants du paramètre 'animal' dans ce zoo
+  """
+  
+  pass
+```
+

representation_construits/chapitre_2/exercices/README_2.md

@@ -0,0 +1,58 @@
+## Exercice n°2
+
+
+
+Pour remplir le pokedex de Sacha, on modélise les informations sur les Pokemons de la façon suivante :
+
+```python
+liste_pokemons = {
+  'Bulbizarre' : (70, 7),
+  'Herbizarre' : (100,13),
+  'Abo' : (200, 7),
+  'Pikachu' : (40, 6)
+}
+```
+
+Les tuples représentent la taille en centimètres, ainsi que le poids en kilogramme du Pokemon.
+
+#### Questions :
+
+- Quel est le type de *liste_pokemons* ?
+
+- Quelle instruction permet d'ajouter à cette structure de données le Pokemon Goupil qui mesure 60 cm et pèse 10 kg ?
+
+On donne le code suivant :
+
+```python
+def le_plus_grand(pokemons):
+  grand = None
+  taille_max = None
+  for (nom,(taille, poids)) in pokemons.items():
+    taille_max = taille
+    grand = nom
+  return(grand,taille_max)
+```
+
+- Quelle est la valeur de *le_plus_grand(liste_pokemons)* ?
+
+- Écrire le code d'une fonction *le_plus_leger(liste_pokemons)* qui prend des Pokémons en paramètre et renvoie un tuple correspondant au nom ainsi qu'au poids de Pokémon le plus léger.
+
+```python
+>> le_plus_leger(liste_pokemons)
+>> ('Pikachu', 6)
+```
+
+
+
+- Écrire une fonction *taille* qui prend en paramère un dictionnaire de Pokémons ainsi que le nom d'un Pokémon, et qui renvoie la taille de ce Pokémon.
+
+```python
+>> taille(liste_pokemons, 'Abo')
+>> 200
+```
+
+```python
+>> taille(liste_pokemons, 'Dracaufeu')
+>> None
+```
+

representation_construits/chapitre_2/td/TD.ipynb

@@ -0,0 +1,279 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# TD - Les dictionnaires"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Exercice 1 - Fruits\n",
+    "\n",
+    "On considère le dictionnaire suivant qui contient différents fruits ainsi que leurs quantités."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fruits = {\"pommes\": 8, \"melons\": 3, \"poires\": 6}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "1. Quelle instruction permet d'accéder au nombre de melons ?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "2. On a acheté 16 clémentines et utilisé 4 pommes pour faire une tarte. Quelles instructions permettent de mettre à jour le dictionnaire ?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Exercice 2 - Encore des fruits"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Répondez aux questions suivantes __sans exécuter les scripts proposés__. \n",
+    "\n",
+    "_Vous les exécuterez pour vérifier vos réponses._\n",
+    "\n",
+    "1. Qu'affiche le programme suivant ?\n",
+    "```python\n",
+    "fruits = {'pommes': 4, 'melons': 3, 'poires': 6, 'clémentines': 16}\n",
+    "for c in fruits.keys():\n",
+    "    print(c)\n",
+    "```\n",
+    "2. Qu'affiche le programme suivant ?\n",
+    "```python\n",
+    "fruits = {'pommes': 4, 'melons': 3, 'poires': 6, 'clémentines': 16}\n",
+    "for cle, valeur in fruits.items():\n",
+    "    print(cle, \"->\", valeur)\n",
+    "```\n",
+    "3. Qu'affiche le programme suivant ?\n",
+    "```python\n",
+    "fruits = {'pommes': 4, 'melons': 3, 'poires': 6, 'clémentines': 16}\n",
+    "for v in fruits.values():\n",
+    "    print(v)\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Exercice 3 - Agenda\n",
+    "\n",
+    "Dans un agenda, un contact est modélisé par un dictionnaire :\n",
+    "\n",
+    "- La clé du dictionnaire est le nom des contacts. \n",
+    "- La valeur du dictionnaire est un tuple dont la première valeur est leur âge (type int) et la seconde leur ville natale (str).\n",
+    "\n",
+    "Voici une petite liste de contact :\n",
+    "\n",
+    "* Pierre a 37 ans et est né à Lille.\n",
+    "* Zoé a 21 ans et est née à Nice.\n",
+    "* Ali a 54 ans et est né à Bordeaux.\n",
+    "* Aymeric a 72 ans et est né à Nice.\n",
+    "\n",
+    "\n",
+    "1. Définissez le dictionnaire de contacts.\n",
+    "2. Donnez les commandes pour :\n",
+    "    1. accéder à l'âge de Zoé\n",
+    "    2. accéder à la ville natale d'Ali.\n",
+    "    3. décider si 'Jean' est dans le dictionnaire ou pas.\n",
+    "3. Écrire le prédicat `est_present(dic, nom)` qui renvoie `True` si le _nom_ est présent dans le dictionnaire _dic_ e t`False` sinon.\n",
+    "\n",
+    "4. Écrire la fonction `renvoyer_age(dic, nom)` qui, si le _nom_ est présent dans le dictionnaire _dic_, renvoie son âge.\n",
+    "\n",
+    "5. Écrire la fonction `renvoyer_ville(dic, nom)` qui, si le _nom_ est présent dans le dictionnaire _dic_, renvoie sa ville natale.\n",
+    "\n",
+    "6. Écrire la fonction `renvoyer_noms(dic, ville)` qui renvoie un tableau de tous les noms dont la ville de naissance est _ville_.\n",
+    "\n",
+    "7. Écrire la procédure `ajouter(dic, nom, age, ville)` qui, si le _nom_ est n'est pas présent dans le dictionnaire _dic_, l'y ajoute.\n",
+    "\n",
+    "> _Remarques :_\n",
+    ">\n",
+    "> * Documentez les fonction\n",
+    "> * Réalisez les doctests significatifs."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 1\n",
+    "\n",
+    "# Question 2.A\n",
+    "\n",
+    "# Question 2.B\n",
+    "\n",
+    "# Question 2.C\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 3"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 4"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 5"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 6"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 7"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Exercice 4 - le SCRABBLE\n",
+    "\n",
+    "Voici un descriptif des valeurs des lettres au scrabble français. \n",
+    "\n",
+    "- 0 point : **Joker** ×2 (appelés en français *jokers* ou *lettres blanches*)\n",
+    "- *1 point* : **E** ×15, **A** ×9, **I** ×8, **N** ×6, **O** ×6, **R** ×6, **S** ×6, **T** ×6, **U** ×6, **L** ×5\n",
+    "- *2 points* : **D** ×3, **M** ×3, **G** ×2\n",
+    "- *3 points* : **B** ×2, **C** ×2, **P** ×2\n",
+    "- *4 points* : **F** ×2, **H** ×2, **V** ×2\n",
+    "- *8 points* : **J** ×1, **Q** ×1\n",
+    "- *10 points* : **K** ×1, **W** ×1, **X** ×1, **Y** ×1, **Z** ×1\n",
+    "\n",
+    "\n",
+    "1. Définissez un dictionnaire _score_ qui prend les lettres majuscules en clés et leur score en valeur\n",
+    "2. Écrire une fonction `calculer_score` qui prend une chaîne de caractère _mot_ en paramètre et renvoie le score du mot s'il est possible de l'écrire avec les lettres du scrabble et `None` sinon.\n",
+    "3. Écrire une fonction `calculer_scores` qui prend un tableau de _mots_ et renvoie un tableau de score de chaque mot.\n",
+    "\n",
+    "> _Remarques :_\n",
+    ">\n",
+    "> * Documentez la fonction\n",
+    "> * Réalisez les doctests significatifs.\n",
+    "> * Pour tester vos fonctions, il est possible d'utiliser la liste de mots suivante :\n",
+    "\n",
+    "```python\n",
+    "liste_mots = ['extenue', 'ligner', 'serier', 'delasse', 'doperas', 'drapes', 'gelee', 'doucir', 'lamparo', 'salee', 'gueri', 'mulots', 'trolley', 'houppe', 'hesitez', 'vogues', 'embelli', 'etonnez', 'mers', 'riviere', 'risquer', 'grogner', 'postale', 'beler', 'lofer', 'rincent', 'boni', 'charter', 'censeur', 'glaise','sauts', 'striee', 'perclus', 'dessous', 'tireras', 'gommant', 'cooptes', 'bombyx', 'gauches', 'filiere', 'devoree', 'viriez', 'murit', 'miteux', 'empenne', 'soudez', 'cochers', 'dejoua', 'tuer', 'present']\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 3"
+   ]
+  }
+ ],
+ "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.9.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

representation_construits/chapitre_2/td/correction.ipynb

@@ -0,0 +1,394 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# TD - Les dictionnaires"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Exercice 1 - Fruits\n",
+    "\n",
+    "On considère le dictionnaire suivant qui contient différents fruits ainsi que leurs quantités."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fruits = {\"pommes\": 8, \"melons\": 3, \"poires\": 6}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "1. Quelle instruction permet d'accéder au nombre de melons ?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fruits['melons']"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "2. On a acheté 16 clémentines et utilisé 4 pommes pour faire une tarte. Quelles instructions permettent de mettre à jour le dictionnaire ?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fruits['clementines'] = 16\n",
+    "fruits['pommes'] = fruits['pommes'] - 4"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Exercice 2 - Encore des fruits"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Répondez aux questions suivantes __sans exécuter les scripts proposés__. \n",
+    "\n",
+    "_Vous les exécuterez pour vérifier vos réponses._\n",
+    "\n",
+    "1. Qu'affiche le programme suivant ?\n",
+    "```python\n",
+    "fruits = {'pommes': 4, 'melons': 3, 'poires': 6, 'clémentines': 16}\n",
+    "for c in fruits.keys():\n",
+    "    print(c)\n",
+    "```\n",
+    "2. Qu'affiche le programme suivant ?\n",
+    "```python\n",
+    "fruits = {'pommes': 4, 'melons': 3, 'poires': 6, 'clémentines': 16}\n",
+    "for cle, valeur in fruits.items():\n",
+    "    print(cle, \"->\", valeur)\n",
+    "```\n",
+    "3. Qu'affiche le programme suivant ?\n",
+    "```python\n",
+    "fruits = {'pommes': 4, 'melons': 3, 'poires': 6, 'clémentines': 16}\n",
+    "for v in fruits.values():\n",
+    "    print(v)\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Exercice 3 - Agenda\n",
+    "\n",
+    "Dans un agenda, un contact est modélisé par un dictionnaire :\n",
+    "\n",
+    "- La clé du dictionnaire est le nom des contacts. \n",
+    "- La valeur du dictionnaire est un tuple dont la première valeur est leur âge (type int) et la seconde leur ville natale (str).\n",
+    "\n",
+    "Voici une petite liste de contact :\n",
+    "\n",
+    "* Pierre a 37 ans et est né à Lille.\n",
+    "* Zoé a 21 ans et est née à Nice.\n",
+    "* Ali a 54 ans et est né à Bordeaux.\n",
+    "* Aymeric a 72 ans et est né à Nice.\n",
+    "\n",
+    "\n",
+    "1. Définissez le dictionnaire de contacts.\n",
+    "2. Donnez les commandes pour :\n",
+    "    1. accéder à l'âge de Zoé\n",
+    "    2. accéder à la ville natale d'Ali.\n",
+    "    3. décider si 'Jean' est dans le dictionnaire ou pas.\n",
+    "3. Écrire le prédicat `est_present(dic, nom)` qui renvoie `True` si le _nom_ est présent dans le dictionnaire _dic_ e t`False` sinon.\n",
+    "\n",
+    "4. Écrire la fonction `renvoyer_age(dic, nom)` qui, si le _nom_ est présent dans le dictionnaire _dic_, renvoie son âge.\n",
+    "\n",
+    "5. Écrire la fonction `renvoyer_ville(dic, nom)` qui, si le _nom_ est présent dans le dictionnaire _dic_, renvoie sa ville natale.\n",
+    "\n",
+    "6. Écrire la fonction `renvoyer_noms(dic, ville)` qui renvoie un tableau de tous les noms dont la ville de naissance est _ville_.\n",
+    "\n",
+    "7. Écrire la procédure `ajouter(dic, nom, age, ville)` qui, si le _nom_ est n'est pas présent dans le dictionnaire _dic_, l'y ajoute.\n",
+    "\n",
+    "> _Remarques :_\n",
+    ">\n",
+    "> * Documentez les fonction\n",
+    "> * Réalisez les doctests significatifs."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "21\n",
+      "Bordeaux\n",
+      "False\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Question 1\n",
+    "contacts = { 'Pierre' : (37, 'Lille'), 'Zoé' : (21, 'Nice'), 'Ali' : (54, 'Bordeaux'), 'Aymeric' : (72, 'Lorient')}\n",
+    "\n",
+    "# Question 2.A\n",
+    "print(contacts['Zoé'][0])\n",
+    "\n",
+    "# Question 2.B\n",
+    "print(contacts['Ali'][1])\n",
+    "\n",
+    "# Question 2.C\n",
+    "print('Jean' in contacts)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 3\n",
+    "def est_present(dic, nom):\n",
+    "    '''\n",
+    "    Détermine si un nom est présent dans le dictionnaire\n",
+    "    :param dic: (dict) un dictionnaire\n",
+    "    :param nom: (str) un nom de contact\n",
+    "    :return: (bool) True si le nom est dans le dictionnaire, False sinon\n",
+    "    :doctest:\n",
+    "        >>> est_present({}, 'Thomas')\n",
+    "        False\n",
+    "        >>> est_present({ 'Thomas' : (15, 'Cannes')}, 'Thomas')\n",
+    "        True\n",
+    "        >>> est_present({ 'Tham' : (15, 'Cannes')}, 'Thomas')\n",
+    "        False\n",
+    "    '''\n",
+    "    return nom in dic"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 4\n",
+    "def renvoyer_age(dic, nom):\n",
+    "    '''\n",
+    "    Renvoie l'âge du contact, s'il est présent dans le dictionnaire\n",
+    "    :param dic: (dict) un dictionnaire\n",
+    "    :param nom: (str) un nom de contact\n",
+    "    :return: (int) L'âge du contact\n",
+    "    :doctest:\n",
+    "        >>> renvoyer_age({}, 'Thomas')\n",
+    "        None\n",
+    "        >>> renvoyer_age({ 'Thomas' : (15, 'Cannes')}, 'Thomas')\n",
+    "        15\n",
+    "    '''\n",
+    "    if est_present(dic, nom):\n",
+    "        return dic[nom][0]\n",
+    "    return None"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 5\n",
+    "def renvoyer_ville(dic, nom):\n",
+    "    '''\n",
+    "    Renvoie la ville natale du contact, s'il est présent dans le dictionnaire\n",
+    "    :param dic: (dict) un dictionnaire\n",
+    "    :param nom: (str) un nom de contact\n",
+    "    :return: (str) La ville natale du contact\n",
+    "    :doctest:\n",
+    "        >>> renvoyer_ville({}, 'Thomas')\n",
+    "        None\n",
+    "        >>> renvoyer_ville({ 'Thomas' : (15, 'Cannes')}, 'Thomas')\n",
+    "        'Cannes'\n",
+    "    '''\n",
+    "    if est_present(dic, nom):\n",
+    "        return dic[nom][1]\n",
+    "    return None"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 6\n",
+    "def renvoyer_noms(dic, ville):\n",
+    "    '''\n",
+    "    Renvoie un tableau de tous les noms dont la ville de naissance est ville\n",
+    "    :param dic: (dict) un dictionnaire\n",
+    "    :param ville: (str) ville natale des contacts\n",
+    "    :return: (list) tableau de tous les noms de contacts nés dans la ville\n",
+    "    :doctest:\n",
+    "        >>> renvoyer_noms({}, 'Nice')\n",
+    "        []\n",
+    "        >>> renvoyer_noms({ 'Pierre' : (37, 'Lille'), 'Zoé' : (21, 'Nice'), 'Ali' : (54, 'Bordeaux'), 'Aymeric' : (72, 'Lorient')}\n",
+    ", 'Nice')\n",
+    "        ['Zoé', 'Aymeric']\n",
+    "    '''\n",
+    "    noms = []\n",
+    "    for contact in dic:\n",
+    "        if dic[contact][1] == ville:\n",
+    "            noms.append(contact)\n",
+    "    return noms"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 7\n",
+    "def ajouter(dic, nom, age, ville):\n",
+    "    '''\n",
+    "    Ajoute un contact s'il n'est pas présent dans le dictionnaire\n",
+    "    :param dic: (dict) un dictionnaire\n",
+    "    :param nom: (str) nom du contact\n",
+    "    :param age: (int) age du contact\n",
+    "    :param ville: (str) ville natale du contact\n",
+    "    :return: (None)\n",
+    "    :Effet de bord: Ajoute le contact au dictionnaire\n",
+    "    '''\n",
+    "    if not est_present(dic, nom):\n",
+    "        dic[nom] = (age, ville)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Exercice 4 - le SCRABBLE\n",
+    "\n",
+    "Voici un descriptif des valeurs des lettres au scrabble français. \n",
+    "\n",
+    "- 0 point : **Joker** ×2 (appelés en français *jokers* ou *lettres blanches*)\n",
+    "- *1 point* : **E** ×15, **A** ×9, **I** ×8, **N** ×6, **O** ×6, **R** ×6, **S** ×6, **T** ×6, **U** ×6, **L** ×5\n",
+    "- *2 points* : **D** ×3, **M** ×3, **G** ×2\n",
+    "- *3 points* : **B** ×2, **C** ×2, **P** ×2\n",
+    "- *4 points* : **F** ×2, **H** ×2, **V** ×2\n",
+    "- *8 points* : **J** ×1, **Q** ×1\n",
+    "- *10 points* : **K** ×1, **W** ×1, **X** ×1, **Y** ×1, **Z** ×1\n",
+    "\n",
+    "\n",
+    "1. Définissez un dictionnaire _score_ qui prend les lettres majuscules en clés et leur score en valeur\n",
+    "2. Écrire une fonction `calculer_score` qui prend une chaîne de caractère _mot_ en paramètre et renvoie le score du mot s'il est possible de l'écrire avec les lettres du scrabble et `None` sinon.\n",
+    "3. Écrire une fonction `calculer_scores` qui prend un tableau de _mots_ et renvoie un tableau de score de chaque mot.\n",
+    "\n",
+    "> _Remarques :_\n",
+    ">\n",
+    "> * Documentez la fonction\n",
+    "> * Réalisez les doctests significatifs.\n",
+    "> * Pour tester vos fonctions, il est possible d'utiliser la liste de mots suivante :\n",
+    "\n",
+    "```python\n",
+    "liste_mots = ['extenue', 'ligner', 'serier', 'delasse', 'doperas', 'drapes', 'gelee', 'doucir', 'lamparo', 'salee', 'gueri', 'mulots', 'trolley', 'houppe', 'hesitez', 'vogues', 'embelli', 'etonnez', 'mers', 'riviere', 'risquer', 'grogner', 'postale', 'beler', 'lofer', 'rincent', 'boni', 'charter', 'censeur', 'glaise','sauts', 'striee', 'perclus', 'dessous', 'tireras', 'gommant', 'cooptes', 'bombyx', 'gauches', 'filiere', 'devoree', 'viriez', 'murit', 'miteux', 'empenne', 'soudez', 'cochers', 'dejoua', 'tuer', 'present']\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 1\n",
+    "score = {'A' : 1, 'B' : 3, 'C': 3, 'D': 2, 'E' : 1, 'F' : 4, 'G': 2, 'H': 4, 'I': 1, 'J': 8, 'K': 10, 'L': 1, 'M': 2, 'N': 1, 'O': 1, 'P': 3, 'Q': 8, 'R': 1, 'S': 1, 'T': 1, 'U': 1, 'V': 4, 'W': 10, 'X': 10, 'Y': 10, 'Z': 10}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 2\n",
+    "def calculer_score(mot):\n",
+    "    '''\n",
+    "    Détermine le score d'un mot\n",
+    "    :param mot: (str) un mot\n",
+    "    :return: (int) Le score du mot\n",
+    "    '''\n",
+    "    _score = 0\n",
+    "    for lettre in mot.upper():\n",
+    "        _score += score[lettre]\n",
+    "    return _score"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question 3\n",
+    "def calculer_scores(mots):\n",
+    "    '''\n",
+    "    Détermine les scores d'un tableau de mots\n",
+    "    :param mot: (str) un mot\n",
+    "    :return: (list) Le tableau des scores des mots\n",
+    "    '''\n",
+    "    scores = []\n",
+    "    for mot in mots:\n",
+    "        scores.append(calculer_score(mot))\n",
+    "    return scores"
+   ]
+  }
+ ],
+ "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.9.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

representation_construits/chapitre_3/.ipynb_checkpoints/README-checkpoint.ipynb

@@ -0,0 +1,396 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "b8f17c0e",
+   "metadata": {},
+   "source": [
+    "# # Structures imbriquées et compréhensions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5c98615f",
+   "metadata": {},
+   "source": [
+    "> Il est possible de combiner listes, tuples, et dictionnaires. Avec la syntaxe des compréhensions, l'écriture des listes et dictionnaires semble plus élègante."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6a42e2e0",
+   "metadata": {},
+   "source": [
+    "----"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2cda11f3",
+   "metadata": {},
+   "source": [
+    "## Les structures imbriquées"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ca8a7b82",
+   "metadata": {},
+   "source": [
+    "On peut imbriquer des listes, des tuples et des dictionnaires. Par contre, les clés de dictionnaire ne peuvent pas muter.\n",
+    "\n",
+    "De ce fait, nous pouvons construire des listes de listes, des listes de tuples, des listes de dictionnaires, des tuples de listes, des dictionnaires de tuples..."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "e3846d2b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(-1, 0)"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "lst = [(4,5), (-1, 0), (2.5, 1)]\n",
+    "len (lst)\n",
+    "lst[1]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "15b98fb6",
+   "metadata": {},
+   "source": [
+    "Ici, on crée une liste de trois tuples.\n",
+    "\n",
+    "Que peuvent représenter ces trois tuples ?\n",
+    "\n",
+    "On peut vérifier qu'il s'agut bien d'un tuple :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "7ce7324e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "tuple"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "t = lst[1]\n",
+    "type(t)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8edf8304",
+   "metadata": {},
+   "source": [
+    "On peut également accéder directement à l'abscisse ou à l'ordonnée d'un point :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "056d9616",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "lst[2][1]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3622be65",
+   "metadata": {},
+   "source": [
+    "Ici, on accède donc à la première valeur du tuple n°2."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8001f10a",
+   "metadata": {},
+   "source": [
+    "------"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "572e8c71",
+   "metadata": {},
+   "source": [
+    "## Parcours"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bbd95e5a",
+   "metadata": {},
+   "source": [
+    "Soit une liste de dictionnaires"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "7ad98a69",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "persos = [{\"prenom\" : \"Bilbo\", \"nom\" : \"Baggins\", \"age\" : 111},\n",
+    "        {\"prenom\" : \"Frodo\", \"nom\": \"Baggins\", \"age\" : 33},\n",
+    "         {\"prenom\" : \"Sam\", \"nom\": \"Gamgee\", \"age\" : 21}]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "79500e4c",
+   "metadata": {},
+   "source": [
+    "On peut parcourir cette liste en séparant chaque dictionnaire :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "e1f9d519",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "----------\n",
+      "prenom  :  Bilbo\n",
+      "nom  :  Baggins\n",
+      "age  :  111\n",
+      "----------\n",
+      "prenom  :  Frodo\n",
+      "nom  :  Baggins\n",
+      "age  :  33\n",
+      "----------\n",
+      "prenom  :  Sam\n",
+      "nom  :  Gamgee\n",
+      "age  :  21\n"
+     ]
+    }
+   ],
+   "source": [
+    "for p in persos:\n",
+    "  print (\"----------\")\n",
+    "  for k, v in p.items():\n",
+    "    print (k, ' : ', v)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2e16c4c1",
+   "metadata": {},
+   "source": [
+    "Que fait la première boucle ? La seconde ?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "64e9f3d8",
+   "metadata": {},
+   "source": [
+    "------"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8c553978",
+   "metadata": {},
+   "source": [
+    "## Les compréhensions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "37f82c8b",
+   "metadata": {},
+   "source": [
+    "> La notation en compréhension permet de créer une liste ou un dictionnaire sans en lister les élèments de manière explicite."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c051c29f",
+   "metadata": {},
+   "source": [
+    "Par exemple, pour créer une liste comportant les entiers de 2 à 10 inclus :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "2ff74969",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[2, 3, 4, 5, 6, 7, 8, 9, 10]"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "[i for i in range (2, 11)]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ba1daaa0",
+   "metadata": {},
+   "source": [
+    "On peut aussi appliquer des fonctions à chaque élément :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "a1f0ed4a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[4, 9, 16, 25, 36, 49, 64, 81, 100]"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "[i ** 2 for i in range (2, 11)]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "25813435",
+   "metadata": {},
+   "source": [
+    "Enfin, il est possible d'appliquer des conditions dans votre déclaration de structures:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "34096ef5",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[9, 49, 169, 289, 529, 729, 1089, 1369, 1849, 2209]"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "[i ** 2 for i in range (2, 51) if (i ** 2) % 10 == 9]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cf329e0d",
+   "metadata": {},
+   "source": [
+    "Que fait cette instruction ?\n",
+    "\n",
+    "Pour les dictionnaires : la syntaxe est la même, il faut juste préciser la clé et la valeur de chaque élèment :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "f974717b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{2: 8, 3: 27, 4: 64, 5: 125, 6: 216, 7: 343, 8: 512, 9: 729, 10: 1000}"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "{k: k ** 3 for k in range (2, 11)}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ae71eaa0",
+   "metadata": {},
+   "source": [
+    "Cela va créer un dictionnaire donc chaque clé sera un nombre entre 2 et 11 non compris, et où la valeur de chaque clé sera le cube de la clé associée.\n",
+    "\n"
+   ]
+  }
+ ],
+ "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.8.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

representation_construits/chapitre_3/README.ipynb

@@ -0,0 +1,396 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "b8f17c0e",
+   "metadata": {},
+   "source": [
+    "# # Structures imbriquées et compréhensions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5c98615f",
+   "metadata": {},
+   "source": [
+    "> Il est possible de combiner listes, tuples, et dictionnaires. Avec la syntaxe des compréhensions, l'écriture des listes et dictionnaires semble plus élègante."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6a42e2e0",
+   "metadata": {},
+   "source": [
+    "----"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2cda11f3",
+   "metadata": {},
+   "source": [
+    "## Les structures imbriquées"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ca8a7b82",
+   "metadata": {},
+   "source": [
+    "On peut imbriquer des listes, des tuples et des dictionnaires. Par contre, les clés de dictionnaire ne peuvent pas muter.\n",
+    "\n",
+    "De ce fait, nous pouvons construire des listes de listes, des listes de tuples, des listes de dictionnaires, des tuples de listes, des dictionnaires de tuples..."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "e3846d2b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(-1, 0)"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "lst = [(4,5), (-1, 0), (2.5, 1)]\n",
+    "len (lst)\n",
+    "lst[1]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "15b98fb6",
+   "metadata": {},
+   "source": [
+    "Ici, on crée une liste de trois tuples.\n",
+    "\n",
+    "Que peuvent représenter ces trois tuples ?\n",
+    "\n",
+    "On peut vérifier qu'il s'agut bien d'un tuple :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "7ce7324e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "tuple"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "t = lst[1]\n",
+    "type(t)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8edf8304",
+   "metadata": {},
+   "source": [
+    "On peut également accéder directement à l'abscisse ou à l'ordonnée d'un point :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "056d9616",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "lst[2][1]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3622be65",
+   "metadata": {},
+   "source": [
+    "Ici, on accède donc à la première valeur du tuple n°2."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8001f10a",
+   "metadata": {},
+   "source": [
+    "------"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "572e8c71",
+   "metadata": {},
+   "source": [
+    "## Parcours"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bbd95e5a",
+   "metadata": {},
+   "source": [
+    "Soit une liste de dictionnaires"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "7ad98a69",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "persos = [{\"prenom\" : \"Bilbo\", \"nom\" : \"Baggins\", \"age\" : 111},\n",
+    "        {\"prenom\" : \"Frodo\", \"nom\": \"Baggins\", \"age\" : 33},\n",
+    "         {\"prenom\" : \"Sam\", \"nom\": \"Gamgee\", \"age\" : 21}]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "79500e4c",
+   "metadata": {},
+   "source": [
+    "On peut parcourir cette liste en séparant chaque dictionnaire :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "e1f9d519",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "----------\n",
+      "prenom  :  Bilbo\n",
+      "nom  :  Baggins\n",
+      "age  :  111\n",
+      "----------\n",
+      "prenom  :  Frodo\n",
+      "nom  :  Baggins\n",
+      "age  :  33\n",
+      "----------\n",
+      "prenom  :  Sam\n",
+      "nom  :  Gamgee\n",
+      "age  :  21\n"
+     ]
+    }
+   ],
+   "source": [
+    "for p in persos:\n",
+    "  print (\"----------\")\n",
+    "  for k, v in p.items():\n",
+    "    print (k, ' : ', v)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2e16c4c1",
+   "metadata": {},
+   "source": [
+    "Que fait la première boucle ? La seconde ?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "64e9f3d8",
+   "metadata": {},
+   "source": [
+    "------"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8c553978",
+   "metadata": {},
+   "source": [
+    "## Les compréhensions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "37f82c8b",
+   "metadata": {},
+   "source": [
+    "> La notation en compréhension permet de créer une liste ou un dictionnaire sans en lister les élèments de manière explicite."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c051c29f",
+   "metadata": {},
+   "source": [
+    "Par exemple, pour créer une liste comportant les entiers de 2 à 10 inclus :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "2ff74969",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[2, 3, 4, 5, 6, 7, 8, 9, 10]"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "[i for i in range (2, 11)]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ba1daaa0",
+   "metadata": {},
+   "source": [
+    "On peut aussi appliquer des fonctions à chaque élément :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "a1f0ed4a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[4, 9, 16, 25, 36, 49, 64, 81, 100]"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "[i ** 2 for i in range (2, 11)]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "25813435",
+   "metadata": {},
+   "source": [
+    "Enfin, il est possible d'appliquer des conditions dans votre déclaration de structures:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "34096ef5",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[9, 49, 169, 289, 529, 729, 1089, 1369, 1849, 2209]"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "[i ** 2 for i in range (2, 51) if (i ** 2) % 10 == 9]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cf329e0d",
+   "metadata": {},
+   "source": [
+    "Que fait cette instruction ?\n",
+    "\n",
+    "Pour les dictionnaires : la syntaxe est la même, il faut juste préciser la clé et la valeur de chaque élèment :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "f974717b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{2: 8, 3: 27, 4: 64, 5: 125, 6: 216, 7: 343, 8: 512, 9: 729, 10: 1000}"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "{k: k ** 3 for k in range (2, 11)}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ae71eaa0",
+   "metadata": {},
+   "source": [
+    "Cela va créer un dictionnaire donc chaque clé sera un nombre entre 2 et 11 non compris, et où la valeur de chaque clé sera le cube de la clé associée.\n",
+    "\n"
+   ]
+  }
+ ],
+ "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.8.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

representation_construits/chapitre_3/README.md

@@ -0,0 +1,98 @@
+# Structures imbriquées et compréhensions
+
+> Il est possible de combiner listes, tuples, et dictionnaires. Avec la syntaxe des compréhensions, l'écriture des listes et dictionnaires semble plus élègante.
+
+--------
+
+## Les structures imbriquées
+
+On peut imbriquer des listes, des tuples et des dictionnaires. Par contre, les clés de dictionnaire ne peuvent pas muter.
+
+De ce fait, nous pouvons construire des listes de listes, des listes de tuples, des listes de dictionnaires, des tuples de listes, des dictionnaires de tuples...
+
+```python
+lst = [(4,5), (-1, 0), (2.5, 1)]
+len (lst)
+lst[1]
+```
+
+Ici, on crée une liste de trois tuples.
+
+Que peuvent représenter ces trois tuples ?
+
+On peut vérifier qu'il s'agut bien d'un tuple :
+
+```python
+t = lst[1]
+type(t)
+```
+
+On peut également accéder directement à l'abscisse ou à l'ordonnée d'un point :
+
+```python
+lst[2][1]
+```
+
+Ici, on accède donc à la première valeur du tuple n°2.
+
+--------
+
+## Parcours
+
+Soit une liste de dictionnaires
+
+```python
+persos = [{"prenom" : "Bilbo", "nom" : "Baggins", "age" : 111},
+        {"prenom" : "Frodo", "nom": "Baggins", "age" : 33},
+         {"prenom" : "Sam", "nom": "Gamgee", "age" : 21}]
+```
+
+On peut parcourir cette liste en séparant chaque dictionnaire :
+
+```python
+for p in persos:
+  print ("----------")
+  for k, v in p.items():
+    print (k, ' : ', v)
+```
+
+Que fait la première boucle ?
+
+La seconde ?
+
+--------------------
+
+## Les compréhensions
+
+> La notation en compréhension permet de créer une liste ou un dictionnaire sans en lister les élèments de manière explicite.
+
+Par exemple, pour créer une liste comportant les entiers de 2 à 10 inclus :
+
+```python
+[i for i in range (2, 11)]
+```
+
+On peut aussi appliquer des fonctions à chaque élément :
+
+```python
+[i ** 2 for i in range (2, 11)]
+```
+
+Enfin, il est possible d'appliquer des conditions dans votre déclaration de structures:
+
+```python
+[i ** 2 for i in range (2, 51) if (i ** 2) % 10 == 9]
+```
+
+Que fait cette instruction ?
+
+Pour les dictionnaires : la syntaxe est la même, il faut juste préciser la clé et la valeur de chaque élèment :
+
+```python
+{k: k ** 3 for k in range (2, 11)}
+```
+
+Cela va créer un dictionnaire donc chaque clé sera un nombre entre 2 et 11 non compris, et où la valeur de chaque clé sera le cube de la clé associée.
+
+
+