diff --git a/representation_base/.DS_Store b/representation_base/.DS_Store
index 7e29ea6..c587415 100644
Binary files a/representation_base/.DS_Store and b/representation_base/.DS_Store differ
diff --git a/representation_base/DM.md b/representation_base/DM.md
deleted file mode 100644
index ff2e6d4..0000000
--- a/representation_base/DM.md
+++ /dev/null
@@ -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 :
- - 100111002
- - 010100112
- - 101001002
- - BEEF 16
- - 70E 16
-
-
-
-
-
-### Exercice n°3
-
-- Écrire les nombres suivants en base 16. Détaillez votre raisonnement :
- - 11110101000010102
- - 1011(10)
- - 688710
-
--------------
-
-
-
-## 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 00112
-
-- 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 10 = 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 10 = 1100, 10112
-
-
-
-**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.
-
-
-
-
-
diff --git a/representation_base/chapitre_1/cours/README.md b/representation_base/chapitre_1/cours/README.md
index 84cd9a6..54580c2 100644
--- a/representation_base/chapitre_1/cours/README.md
+++ b/representation_base/chapitre_1/cours/README.md
@@ -8,7 +8,7 @@
-
+
## Apport de connaissances
@@ -33,7 +33,7 @@ Donc 4138 peut s’écrire : 4 * 103 + 1 * 102 + 3 * 10
→où chaque chiffre (compris entre 0 et 9) est soit celui des unités, dizaines, etc…
-
+
✏ *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_**. Un
En électronique, il est facile d'obtenir un système présentant deux états stables distincts. Prenons l'exemple
d'un interrupteur
-
+
-
+
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
Exemple: (11)d = (?)b
-
+
(11)d => (1011)b
-
+
✏ Comment représenter des informations complexes ? ✏
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 **_2k
Compléter le tableau suivant afin de coder les 8 premiers entiers naturels (entiers positifs ou nul)
-
+
### À 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 28 = 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).
-
+
### Unités de mesure
@@ -126,7 +126,7 @@ Méthode :
Ecrire le nombre binaire dans le tableau de correspondance
Faire la somme des valeurs des rangs pour lesquels la valeur du bit vaut 1.
-
+
Somme : ............
@@ -153,11 +153,11 @@ Ce sera donc un système en **base 16**.
> Compléter la colonne binaire
-
+
> Passer de la base décimale à la base hexadécimale Écrire le nombre 63650 (10) en base 16
-
+
> 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 :
Ecrire le nombre hexadécimal dans le tableau de correspondance en positionnant le chiffre correspondant à chacun des rangs.
Faire la somme des produits des chiffres avec la pondération correspondante.
-
+
> 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)10 → ( 12234)5
-
+
-------------------------
@@ -201,24 +201,24 @@ Prenons l'exemple d'un mot de 2 octets (16 bits) comme 5BC9. Il y a deux organis
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.
-
+
> 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.
Le petit boutisme (ou little endian en anglais), qui au contraire place l'octet de poids faible en premier.
-
+
> 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**
-
+
en **petit boutisme**
-
+
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.
diff --git a/representation_construits/assets/bo_dico.png b/representation_construits/assets/bo_dico.png
new file mode 100644
index 0000000..4d08453
Binary files /dev/null and b/representation_construits/assets/bo_dico.png differ
diff --git a/representation_construits/assets/bo_liste.png b/representation_construits/assets/bo_liste.png
new file mode 100644
index 0000000..05f2a6f
Binary files /dev/null and b/representation_construits/assets/bo_liste.png differ
diff --git a/representation_construits/assets/bo_tuple.png b/representation_construits/assets/bo_tuple.png
new file mode 100644
index 0000000..2491759
Binary files /dev/null and b/representation_construits/assets/bo_tuple.png differ
diff --git a/representation_construits/chapitre_1/.ipynb_checkpoints/README-checkpoint.ipynb b/representation_construits/chapitre_1/.ipynb_checkpoints/README-checkpoint.ipynb
new file mode 100644
index 0000000..f72c7d4
--- /dev/null
+++ b/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": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d2f3b985",
+ "metadata": {},
+ "source": [
+ ""
+ ]
+ },
+ {
+ "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
+}
diff --git a/representation_construits/chapitre_1/README.ipynb b/representation_construits/chapitre_1/README.ipynb
new file mode 100644
index 0000000..f72c7d4
--- /dev/null
+++ b/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": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d2f3b985",
+ "metadata": {},
+ "source": [
+ ""
+ ]
+ },
+ {
+ "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
+}
diff --git a/representation_construits/chapitre_1/README.md b/representation_construits/chapitre_1/README.md
new file mode 100644
index 0000000..4316527
--- /dev/null
+++ b/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
+
+-----------
+
+
+
+
+
+## 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 |
diff --git a/representation_construits/chapitre_1/TABLEAUX.md b/representation_construits/chapitre_1/TABLEAUX.md
new file mode 100644
index 0000000..e3ab0b0
--- /dev/null
+++ b/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" ?
+
diff --git a/representation_construits/chapitre_1/projet/README.md b/representation_construits/chapitre_1/projet/README.md
new file mode 100644
index 0000000..e857db2
--- /dev/null
+++ b/representation_construits/chapitre_1/projet/README.md
@@ -0,0 +1,139 @@
+# Projet - Désamorceur de bombes
+
+
+
+## 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 |
+| :--: | :-- |
+|  | Le fil à couper est celui à l'indice 1, soit le deuxième fil. La règle qui le justifie : il n'y a pas de fil rouge. |
+|  | Le fil à couper est celui à l'indice 2, soit le dernier fil. 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.
+
+
+
+ Fig 2. Exemple d'utilisation du module paint
+
+
+## 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`.
diff --git a/representation_construits/chapitre_1/projet/assets/bomb.png b/representation_construits/chapitre_1/projet/assets/bomb.png
new file mode 100644
index 0000000..de91c19
Binary files /dev/null and b/representation_construits/chapitre_1/projet/assets/bomb.png differ
diff --git a/representation_construits/chapitre_1/projet/assets/exemple_1.png b/representation_construits/chapitre_1/projet/assets/exemple_1.png
new file mode 100644
index 0000000..588031e
Binary files /dev/null and b/representation_construits/chapitre_1/projet/assets/exemple_1.png differ
diff --git a/representation_construits/chapitre_1/projet/assets/exemple_2.png b/representation_construits/chapitre_1/projet/assets/exemple_2.png
new file mode 100644
index 0000000..8bf8fb7
Binary files /dev/null and b/representation_construits/chapitre_1/projet/assets/exemple_2.png differ
diff --git a/representation_construits/chapitre_1/projet/assets/utilisation_paint.png b/representation_construits/chapitre_1/projet/assets/utilisation_paint.png
new file mode 100644
index 0000000..6bae16b
Binary files /dev/null and b/representation_construits/chapitre_1/projet/assets/utilisation_paint.png differ
diff --git a/representation_construits/chapitre_1/projet/correction.py b/representation_construits/chapitre_1/projet/correction.py
new file mode 100644
index 0000000..d2754a0
--- /dev/null
+++ b/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é')
\ No newline at end of file
diff --git a/representation_construits/chapitre_1/projet/paint.py b/representation_construits/chapitre_1/projet/paint.py
new file mode 100644
index 0000000..c8054d1
--- /dev/null
+++ b/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('')
\ No newline at end of file
diff --git a/representation_construits/chapitre_1/td/TD.ipynb b/representation_construits/chapitre_1/td/TD.ipynb
new file mode 100644
index 0000000..4c0ec46
--- /dev/null
+++ b/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[wikipédia](https://fr.wikipedia.org/wiki/Code_Konami)\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",
+ "
\n",
+ "
Fig 1. - Carré d'ordre 4
\n",
+ "
16
3
2
13
\n",
+ "
5
10
11
8
\n",
+ "
9
6
7
12
\n",
+ "
4
15
14
1
\n",
+ "
\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",
+ "
\n",
+ "
Fig 1.1 - Carré magique avec sa constante égale à 34
\n",
+ "
16
3
2
13
→34
\n",
+ "
5
10
11
8
→34
\n",
+ "
9
6
7
12
→34
\n",
+ "
4
15
14
1
→34
\n",
+ "
↙ 34
↓ 34
↓ 34
↓ 34
↓ 34
↘ 34
\n",
+ "
\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",
+ "
\n",
+ "
Fig.2.1 - Carré magique de lettres d'ordre 3
\n",
+ "
T
E
L
\n",
+ "
E
T
E
\n",
+ "
L
E
S
\n",
+ "
\n",
+ "\n",
+ "
\n",
+ "
Fig.2.2 - Carré magique de lettres d'ordre 5
\n",
+ "
C
U
L
T
E
\n",
+ "
U
N
I
E
S
\n",
+ "
L
I
O
N
S
\n",
+ "
T
E
N
T
A
\n",
+ "
E
S
S
A
I
\n",
+ "
\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",
+ "
\n",
+ "
Fig.3 - Dessin d'une maison
\n",
+ "
⚪
⚪
⚪
⚫
⚪
⚪
\n",
+ "
⚪
⚪
⚫
⚪
⚫
⚪
\n",
+ "
⚪
⚫
⚪
⚪
⚪
⚫
\n",
+ "
⚫
⚫
⚫
⚫
⚫
⚫
\n",
+ "
⚫
⚪
⚫
⚪
⚪
⚫
\n",
+ "
⚫
⚫
⚫
⚫
⚫
⚫
\n",
+ "
\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",
+ "
\n",
+ "
Fig.3.1 - Effet miroir vertical de la Fig.4
\n",
+ "
⚪
⚪
⚫
⚪
⚪
⚪
\n",
+ "
⚪
⚫
⚪
⚫
⚪
⚪
\n",
+ "
⚫
⚪
⚪
⚪
⚫
⚪
\n",
+ "
⚫
⚫
⚫
⚫
⚫
⚫
\n",
+ "
⚫
⚪
⚪
⚫
⚪
⚫
\n",
+ "
⚫
⚫
⚫
⚫
⚫
⚫
\n",
+ "
"
+ ]
+ },
+ {
+ "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",
+ "
\n",
+ "
Fig.3.2 - Effet miroir horizontal de la Fig.4
\n",
+ "
⚫
⚫
⚫
⚫
⚫
⚫
\n",
+ "
⚫
⚪
⚫
⚪
⚪
⚫
\n",
+ "
⚫
⚫
⚫
⚫
⚫
⚫
\n",
+ "
⚪
⚫
⚪
⚪
⚪
⚫
\n",
+ "
⚪
⚪
⚫
⚪
⚫
⚪
\n",
+ "
⚪
⚪
⚪
⚫
⚪
⚪
\n",
+ "
"
+ ]
+ },
+ {
+ "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",
+ "
\n",
+ "
Fig.3.3 - Roration horaire de la Fig.4
\n",
+ "
⚫
⚫
⚫
⚪
⚪
⚪
\n",
+ "
⚫
⚪
⚫
⚫
⚪
⚪
\n",
+ "
⚫
⚫
⚫
⚪
⚫
⚪
\n",
+ "
⚫
⚪
⚫
⚪
⚪
⚫
\n",
+ "
⚫
⚪
⚫
⚪
⚫
⚪
\n",
+ "
⚫
⚫
⚫
⚫
⚪
⚪
\n",
+ "
"
+ ]
+ },
+ {
+ "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",
+ "
\n",
+ "
Fig.3.4 - Roration anti-horaire de la Fig.4
\n",
+ "
⚪
⚪
⚫
⚫
⚫
⚫
\n",
+ "
⚪
⚫
⚪
⚫
⚪
⚫
\n",
+ "
⚫
⚪
⚪
⚫
⚪
⚫
\n",
+ "
⚪
⚫
⚪
⚫
⚫
⚫
\n",
+ "
⚪
⚪
⚫
⚫
⚪
⚫
\n",
+ "
⚪
⚪
⚪
⚫
⚫
⚫
\n",
+ "
"
+ ]
+ },
+ {
+ "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",
+ "
\n",
+ "
Fig.4 - Dessin d'un bateau avec une mouette
\n",
+ "
⚪
⚪
⚫
⚪
⚪
⚪
⚪
\n",
+ "
⚪
⚫
⚫
⚪
⚫
⚪
⚫
\n",
+ "
⚫
⚪
⚫
⚪
⚪
⚫
⚪
\n",
+ "
⚪
⚫
⚫
⚪
⚪
⚪
⚪
\n",
+ "
⚪
⚪
⚫
⚪
⚪
⚪
⚪
\n",
+ "
⚫
⚫
⚫
⚫
⚫
⚫
⚫
\n",
+ "
⚫
⚪
⚪
⚪
⚪
⚪
⚫
\n",
+ "
⚪
⚫
⚫
⚫
⚫
⚫
⚪
\n",
+ "
\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
+}
diff --git a/representation_construits/chapitre_1/td/correction.ipynb b/representation_construits/chapitre_1/td/correction.ipynb
new file mode 100644
index 0000000..9c10baa
--- /dev/null
+++ b/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[wikipédia](https://fr.wikipedia.org/wiki/Code_Konami)\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",
+ "
\n",
+ "
Fig 1. - Carré d'ordre 4
\n",
+ "
16
3
2
13
\n",
+ "
5
10
11
8
\n",
+ "
9
6
7
12
\n",
+ "
4
15
14
1
\n",
+ "
\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",
+ "
\n",
+ "
Fig 1.1 - Carré magique avec sa constante égale à 34
\n",
+ "
16
3
2
13
→34
\n",
+ "
5
10
11
8
→34
\n",
+ "
9
6
7
12
→34
\n",
+ "
4
15
14
1
→34
\n",
+ "
↙ 34
↓ 34
↓ 34
↓ 34
↓ 34
↘ 34
\n",
+ "
\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",
+ "
\n",
+ "
Fig.2.1 - Carré magique de lettres d'ordre 3
\n",
+ "
T
E
L
\n",
+ "
E
T
E
\n",
+ "
L
E
S
\n",
+ "
\n",
+ "\n",
+ "
\n",
+ "
Fig.2.2 - Carré magique de lettres d'ordre 5
\n",
+ "
C
U
L
T
E
\n",
+ "
U
N
I
E
S
\n",
+ "
L
I
O
N
S
\n",
+ "
T
E
N
T
A
\n",
+ "
E
S
S
A
I
\n",
+ "
\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",
+ "
\n",
+ "
Fig.3 - Dessin d'une maison
\n",
+ "
⚪
⚪
⚪
⚫
⚪
⚪
\n",
+ "
⚪
⚪
⚫
⚪
⚫
⚪
\n",
+ "
⚪
⚫
⚪
⚪
⚪
⚫
\n",
+ "
⚫
⚫
⚫
⚫
⚫
⚫
\n",
+ "
⚫
⚪
⚫
⚪
⚪
⚫
\n",
+ "
⚫
⚫
⚫
⚫
⚫
⚫
\n",
+ "
\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",
+ "
\n",
+ "
Fig.3.1 - Effet miroir vertical de la Fig.4
\n",
+ "
⚪
⚪
⚫
⚪
⚪
⚪
\n",
+ "
⚪
⚫
⚪
⚫
⚪
⚪
\n",
+ "
⚫
⚪
⚪
⚪
⚫
⚪
\n",
+ "
⚫
⚫
⚫
⚫
⚫
⚫
\n",
+ "
⚫
⚪
⚪
⚫
⚪
⚫
\n",
+ "
⚫
⚫
⚫
⚫
⚫
⚫
\n",
+ "
"
+ ]
+ },
+ {
+ "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",
+ "
\n",
+ "
Fig.3.2 - Effet miroir horizontal de la Fig.4
\n",
+ "
⚫
⚫
⚫
⚫
⚫
⚫
\n",
+ "
⚫
⚪
⚫
⚪
⚪
⚫
\n",
+ "
⚫
⚫
⚫
⚫
⚫
⚫
\n",
+ "
⚪
⚫
⚪
⚪
⚪
⚫
\n",
+ "
⚪
⚪
⚫
⚪
⚫
⚪
\n",
+ "
⚪
⚪
⚪
⚫
⚪
⚪
\n",
+ "
"
+ ]
+ },
+ {
+ "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",
+ "
\n",
+ "
Fig.3.3 - Roration horaire de la Fig.4
\n",
+ "
⚫
⚫
⚫
⚪
⚪
⚪
\n",
+ "
⚫
⚪
⚫
⚫
⚪
⚪
\n",
+ "
⚫
⚫
⚫
⚪
⚫
⚪
\n",
+ "
⚫
⚪
⚫
⚪
⚪
⚫
\n",
+ "
⚫
⚪
⚫
⚪
⚫
⚪
\n",
+ "
⚫
⚫
⚫
⚫
⚪
⚪
\n",
+ "
"
+ ]
+ },
+ {
+ "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",
+ "
+
+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.
+
+
| Le drapeau est de dimension $ 15 \times 7$ |
+| Pays-Bas |
| Le drapeau est de dimension $ 15 \times 6$ |
+| Suède | 
| Le drapeau est de dimension $ 15 \times 7$ |
+| Finlande | 
| Le drapeau est de dimension $ 15 \times 7$ |
+| Irlande | 
| Le drapeau est de dimension $ 15 \times 7$ |
+| Côte d'Ivoire |
| Vous devez utiliser la fonction de création du drapeau d'Irlande. |
+| Bénin | 
| Le drapeau est de dimension $ 15 \times 6$ |
+| Suisse | 
| Le drapeau est de dimension $ 15 \times 7$ |
+| Guinée | 
| Le drapeau est de dimension $ 15 \times 7$ |
+| Mali |
| Vous devez utiliser la fonction de création du drapeau de Guinée. |
+| Botswana | 
| Le drapeau est de dimension $ 15 \times 7$ |
+| Monaco | 
| Le drapeau est de dimension $ 15 \times 6$ |
+| Pologne | 
| Vous devez utiliser la fonction de création du drapeau de Monaco. |
+| Japon | 
| Le drapeau est de dimension $ 15 \times 7$ |
+| Hongrie | 
| Le drapeau est de dimension $ 15 \times 7$ |
+| Iran | 
| Vous devez utiliser la fonction de création du drapeau de Hongrie. |
+| Palaos | 
| Le drapeau est de dimension $ 15 \times 7$ |
+| Grèce |
| Le drapeau est de dimension $ 15 \times 6$ |
+| Etats-Unis |
| Le drapeau est de dimension $ 15 \times 6$ |
+| République du Congo | 
| Le drapeau est de dimension $ 15 \times 7$ |
+| Trinidad et Tobago |
| Le drapeau est de dimension $ 15 \times 7$ |
+| Jamaique |
| Le drapeau est de dimension $ 15 \times 7$ |
diff --git a/representation_construits/chapitre_1/tp/assets/belgique.png b/representation_construits/chapitre_1/tp/assets/belgique.png
new file mode 100644
index 0000000..6591087
Binary files /dev/null and b/representation_construits/chapitre_1/tp/assets/belgique.png differ
diff --git a/representation_construits/chapitre_1/tp/assets/benin.png b/representation_construits/chapitre_1/tp/assets/benin.png
new file mode 100644
index 0000000..3ae5142
Binary files /dev/null and b/representation_construits/chapitre_1/tp/assets/benin.png differ
diff --git a/representation_construits/chapitre_1/tp/assets/botswana.png b/representation_construits/chapitre_1/tp/assets/botswana.png
new file mode 100644
index 0000000..94c3b43
Binary files /dev/null and b/representation_construits/chapitre_1/tp/assets/botswana.png differ
diff --git a/representation_construits/chapitre_1/tp/assets/cote_ivoire.png b/representation_construits/chapitre_1/tp/assets/cote_ivoire.png
new file mode 100644
index 0000000..a23b0d4
Binary files /dev/null and b/representation_construits/chapitre_1/tp/assets/cote_ivoire.png differ
diff --git a/representation_construits/chapitre_1/tp/assets/etats_unis.png b/representation_construits/chapitre_1/tp/assets/etats_unis.png
new file mode 100644
index 0000000..a9a13f9
Binary files /dev/null and b/representation_construits/chapitre_1/tp/assets/etats_unis.png differ
diff --git a/representation_construits/chapitre_1/tp/assets/finlande.png b/representation_construits/chapitre_1/tp/assets/finlande.png
new file mode 100644
index 0000000..ffe1b4d
Binary files /dev/null and b/representation_construits/chapitre_1/tp/assets/finlande.png differ
diff --git a/representation_construits/chapitre_1/tp/assets/france.png b/representation_construits/chapitre_1/tp/assets/france.png
new file mode 100644
index 0000000..a49531a
Binary files /dev/null and b/representation_construits/chapitre_1/tp/assets/france.png differ
diff --git a/representation_construits/chapitre_1/tp/assets/grece.png b/representation_construits/chapitre_1/tp/assets/grece.png
new file mode 100644
index 0000000..7a9caf8
Binary files /dev/null and b/representation_construits/chapitre_1/tp/assets/grece.png differ
diff --git a/representation_construits/chapitre_1/tp/assets/guinee.png b/representation_construits/chapitre_1/tp/assets/guinee.png
new file mode 100644
index 0000000..aa93747
Binary files /dev/null and b/representation_construits/chapitre_1/tp/assets/guinee.png differ
diff --git a/representation_construits/chapitre_1/tp/assets/hongrie.png b/representation_construits/chapitre_1/tp/assets/hongrie.png
new file mode 100644
index 0000000..f064146
Binary files /dev/null and b/representation_construits/chapitre_1/tp/assets/hongrie.png differ
diff --git a/representation_construits/chapitre_1/tp/assets/iran.png b/representation_construits/chapitre_1/tp/assets/iran.png
new file mode 100644
index 0000000..6f7e749
Binary files /dev/null and b/representation_construits/chapitre_1/tp/assets/iran.png differ
diff --git a/representation_construits/chapitre_1/tp/assets/irlande.png b/representation_construits/chapitre_1/tp/assets/irlande.png
new file mode 100644
index 0000000..d67916c
Binary files /dev/null and b/representation_construits/chapitre_1/tp/assets/irlande.png differ
diff --git a/representation_construits/chapitre_1/tp/assets/jamaique.png b/representation_construits/chapitre_1/tp/assets/jamaique.png
new file mode 100644
index 0000000..1b95070
Binary files /dev/null and b/representation_construits/chapitre_1/tp/assets/jamaique.png differ
diff --git a/representation_construits/chapitre_1/tp/assets/japon.png b/representation_construits/chapitre_1/tp/assets/japon.png
new file mode 100644
index 0000000..563b156
Binary files /dev/null and b/representation_construits/chapitre_1/tp/assets/japon.png differ
diff --git a/representation_construits/chapitre_1/tp/assets/mali.png b/representation_construits/chapitre_1/tp/assets/mali.png
new file mode 100644
index 0000000..9c4335f
Binary files /dev/null and b/representation_construits/chapitre_1/tp/assets/mali.png differ
diff --git a/representation_construits/chapitre_1/tp/assets/monaco.png b/representation_construits/chapitre_1/tp/assets/monaco.png
new file mode 100644
index 0000000..01c1794
Binary files /dev/null and b/representation_construits/chapitre_1/tp/assets/monaco.png differ
diff --git a/representation_construits/chapitre_1/tp/assets/palaos.png b/representation_construits/chapitre_1/tp/assets/palaos.png
new file mode 100644
index 0000000..34f73d6
Binary files /dev/null and b/representation_construits/chapitre_1/tp/assets/palaos.png differ
diff --git a/representation_construits/chapitre_1/tp/assets/pays_bas.png b/representation_construits/chapitre_1/tp/assets/pays_bas.png
new file mode 100644
index 0000000..1d3e1e2
Binary files /dev/null and b/representation_construits/chapitre_1/tp/assets/pays_bas.png differ
diff --git a/representation_construits/chapitre_1/tp/assets/pologne.png b/representation_construits/chapitre_1/tp/assets/pologne.png
new file mode 100644
index 0000000..295eed8
Binary files /dev/null and b/representation_construits/chapitre_1/tp/assets/pologne.png differ
diff --git a/representation_construits/chapitre_1/tp/assets/republique_congo.png b/representation_construits/chapitre_1/tp/assets/republique_congo.png
new file mode 100644
index 0000000..5e45e6e
Binary files /dev/null and b/representation_construits/chapitre_1/tp/assets/republique_congo.png differ
diff --git a/representation_construits/chapitre_1/tp/assets/suede.png b/representation_construits/chapitre_1/tp/assets/suede.png
new file mode 100644
index 0000000..7f65489
Binary files /dev/null and b/representation_construits/chapitre_1/tp/assets/suede.png differ
diff --git a/representation_construits/chapitre_1/tp/assets/suisse.png b/representation_construits/chapitre_1/tp/assets/suisse.png
new file mode 100644
index 0000000..d6e318b
Binary files /dev/null and b/representation_construits/chapitre_1/tp/assets/suisse.png differ
diff --git a/representation_construits/chapitre_1/tp/assets/trinidad.png b/representation_construits/chapitre_1/tp/assets/trinidad.png
new file mode 100644
index 0000000..3bde60d
Binary files /dev/null and b/representation_construits/chapitre_1/tp/assets/trinidad.png differ
diff --git a/representation_construits/chapitre_1/tp/assets/utilisation_paint.png b/representation_construits/chapitre_1/tp/assets/utilisation_paint.png
new file mode 100644
index 0000000..5b0037e
Binary files /dev/null and b/representation_construits/chapitre_1/tp/assets/utilisation_paint.png differ
diff --git a/representation_construits/chapitre_1/tp/correction.py b/representation_construits/chapitre_1/tp/correction.py
new file mode 100644
index 0000000..64f612f
--- /dev/null
+++ b/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())}')
diff --git a/representation_construits/chapitre_1/tp/paint.py b/representation_construits/chapitre_1/tp/paint.py
new file mode 100644
index 0000000..c8054d1
--- /dev/null
+++ b/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('')
\ No newline at end of file
diff --git a/representation_construits/chapitre_2/.ipynb_checkpoints/README-checkpoint.ipynb b/representation_construits/chapitre_2/.ipynb_checkpoints/README-checkpoint.ipynb
new file mode 100644
index 0000000..68de91c
--- /dev/null
+++ b/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": [
+ ""
+ ]
+ },
+ {
+ "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