ajout representation construits
This commit is contained in:
@@ -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
|
||||
}
|
||||
682
representation_construits/chapitre_1/README.ipynb
Normal file
682
representation_construits/chapitre_1/README.ipynb
Normal file
@@ -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
|
||||
}
|
||||
261
representation_construits/chapitre_1/README.md
Normal file
261
representation_construits/chapitre_1/README.md
Normal file
@@ -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 |
|
||||
40
representation_construits/chapitre_1/TABLEAUX.md
Normal file
40
representation_construits/chapitre_1/TABLEAUX.md
Normal file
@@ -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" ?
|
||||
|
||||
139
representation_construits/chapitre_1/projet/README.md
Normal file
139
representation_construits/chapitre_1/projet/README.md
Normal file
@@ -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.<br />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.<br />La règle qui le justifie : Toutes les règles ne sont pas satisfaites, c'est le dernier sinon qui s'applique. |
|
||||
|
||||
## 3. Consignes
|
||||
|
||||
Vous devez créer un module `desamorceur` qui va permettre de :
|
||||
|
||||
- créer une combinaison aléatoire de couleur pour $`n`$ fils,
|
||||
- créer une bombe de $`n`$ fils,
|
||||
- afficher une bombe,
|
||||
- créer un numéro de série sur 8 chiffres,
|
||||
- déterminer si le fil choisi désarme la bombe ou non,
|
||||
- ... ainsi que d'autres fonctions nécessaires à l'implantation du jeu (Cf. Partie "Petit manuel du désamorceur de bombes").
|
||||
|
||||
L'algorithme principal est le suivant :
|
||||
```python
|
||||
bombe = creer_bombe(creer_combinaison(combinaison))
|
||||
numero_serie = creer_numero_serie()
|
||||
|
||||
print(f"n°{numero_serie}")
|
||||
|
||||
afficher_bombe(bombe)
|
||||
|
||||
indice = input('Indice du fils à couper : ')
|
||||
|
||||
if est_bon_fil_a_couper(bombe, int(indice), numero_serie):
|
||||
print('Sauvé !!!')
|
||||
else:
|
||||
print('Perdu, la bombe a explosé')
|
||||
```
|
||||
***N.B : Vous devez, pour chaque fonction y adjoindre les docstrings et doctests nécessaires***
|
||||
|
||||
Le module sera exécutable de la manière suivante :
|
||||
|
||||
> python3 desamorceur.py 4
|
||||
|
||||
où le 2ème paramètres correspond au nombre de fils de la bombe
|
||||
|
||||
## 4. Matériel fourni
|
||||
|
||||
Le module `paint` dispose de :
|
||||
|
||||
- 5 variables : `ROUGE, VERT, JAUNE, BLEU, BLANC`, qui permettent de matérialiser les couleurs des fils,
|
||||
- d'une méthode `dessiner` qui permet d'afficher une matrice passée en paramètre.
|
||||
|
||||
<figure>
|
||||
<center><img src='./assets/utilisation_paint.png'/></center>
|
||||
<figcaption style='text-align:center;'>Fig 2. Exemple d'utilisation du module paint</figcaption>
|
||||
</figure>
|
||||
|
||||
## 5. Rendu
|
||||
|
||||
- un script `desamorceur.py`,
|
||||
- un fichier `README.md` qui présente vos choix de structures de données, les autres fonctions implantées..., ainsi qu'un extrait de codes ou le decriptif d'un problème rencontré et la solution mise en place.
|
||||
|
||||
## 6. Annexe - Petit manuel du désamorceur de bombes
|
||||
|
||||
Voici les règles pour désamorcer la bombe :
|
||||
|
||||
__3 fils__ :
|
||||
|
||||
S'il n'y a pas de fil rouge, couper le deuxième fil.
|
||||
|
||||
Sinon, si le dernier fil est blanc, couper le dernier fil.
|
||||
|
||||
Sinon, s'il y a plus d'un fil bleu, couper le dernier fil bleu.
|
||||
|
||||
Sinon, couper le dernier fil.
|
||||
|
||||
__4 fils__ :
|
||||
|
||||
S'il y a plus d'un fil rouge et si le dernier chiffre du numéro de série est impair, couper le dernier fil rouge.
|
||||
|
||||
Sinon, si le dernier fil est jaune et s'il n'y a pas de fil rouge, couper le premier fil.
|
||||
|
||||
Sinon, s'il y a exactement un fil bleu, couper le premier fil.
|
||||
|
||||
Sinon, s'il y a plus d'un fil jaune, couper le dernier fil.
|
||||
|
||||
Sinon, couper le deuxième fil.
|
||||
|
||||
__5 fils__ :
|
||||
|
||||
Si le dernier fil est vert et si le dernier chiffre du numéro de série est impair, couper le quatrième fil.
|
||||
|
||||
Sinon, s'il y a exactement un fil rouge et plus d'un fil jaune, couper le premier fil.
|
||||
|
||||
Sinon, s'il n'y a pas de fil vert, couper le deuxième fil.
|
||||
|
||||
Sinon, couper le premier fil.
|
||||
|
||||
__6 fils__ :
|
||||
|
||||
S'il n'y a pas de fil jaune et si le dernier chiffre du numéro de série est impair, couper le troisième fil.
|
||||
|
||||
Sinon, s'il y a exactement un fil jaune et plus d'un fil blanc, couper le quatrième fil.
|
||||
|
||||
Sinon, s'il n'y a pas de fil rouge, couper le dernier fil.
|
||||
|
||||
Sinon, couper le quatrième fil.
|
||||
|
||||
## 7. Pour aller plus loin
|
||||
|
||||
Dans le cas où les éléments du projet sont finalisés, vous pouvez le compléter avec les éléments suivants :
|
||||
- En cas d'explosion de la bombe, afficher à l'utilisateur l'indice du fil qu'il fallait couper pour désarmer la bombe,
|
||||
- Mettre en place un numéro de série alphanumérique, qui comporte au moins 1 chiffre qui n'est pas forcément en dernière position,
|
||||
- Doter le projet d'une interface graphique, via le module `pygame`.
|
||||
BIN
representation_construits/chapitre_1/projet/assets/bomb.png
Normal file
BIN
representation_construits/chapitre_1/projet/assets/bomb.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 21 KiB |
BIN
representation_construits/chapitre_1/projet/assets/exemple_1.png
Normal file
BIN
representation_construits/chapitre_1/projet/assets/exemple_1.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 12 KiB |
BIN
representation_construits/chapitre_1/projet/assets/exemple_2.png
Normal file
BIN
representation_construits/chapitre_1/projet/assets/exemple_2.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 14 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 18 KiB |
161
representation_construits/chapitre_1/projet/correction.py
Normal file
161
representation_construits/chapitre_1/projet/correction.py
Normal file
@@ -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é')
|
||||
44
representation_construits/chapitre_1/projet/paint.py
Normal file
44
representation_construits/chapitre_1/projet/paint.py
Normal file
@@ -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('')
|
||||
572
representation_construits/chapitre_1/td/TD.ipynb
Normal file
572
representation_construits/chapitre_1/td/TD.ipynb
Normal file
@@ -0,0 +1,572 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# TD : Les Tableaux\n",
|
||||
"\n",
|
||||
"Ce TD va nous permettre de manipuler les tableaux en Python."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 1. Rappel\n",
|
||||
"\n",
|
||||
"Pour créer un tableau en python, la syntaxe est la suivante :\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
">>> tableau = []\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"Pour ajouter un élément à un tableau, on utilise la méthode `append` :\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
">>> tableau.append('NSI')\n",
|
||||
">>> tableau.append('ANGLAIS')\n",
|
||||
">>> tableau\n",
|
||||
"['NSI', 'ANGLAIS']\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"Pour accéder à un élément, on utilise son **indice** :\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
">>> tableau[0]\n",
|
||||
"'NSI'\n",
|
||||
">>> tableau[1]\n",
|
||||
"'ANGLAIS'\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"Il est également possible de créer un tableau avec un ensemble d'éléments :\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
">>> tableau = ['NSI', 'ANGLAIS', 'PHYSIQUE']\n",
|
||||
">>> tableau\n",
|
||||
"['NSI', 'ANGLAIS', 'PHYSIQUE']\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"Il est possible d'obtenir la taille du tableau, i.e le nombre d'éléments grâce à la méthode `len` :\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
">>> len(tableau)\n",
|
||||
"3\n",
|
||||
"```"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 2. Exercices"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 1 : Création de tableaux\n",
|
||||
"\n",
|
||||
"1. Créer un tableau contenant l'ensemble des noms des personnes dans la salle de TP\n",
|
||||
"2. Créer un tableau contenant l'ensemble des entiers pairs entre 0 et 20 inclus,\n",
|
||||
"3. Afficher uniquement les entiers du tableau, construit à la question 2, qui sont multiples de 4.\n",
|
||||
"4. Créer une fonction `aleatoire` qui renvoie un tableau de valeurs aléatoires. Elle prend 3 entiers en paramètre :\n",
|
||||
" - $n$ : le nombre d'éléments du tableau\n",
|
||||
" - $min$ : la valeur minimale possible\n",
|
||||
" - $max$ : la valeur maximale possible"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 1"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 2"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 3"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 4"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 2 : Parcours et Recherche\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
">>> groupe_1 = ['Alan', 'Brice', 'Chloé', 'Damien', 'Eléonore', 'Farid']\n",
|
||||
">>> groupe_2 = ['Damien', 'Killian', 'Margot', 'Tom', 'Hugo', 'Killian']\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"1. Écrire une fonction `indice` qui prend en paramètre un tableau de noms et un nom et permet d'obtenir l'indice du nom dans le tableau.\n",
|
||||
"2. Écrire une fonction `est_present` qui prend en paramètre un tableau et un nom et renvoie True si le nom est présent dans le tableau, False sinon.\n",
|
||||
"3. Écrire une fonction `indices` qui prend en paramètre un tableau de noms et un nom et permet d'obtenir l'ensemble des indices du nom dans le tableau.\n",
|
||||
"4. Écrire une fonction `compte` qui prend en paramètre un tableau de noms et un nom et permet d'obtenir le nombre d'occurrences du nom dans le tableau."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 1"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 2"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 3"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 4"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 3 : Agrégation\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
">>> notes = [14.5, 13, 7, 10.25, 16, 12.5, 9.5]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"1. Écrire une fonction `somme` qui prend en paramètre un tableau de flottants et renvoie la somme des valeurs du tableau.\n",
|
||||
"2. Écrire une fonction `moyenne` qui prend en paramètre un tableau de flottants et renvoie la valeur moyenne du tableau.\n",
|
||||
"3. Écrire une fonction `maximum` qui prend en paramètre un tableau de flottants et renvoie la valeur maximale du tableau. "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 1"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 2"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 3"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 4 : Manipulations sur les tableaux\n",
|
||||
"\n",
|
||||
"Pour tester les fonctions de manipulations, nous utiliserons le Code Konami<sup>[wikipédia](https://fr.wikipedia.org/wiki/Code_Konami)</sup>\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
">>> code = [\"↑\", \"↑\", \"↓\",\"↓\", \"←\", \"→\", \"←\", \"→\", \"B\", \"A\"]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"1. Écrire une méthode `inverser` qui prend en paramètre un tableau et a pour effet de bord d'inverser l'ensemble des valeurs du tableau.\n",
|
||||
"2. Écrire une fonction `copie` qui prend en paramètre un tableau et renvoie une copie du tableau.\n",
|
||||
"3. Écrire une méthode `dedoublonner` qui prend en paramètre un tableau et a pour effet de bord de supprimer les doublons d'une même valeur. \n",
|
||||
"4. Écrire une fonction `tranche` qui prend en paramètre un tableau et deux entiers $min$ et $max$, et renvoie le sous-tableau entre $min$ et $max$."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 1"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 2"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 3"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 4"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 5 : Matrice\n",
|
||||
"\n",
|
||||
"1. Écrire une fonction `ligne` qui prend en paramètre une matrice et un indice de ligne en entrées et renvoie un tableau avec l'ensemble des valeurs de la ligne.\n",
|
||||
"2. Écrire une fonction `colonne` qui prend en paramètre une matrice et un indice de colonne en entrées et renvoie un tableau avec l'ensemble des valeurs de la colonne.\n",
|
||||
"3. Écrire une fonction `diagonale_nord_ouest` qui prend en paramètre une matrice et renvoie un tableau avec l'ensemble des valeurs de la diagonale. La première valeur est celle à l'indice \\[0]\\[0] et la dernière celle correspondant à l'indice \\[len(matrice) - 1]\\[len(matrice) - 1].\n",
|
||||
"4. Écrire une fonction `diagonale_nord_est` qui prend en paramètre une matrice et renvoie un tableau avec l'ensemble des valeurs de la diagonale. La première valeur est celle à l'indice \\[0]\\[len(matrice) - 1] et la dernière celle correspondant à l'indice \\[len(matrice) - 1]\\[0]."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 1"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 2"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 3"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 4"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"#### Application - Carré magique\n",
|
||||
"\n",
|
||||
"<table style=\"margin : 0 auto 0 auto; width:100px;text-align:center;\">\n",
|
||||
"<caption style=\"caption-side:bottom;\">Fig 1. - Carré d'ordre 4</caption>\n",
|
||||
"<tr style=\"border:none;\"><td>16</td><td>3</td><td>2</td><td>13</td></tr>\n",
|
||||
"<tr style=\"border:none;\"><td>5</td><td>10</td><td>11</td><td>8</td></tr>\n",
|
||||
"<tr style=\"border:none;\"><td>9</td><td>6</td><td>7</td><td>12</td></tr>\n",
|
||||
"<tr style=\"border:none;\"><td>4</td><td>15</td><td>14</td><td>1</td></tr>\n",
|
||||
"</table>\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"En mathématiques, un ***carré magique*** d’ordre $n$ est composé de $n^2$ entiers strictement positifs, écrits sous la forme d’un tableau carré. Ces nombres sont disposés de sorte que leurs sommes sur chaque rangée, sur chaque colonne et sur chaque diagonale principale soient égales. On nomme alors ***constante magique*** la valeur de ces sommes.\n",
|
||||
"\n",
|
||||
"<table style=\"margin : 0 auto 0 auto; width:100px;text-align:center;\">\n",
|
||||
" <caption style=\"caption-side:bottom;\">Fig 1.1 - Carré magique avec sa constante égale à 34</caption>\n",
|
||||
"<tr style=\"border:none;\"><th style=\"border : none;\"></th><td>16</td><td>3</td><td>2</td><td>13</td><th style=\"border : none;padding-left:.5em;\">→34</th></tr>\n",
|
||||
"<tr style=\"border:none;\"><th style=\"border : none;\"></th><td>5</td><td>10</td><td>11</td><td>8</td><th style=\"border : none;padding-left:.5em;\">→34</th></tr>\n",
|
||||
"<tr style=\"border:none;\"><th style=\"border : none;\"></th><td>9</td><td>6</td><td>7</td><td>12</td><th style=\"border : none;padding-left:.5em;\">→34</th></tr>\n",
|
||||
"<tr style=\"border:none;\"><th style=\"border : none;\"></th><td>4</td><td>15</td><td>14</td><td>1</td><th style=\"border : none;padding-left:.5em;\">→34</th></tr>\n",
|
||||
"<tr style=\"border:none;\"><th style=\"border : none;\">↙ 34</th><th style=\"border:none;\">↓ 34</th><th style=\"border:none;\">↓ 34</th><th style=\"border:none;\">↓ 34</th><th style=\"border:none;\">↓ 34</th><th style=\"border:none;\">↘ 34</th></tr>\n",
|
||||
"</table>\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"> Écrire un prédicat `est_magique` qui prend une matrice d'entiers en paramètre et indique si le carré est magique ou non."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"#### Carré magique de lettres\n",
|
||||
"\n",
|
||||
"Un ***carré magique de lettres***, également appelé « ***mots carrés*** », est une forme de mots croisés disposé en carré, ne comportant pas de case noire et constitué de mots valides dans une langue définie. Ils peuvent, par définition, être lus horizontalement et verticalement et présentent dans ces deux sens les mêmes mots.\n",
|
||||
"\n",
|
||||
"<table style=\"margin : 0 auto 0 auto; width : 100px;text-align:center;\">\n",
|
||||
" <caption style=\"caption-side:bottom;\">Fig.2.1 - Carré magique de lettres d'ordre 3</caption>\n",
|
||||
"<tr><td>T</td><td>E</td><td>L</td></tr>\n",
|
||||
"<tr><td>E</td><td>T</td><td>E</td></tr>\n",
|
||||
"<tr><td>L</td><td>E</td><td>S</td></tr>\n",
|
||||
"</table>\n",
|
||||
"\n",
|
||||
"<table style=\"margin : 0 auto 0 auto; width : 100px;text-align:center;\">\n",
|
||||
" <caption style=\"caption-side:bottom;\">Fig.2.2 - Carré magique de lettres d'ordre 5</caption>\n",
|
||||
"<tr><td>C</td><td>U</td><td>L</td><td>T</td><td>E</td></tr>\n",
|
||||
"<tr><td>U</td><td>N</td><td>I</td><td>E</td><td>S</td></tr>\n",
|
||||
"<tr><td>L</td><td>I</td><td>O</td><td>N</td><td>S</td></tr>\n",
|
||||
"<tr><td>T</td><td>E</td><td>N</td><td>T</td><td>A</td></tr>\n",
|
||||
"<tr><td>E</td><td>S</td><td>S</td><td>A</td><td>I</td></tr>\n",
|
||||
"</table>\n",
|
||||
"\n",
|
||||
"> Écrire un prédicat `est_magique_lettres` qui prend une matrice de caractères en paramètre et indique si le carré est magique de lettres ou non."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"#### Application - Pour aller plus loin\n",
|
||||
"\n",
|
||||
"<table style=\"margin : 0 auto 0 auto; width : 100px;text-align:center;\">\n",
|
||||
" <caption style=\"caption-side:bottom;\">Fig.3 - Dessin d'une maison</caption>\n",
|
||||
"<tr><td>⚪</td><td>⚪</td><td>⚪</td><td>⚫</td><td>⚪</td><td>⚪</td></tr>\n",
|
||||
"<tr><td>⚪</td><td>⚪</td><td>⚫</td><td>⚪</td><td>⚫</td><td>⚪</td></tr>\n",
|
||||
"<tr><td>⚪</td><td>⚫</td><td>⚪</td><td>⚪</td><td>⚪</td><td>⚫</td></tr>\n",
|
||||
"<tr><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td></tr>\n",
|
||||
"<tr><td>⚫</td><td>⚪</td><td>⚫</td><td>⚪</td><td>⚪</td><td>⚫</td></tr>\n",
|
||||
"<tr><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td></tr>\n",
|
||||
"</table>\n",
|
||||
"\n",
|
||||
"Déclaration de la matrice correspondante à la Fig.1 :\n",
|
||||
"```python\n",
|
||||
"matrice = [\n",
|
||||
" ['⚪', '⚪', '⚪', '⚫', '⚪', '⚪'],\n",
|
||||
" ['⚪', '⚪', '⚫', '⚪', '⚫', '⚪'],\n",
|
||||
" ['⚪', '⚫', '⚪', '⚪', '⚪', '⚫'],\n",
|
||||
" ['⚫', '⚫', '⚫', '⚫', '⚫', '⚫'],\n",
|
||||
" ['⚫', '⚪', '⚫', '⚪', '⚪', '⚫'],\n",
|
||||
" ['⚫', '⚫', '⚫', '⚫', '⚫', '⚫']\n",
|
||||
"]\n",
|
||||
"```"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"1. Écrire une méthode `miroir_vertical` qui prend en paramètre une matrice et a pour effet de bord de réaliser l'effet miroir vertical sur les valeurs de la matrice.\n",
|
||||
"\n",
|
||||
"<table style=\"margin : 0 auto 0 auto; width : 100px;text-align:center;\">\n",
|
||||
" <caption style=\"caption-side:bottom;\">Fig.3.1 - Effet miroir vertical de la Fig.4</caption>\n",
|
||||
"<tr><td>⚪</td><td>⚪</td><td>⚫</td><td>⚪</td><td>⚪</td><td>⚪</td></tr>\n",
|
||||
"<tr><td>⚪</td><td>⚫</td><td>⚪</td><td>⚫</td><td>⚪</td><td>⚪</td></tr>\n",
|
||||
"<tr><td>⚫</td><td>⚪</td><td>⚪</td><td>⚪</td><td>⚫</td><td>⚪</td></tr>\n",
|
||||
"<tr><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td></tr>\n",
|
||||
"<tr><td>⚫</td><td>⚪</td><td>⚪</td><td>⚫</td><td>⚪</td><td>⚫</td></tr>\n",
|
||||
"<tr><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td></tr>\n",
|
||||
"</table>"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 1"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"2. Écrire une méthode `miroir_horizontal` qui prend en paramètre une matrice et a pour effet de bord de réaliser l'effet miroir horizontal sur les valeurs de la matrice.\n",
|
||||
"\n",
|
||||
"<table style=\"margin : 0 auto 0 auto; width : 100px;text-align:center;\">\n",
|
||||
" <caption style=\"caption-side:bottom;\">Fig.3.2 - Effet miroir horizontal de la Fig.4</caption>\n",
|
||||
"<tr><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td></tr>\n",
|
||||
"<tr><td>⚫</td><td>⚪</td><td>⚫</td><td>⚪</td><td>⚪</td><td>⚫</td></tr>\n",
|
||||
"<tr><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td></tr>\n",
|
||||
"<tr><td>⚪</td><td>⚫</td><td>⚪</td><td>⚪</td><td>⚪</td><td>⚫</td></tr>\n",
|
||||
"<tr><td>⚪</td><td>⚪</td><td>⚫</td><td>⚪</td><td>⚫</td><td>⚪</td></tr>\n",
|
||||
"<tr><td>⚪</td><td>⚪</td><td>⚪</td><td>⚫</td><td>⚪</td><td>⚪</td></tr>\n",
|
||||
"</table>"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 2"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"3. Écrire une fonction `rotation_horaire` qui prend en paramètre une matrice et renvoie une matrice dont les valeurs correspondent à la rotation dans le sens horaire des valeurs de la matrice.\n",
|
||||
"\n",
|
||||
"<table style=\"margin : 0 auto 0 auto; width : 100px;text-align:center;\">\n",
|
||||
" <caption style=\"caption-side:bottom;\">Fig.3.3 - Roration horaire de la Fig.4</caption>\n",
|
||||
"<tr><td>⚫</td><td>⚫</td><td>⚫</td><td>⚪</td><td>⚪</td><td>⚪</td></tr>\n",
|
||||
"<tr><td>⚫</td><td>⚪</td><td>⚫</td><td>⚫</td><td>⚪</td><td>⚪</td></tr>\n",
|
||||
"<tr><td>⚫</td><td>⚫</td><td>⚫</td><td>⚪</td><td>⚫</td><td>⚪</td></tr>\n",
|
||||
"<tr><td>⚫</td><td>⚪</td><td>⚫</td><td>⚪</td><td>⚪</td><td>⚫</td></tr>\n",
|
||||
"<tr><td>⚫</td><td>⚪</td><td>⚫</td><td>⚪</td><td>⚫</td><td>⚪</td></tr>\n",
|
||||
"<tr><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td><td>⚪</td><td>⚪</td></tr>\n",
|
||||
"</table>"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 3"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"4. Écrire une fonction `rotation_anti_horaire` qui prend en paramètre une matrice et renvoie une matrice dont les valeurs correspondent à la rotation dans le sens anti-horaire des valeurs de la matrice.\n",
|
||||
"\n",
|
||||
"<table style=\"margin : 0 auto 0 auto; width : 100px;text-align:center;\">\n",
|
||||
" <caption style=\"caption-side:bottom;\">Fig.3.4 - Roration anti-horaire de la Fig.4</caption>\n",
|
||||
"<tr><td>⚪</td><td>⚪</td><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td></tr>\n",
|
||||
"<tr><td>⚪</td><td>⚫</td><td>⚪</td><td>⚫</td><td>⚪</td><td>⚫</td></tr>\n",
|
||||
"<tr><td>⚫</td><td>⚪</td><td>⚪</td><td>⚫</td><td>⚪</td><td>⚫</td></tr>\n",
|
||||
"<tr><td>⚪</td><td>⚫</td><td>⚪</td><td>⚫</td><td>⚫</td><td>⚫</td></tr>\n",
|
||||
"<tr><td>⚪</td><td>⚪</td><td>⚫</td><td>⚫</td><td>⚪</td><td>⚫</td></tr>\n",
|
||||
"<tr><td>⚪</td><td>⚪</td><td>⚪</td><td>⚫</td><td>⚫</td><td>⚫</td></tr>\n",
|
||||
"</table>"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 4"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Pour valider vos fonctions, vous pouvez réaliser sur papier les opérations miroir et de rotation sur la Fig.4 et vérifier que les résultats obtenus sont conformes.\n",
|
||||
"\n",
|
||||
"<table style=\"margin : 0 auto 0 auto; width : 100px;text-align:center;\">\n",
|
||||
" <caption style=\"caption-side:bottom;\">Fig.4 - Dessin d'un bateau avec une mouette</caption>\n",
|
||||
"<tr><td>⚪</td><td>⚪</td><td>⚫</td><td>⚪</td><td>⚪</td><td>⚪</td><td>⚪</td></tr>\n",
|
||||
"<tr><td>⚪</td><td>⚫</td><td>⚫</td><td>⚪</td><td>⚫</td><td>⚪</td><td>⚫</td></tr>\n",
|
||||
"<tr><td>⚫</td><td>⚪</td><td>⚫</td><td>⚪</td><td>⚪</td><td>⚫</td><td>⚪</td></tr>\n",
|
||||
"<tr><td>⚪</td><td>⚫</td><td>⚫</td><td>⚪</td><td>⚪</td><td>⚪</td><td>⚪</td></tr>\n",
|
||||
"<tr><td>⚪</td><td>⚪</td><td>⚫</td><td>⚪</td><td>⚪</td><td>⚪</td><td>⚪</td></tr>\n",
|
||||
"<tr><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td></tr>\n",
|
||||
"<tr><td>⚫</td><td>⚪</td><td>⚪</td><td>⚪</td><td>⚪</td><td>⚪</td><td>⚫</td></tr>\n",
|
||||
"<tr><td>⚪</td><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td><td>⚪</td></tr>\n",
|
||||
"</table>\n",
|
||||
"\n",
|
||||
"Déclaration de la matrice correspondante à la Fig.4 :\n",
|
||||
"```python\n",
|
||||
"matrice = [\n",
|
||||
" ['⚪', '⚪', '⚫', '⚪', '⚪', '⚪', '⚪'],\n",
|
||||
" ['⚪', '⚫', '⚫', '⚪', '⚫', '⚪', '⚫'],\n",
|
||||
" ['⚫', '⚪', '⚫', '⚪', '⚪', '⚫', '⚪'],\n",
|
||||
" ['⚪', '⚫', '⚫', '⚪', '⚪', '⚪', '⚪'],\n",
|
||||
" ['⚪', '⚪', '⚫', '⚪', '⚪', '⚪', '⚪'],\n",
|
||||
" ['⚫', '⚫', '⚫', '⚫', '⚫', '⚫', '⚫'],\n",
|
||||
" ['⚫', '⚪', '⚪', '⚪', '⚪', '⚪', '⚫'],\n",
|
||||
" ['⚪', '⚫', '⚫', '⚫', '⚫', '⚫', '⚪']\n",
|
||||
"]\n",
|
||||
"```"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"kernelspec": {
|
||||
"display_name": "Python 3",
|
||||
"language": "python",
|
||||
"name": "python3"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": {
|
||||
"name": "ipython",
|
||||
"version": 3
|
||||
},
|
||||
"file_extension": ".py",
|
||||
"mimetype": "text/x-python",
|
||||
"name": "python",
|
||||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.9.7"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 2
|
||||
}
|
||||
940
representation_construits/chapitre_1/td/correction.ipynb
Normal file
940
representation_construits/chapitre_1/td/correction.ipynb
Normal file
@@ -0,0 +1,940 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# TD : Les Tableaux\n",
|
||||
"\n",
|
||||
"Ce TD va nous permettre de manipuler les tableaux en Python."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 1. Rappel\n",
|
||||
"\n",
|
||||
"Pour créer un tableau en python, la syntaxe est la suivante :\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
">>> tableau = []\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"Pour ajouter un élément à un tableau, on utilise la méthode `append` :\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
">>> tableau.append('NSI')\n",
|
||||
">>> tableau.append('ANGLAIS')\n",
|
||||
">>> tableau\n",
|
||||
"['NSI', 'ANGLAIS']\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"Pour accéder à un élément, on utilise son **indice** :\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
">>> tableau[0]\n",
|
||||
"'NSI'\n",
|
||||
">>> tableau[1]\n",
|
||||
"'ANGLAIS'\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"Il est également possible de créer un tableau avec un ensemble d'éléments :\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
">>> tableau = ['NSI', 'ANGLAIS', 'PHYSIQUE']\n",
|
||||
">>> tableau\n",
|
||||
"['NSI', 'ANGLAIS', 'PHYSIQUE']\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"Il est possible d'obtenir la taille du tableau, i.e le nombre d'éléments grâce à la méthode `len` :\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
">>> len(tableau)\n",
|
||||
"3\n",
|
||||
"```"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 2. Exercices"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 1 : Création de tableaux\n",
|
||||
"\n",
|
||||
"1. Créer un tableau contenant l'ensemble des noms des personnes dans la salle de TP\n",
|
||||
"2. Créer un tableau contenant l'ensemble des entiers pairs entre 0 et 20 inclus,\n",
|
||||
"3. Afficher uniquement les entiers du tableau, construit à la question 2, qui sont multiples de 4.\n",
|
||||
"4. Créer une fonction `aleatoire` qui renvoie un tableau de valeurs aléatoires. Elle prend 3 entiers en paramètre :\n",
|
||||
" - $n$ : le nombre d'éléments du tableau\n",
|
||||
" - $min$ : la valeur minimale possible\n",
|
||||
" - $max$ : la valeur maximale possible"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 1\n",
|
||||
"personnes = ['Albert', 'Bertrand', 'Camille']"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 2\n",
|
||||
"pairs = [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20]"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 3\n",
|
||||
"for entier in pairs:\n",
|
||||
" if entier % 4 == 0:\n",
|
||||
" print(entier)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 4\n",
|
||||
"import random\n",
|
||||
"def aleatoire(n, min, max):\n",
|
||||
" tableau = []\n",
|
||||
" for i in range(n):\n",
|
||||
" tableau.append(random.randint(min, max))\n",
|
||||
" return tableau"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 2 : Parcours et Recherche\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
">>> groupe_1 = ['Alan', 'Brice', 'Chloé', 'Damien', 'Eléonore', 'Farid']\n",
|
||||
">>> groupe_2 = ['Damien', 'Killian', 'Margot', 'Tom', 'Hugo', 'Killian']\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"1. Écrire une fonction `indice` qui prend en paramètre un tableau de noms et un nom et permet d'obtenir l'indice du nom dans le tableau.\n",
|
||||
"2. Écrire une fonction `est_present` qui prend en paramètre un tableau et un nom et renvoie True si le nom est présent dans le tableau, False sinon.\n",
|
||||
"3. Écrire une fonction `indices` qui prend en paramètre un tableau de noms et un nom et permet d'obtenir l'ensemble des indices du nom dans le tableau.\n",
|
||||
"4. Écrire une fonction `compte` qui prend en paramètre un tableau de noms et un nom et permet d'obtenir le nombre d'occurrences du nom dans le tableau."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 1\n",
|
||||
"def indice(tableau, element):\n",
|
||||
" '''\n",
|
||||
" Indique l'indice où se situe l'élément dans le tableau\n",
|
||||
" :param tableau: (list) un tableau\n",
|
||||
" :param element: (any) un élément\n",
|
||||
" :return: (int) le premier indice de l'élément dans le tableau, None sinon\n",
|
||||
" :doctest:\n",
|
||||
" >>> indice([0, 1, 2, 3], 1)\n",
|
||||
" 1\n",
|
||||
" >>> indice([], 1) is None\n",
|
||||
" True\n",
|
||||
" >>> indice([3, 2, 0, 1], 1)\n",
|
||||
" 3\n",
|
||||
" >>> indice([3, 2, 1, 1], 1)\n",
|
||||
" 2\n",
|
||||
" '''\n",
|
||||
" i = 0\n",
|
||||
" while i < len(tableau) and tableau[i] != element:\n",
|
||||
" i += 1\n",
|
||||
" if i == len(tableau):\n",
|
||||
" return None\n",
|
||||
" return i"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 2\n",
|
||||
"def est_present(tableau, element):\n",
|
||||
" '''\n",
|
||||
" Indique si l'élément est dans la liste\n",
|
||||
" :param tableau: (list) un tableau\n",
|
||||
" :param element: (any) un élément\n",
|
||||
" :return: (bool) True si l'élément est dans la liste, False sinon\n",
|
||||
" :doctest;\n",
|
||||
" >>> est_present([0, 1, 2, 3], 1)\n",
|
||||
" True\n",
|
||||
" >>> est_present([], 1)\n",
|
||||
" False\n",
|
||||
" >>> est_present(['Belgique', 'Pays-Bas', 'Luxembourg'], 'France')\n",
|
||||
" False\n",
|
||||
" >>> est_present([3, 2, 1, 1], 1)\n",
|
||||
" True\n",
|
||||
" '''\n",
|
||||
" return indice(tableau, element) is not None"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 3\n",
|
||||
"def indices(tableau, element):\n",
|
||||
" '''\n",
|
||||
" Indique les indices où se situent l'élément dans le tableau\n",
|
||||
" :param tableau: (list) un tableau\n",
|
||||
" :param element: (any) un élément\n",
|
||||
" :return: (list) les indices de l'élément dans le tableau\n",
|
||||
" :doctest:\n",
|
||||
" >>> indices([0, 1, 2, 3], 1)\n",
|
||||
" [1]\n",
|
||||
" >>> indices([], 1)\n",
|
||||
" []\n",
|
||||
" >>> indices([3, 2, 0, 1], 1)\n",
|
||||
" [3]\n",
|
||||
" >>> indices([3, 1, 2, 1], 1)\n",
|
||||
" [1, 3]\n",
|
||||
" '''\n",
|
||||
" i = []\n",
|
||||
" for j in range(len(tableau)):\n",
|
||||
" if tableau[j] == element:\n",
|
||||
" i.append(j)\n",
|
||||
" return i"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 4\n",
|
||||
"def compte(tableau, element):\n",
|
||||
" '''\n",
|
||||
" Compte le nombre d'occurrences de l'élément dans le tableau\n",
|
||||
" :param tableau: (list) Un tableau\n",
|
||||
" :param element: (any) un élément\n",
|
||||
" ;return: (int) le nombre d'occurrences de l'élément dans le tableau\n",
|
||||
" :doctest:\n",
|
||||
" >>> compte([], 1)\n",
|
||||
" 0\n",
|
||||
" >>> compte([1], 1)\n",
|
||||
" 1\n",
|
||||
" >>> compte([0], 1)\n",
|
||||
" 0\n",
|
||||
" >>> compte([1, 0, 1, 0], 1)\n",
|
||||
" 2\n",
|
||||
" '''\n",
|
||||
" occurrences = 0\n",
|
||||
" for x in tableau:\n",
|
||||
" if x == element:\n",
|
||||
" occurrences += 1\n",
|
||||
" return occurrences"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 3 : Agrégation\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
">>> notes = [14.5, 13, 7, 10.25, 16, 12.5, 9.5]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"1. Écrire une fonction `somme` qui prend en paramètre un tableau de flottants et renvoie la somme des valeurs du tableau.\n",
|
||||
"2. Écrire une fonction `moyenne` qui prend en paramètre un tableau de flottants et renvoie la valeur moyenne du tableau.\n",
|
||||
"3. Écrire une fonction `maximum` qui prend en paramètre un tableau de flottants et renvoie la valeur maximale du tableau. "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 1\n",
|
||||
"def somme(tableau):\n",
|
||||
" '''\n",
|
||||
" Calcule la somme des éléments du tableau\n",
|
||||
" :param tableau: (list) une tableau\n",
|
||||
" :return: (int) la somme\n",
|
||||
" :doctest:\n",
|
||||
" >>> somme([1, 2, 3])\n",
|
||||
" 6\n",
|
||||
" >>> somme([1, -2, 3])\n",
|
||||
" 2\n",
|
||||
" >>> somme([])\n",
|
||||
" 0\n",
|
||||
" '''\n",
|
||||
" _somme = 0\n",
|
||||
" for element in tableau:\n",
|
||||
" _somme += element\n",
|
||||
" return _somme"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 2\n",
|
||||
"def moyenne(tableau):\n",
|
||||
" '''\n",
|
||||
" Calcule la moyenne des éléments du tableau\n",
|
||||
" :param tableau: (list) un tableau\n",
|
||||
" :return: (float) la moyenne des éléments du tableau\n",
|
||||
" :doctest:\n",
|
||||
" >>> moyenne([1, 1, 1])\n",
|
||||
" 1.0\n",
|
||||
" >>> moyenne([1, 2, 3])\n",
|
||||
" 2.0\n",
|
||||
" >>> moyenne([])\n",
|
||||
" Traceback (most recent call last):\n",
|
||||
" ...\n",
|
||||
" ZeroDivisionError: division by zero\n",
|
||||
" '''\n",
|
||||
" return somme(tableau) / len(tableau)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 3\n",
|
||||
"def maximum(tableau):\n",
|
||||
" '''\n",
|
||||
" Trouve l'élément avec la valeur maximale du tableau\n",
|
||||
" :param tableau: (list) un tableau\n",
|
||||
" :return: (int) l'élément de valeur maximale\n",
|
||||
" :doctest:\n",
|
||||
" >>> maximum([1, 2, 3])\n",
|
||||
" 3\n",
|
||||
" >>> maximum([-1, -2, -3])\n",
|
||||
" -1\n",
|
||||
" >>> maximum([]) is None\n",
|
||||
" True\n",
|
||||
" '''\n",
|
||||
" if len(tableau) == 0:\n",
|
||||
" return None\n",
|
||||
" max = tableau[0]\n",
|
||||
" for element in tableau:\n",
|
||||
" if element > max:\n",
|
||||
" max = element\n",
|
||||
" return max"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 4 : Manipulations sur les tableaux\n",
|
||||
"\n",
|
||||
"Pour tester les fonctions de manipulations, nous utiliserons le Code Konami<sup>[wikipédia](https://fr.wikipedia.org/wiki/Code_Konami)</sup>\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
">>> code = [\"↑\", \"↑\", \"↓\",\"↓\", \"←\", \"→\", \"←\", \"→\", \"B\", \"A\"]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"1. Écrire une méthode `inverser` qui prend en paramètre un tableau et a pour effet de bord d'inverser l'ensemble des valeurs du tableau.\n",
|
||||
"2. Écrire une fonction `copie` qui prend en paramètre un tableau et renvoie une copie du tableau.\n",
|
||||
"3. Écrire une méthode `dedoublonner` qui prend en paramètre un tableau et a pour effet de bord de supprimer les doublons d'une même valeur. \n",
|
||||
"4. Écrire une fonction `tranche` qui prend en paramètre un tableau et deux entiers $min$ et $max$, et renvoie le sous-tableau entre $min$ et $max$."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 1\n",
|
||||
"def inverser(tableau):\n",
|
||||
" '''\n",
|
||||
" Inverse les éléments du tableau\n",
|
||||
" :param tableau: (list) un tableau\n",
|
||||
" :doctest:\n",
|
||||
" >>> t = [1, 2, 3]\n",
|
||||
" >>> inverser(t)\n",
|
||||
" >>> t\n",
|
||||
" [3, 2, 1]\n",
|
||||
" >>> t = ['b', 'o', 'n', 'j', 'o', 'u', 'r']\n",
|
||||
" >>> inverser(t)\n",
|
||||
" >>> t\n",
|
||||
" ['r', 'u', 'o', 'j', 'n', 'o', 'b']\n",
|
||||
" '''\n",
|
||||
" debut = 0\n",
|
||||
" fin = len(tableau) - 1\n",
|
||||
" \n",
|
||||
" while debut < fin:\n",
|
||||
" tableau[debut], tableau[fin] = tableau[fin], tableau[debut]\n",
|
||||
" debut += 1\n",
|
||||
" fin -= 1"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 2\n",
|
||||
"def copie(tableau):\n",
|
||||
" '''\n",
|
||||
" Renvoie une copie du tableau\n",
|
||||
" :param tableau: (list) un tableau\n",
|
||||
" :return: (list) une copie du tableau\n",
|
||||
" :doctest:\n",
|
||||
" >>> copie([1, 1, 1, 1])\n",
|
||||
" [1, 1, 1, 1]\n",
|
||||
" >>> copie([1, 2, 3, 4])\n",
|
||||
" [1, 2, 3, 4]\n",
|
||||
" >>> copie([])\n",
|
||||
" []\n",
|
||||
" '''\n",
|
||||
" resultat = []\n",
|
||||
" for element in tableau:\n",
|
||||
" resultat.append(element)\n",
|
||||
" return resultat"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 3\n",
|
||||
"def dedoublonner(tableau):\n",
|
||||
" '''\n",
|
||||
" Renvoie un tableau sans doublant\n",
|
||||
" :param tableau: (list) un tableau\n",
|
||||
" :return: (list) le tableau sans doublon\n",
|
||||
" :doctest:\n",
|
||||
" >>> dedoublonner([1, 1, 1, 1])\n",
|
||||
" [1]\n",
|
||||
" >>> dedoublonner([1, 2, 3, 4])\n",
|
||||
" [1, 2, 3, 4]\n",
|
||||
" >>> dedoublonner([1, 2, 1, 4])\n",
|
||||
" [1, 2, 4]\n",
|
||||
" '''\n",
|
||||
" resultat = []\n",
|
||||
" for element in tableau:\n",
|
||||
" if not est_present(resultat, element):\n",
|
||||
" resultat.append(element)\n",
|
||||
" return resultat"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 4\n",
|
||||
"def tranche(tableau, debut, fin):\n",
|
||||
" '''\n",
|
||||
" Obtient une tranche du tableau\n",
|
||||
" :param tableau: (list) un tableau\n",
|
||||
" :param debut: (int) l'indice du début de la tranche\n",
|
||||
" :param fin: (int) l'indice de fin de la tranche\n",
|
||||
" :return: (list) un tableau contenant les éléments entre début et fin non inclus\n",
|
||||
" :doctest:\n",
|
||||
" >>> tranche([ i for i in range(10)], 0, 10)\n",
|
||||
" [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
|
||||
" >>> tranche([ i for i in range(10)], 0, 5)\n",
|
||||
" [0, 1, 2, 3, 4]\n",
|
||||
" >>> tranche([ i for i in range(10)], 5, 10)\n",
|
||||
" [5, 6, 7, 8, 9]\n",
|
||||
" '''\n",
|
||||
" sous_tableau = []\n",
|
||||
" for i in range(debut, fin):\n",
|
||||
" sous_tableau.append(tableau[i])\n",
|
||||
" return sous_tableau"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 5 : Matrice\n",
|
||||
"\n",
|
||||
"1. Écrire une fonction `ligne` qui prend en paramètre une matrice et un indice de ligne en entrées et renvoie un tableau avec l'ensemble des valeurs de la ligne.\n",
|
||||
"2. Écrire une fonction `colonne` qui prend en paramètre une matrice et un indice de colonne en entrées et renvoie un tableau avec l'ensemble des valeurs de la colonne.\n",
|
||||
"3. Écrire une fonction `diagonale_nord_ouest` qui prend en paramètre une matrice et renvoie un tableau avec l'ensemble des valeurs de la diagonale. La première valeur est celle à l'indice \\[0]\\[0] et la dernière celle correspondant à l'indice \\[len(matrice) - 1]\\[len(matrice) - 1].\n",
|
||||
"4. Écrire une fonction `diagonale_nord_est` qui prend en paramètre une matrice et renvoie un tableau avec l'ensemble des valeurs de la diagonale. La première valeur est celle à l'indice \\[0]\\[len(matrice) - 1] et la dernière celle correspondant à l'indice \\[len(matrice) - 1]\\[0]."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 1\n",
|
||||
"def ligne(matrice, indice):\n",
|
||||
" '''\n",
|
||||
" Obtient un tableau comportant l'ensemble des valeurs de la ligne indice de la matrice\n",
|
||||
" :param matrice: (list) une matrice\n",
|
||||
" :param indice: (int) un entier\n",
|
||||
" :return: (list) un tableau de valeurs de la ligne indice\n",
|
||||
" :doctest:\n",
|
||||
" >>> ligne([[1, 2],[3, 4]], 0)\n",
|
||||
" [1, 2]\n",
|
||||
" >>> ligne([[1, 2],[3, 4]], 1)\n",
|
||||
" [3, 4]\n",
|
||||
" '''\n",
|
||||
" return matrice[indice]"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 2\n",
|
||||
"def colonne(matrice, indice):\n",
|
||||
" '''\n",
|
||||
" Obtient un tableau comportant l'ensemble des valeurs de la colonne indice de la matrice\n",
|
||||
" :param matrice: (list) une matrice\n",
|
||||
" :param indice: (int) un entier\n",
|
||||
" :return: (list) un tableau de valeurs de la colonne indice\n",
|
||||
" :doctest:\n",
|
||||
" >>> colonne([[1, 2],[3, 4]], 0)\n",
|
||||
" [1, 3]\n",
|
||||
" >>> colonne([[1, 2],[3, 4]], 1)\n",
|
||||
" [2, 4]\n",
|
||||
" '''\n",
|
||||
" return [ matrice[i][indice] for i in range(len(matrice[0]))]"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 3\n",
|
||||
"def diagonale_nord_ouest(matrice):\n",
|
||||
" '''\n",
|
||||
" Obtient les valeurs de la diagonale de la matrice, dont l'origine est la valeur correspondant à l'indice [0][0]\n",
|
||||
" :param matrice: (list) une matrice\n",
|
||||
" :return: (list) un tableau de valeurs de la diagonale\n",
|
||||
" :doctest:\n",
|
||||
" >>> diagonale_nord_ouest([[1, 2], [3, 4]])\n",
|
||||
" [1, 4]\n",
|
||||
" >>> diagonale_nord_ouest([['A', 'D', 'C'], ['B', 'F', 'E'], ['H', 'I', 'G']])\n",
|
||||
" ['A', 'F', 'G']\n",
|
||||
" '''\n",
|
||||
" return [matrice[i][i] for i in range(0, len(matrice))]"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 4\n",
|
||||
"def diagonale_nord_est(matrice):\n",
|
||||
" '''\n",
|
||||
" Obtient les valeurs de la diagonale de la matrice, dont l'origine est la valeur correspondant à l'indice [0][len(matrice) - 1]\n",
|
||||
" :param matrice: (list) une matrice\n",
|
||||
" :return: (list) un tableau de valeurs de la diagonale\n",
|
||||
" :doctest:\n",
|
||||
" >>> diagonale_nord_est([[1, 2], [3, 4]])\n",
|
||||
" [2, 3]\n",
|
||||
" >>> diagonale_nord_est([['A', 'D', 'C'], ['B', 'F', 'E'], ['H', 'I', 'G']])\n",
|
||||
" ['C', 'F', 'H']\n",
|
||||
" '''\n",
|
||||
" return [matrice[i][len(matrice[0]) - 1 - i] for i in range(0, len(matrice))]"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"#### Application - Carré magique\n",
|
||||
"\n",
|
||||
"<table style=\"margin : 0 auto 0 auto; width:100px;text-align:center;\">\n",
|
||||
"<caption style=\"caption-side:bottom;\">Fig 1. - Carré d'ordre 4</caption>\n",
|
||||
"<tr style=\"border:none;\"><td>16</td><td>3</td><td>2</td><td>13</td></tr>\n",
|
||||
"<tr style=\"border:none;\"><td>5</td><td>10</td><td>11</td><td>8</td></tr>\n",
|
||||
"<tr style=\"border:none;\"><td>9</td><td>6</td><td>7</td><td>12</td></tr>\n",
|
||||
"<tr style=\"border:none;\"><td>4</td><td>15</td><td>14</td><td>1</td></tr>\n",
|
||||
"</table>\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"En mathématiques, un ***carré magique*** d’ordre $n$ est composé de $n^2$ entiers strictement positifs, écrits sous la forme d’un tableau carré. Ces nombres sont disposés de sorte que leurs sommes sur chaque rangée, sur chaque colonne et sur chaque diagonale principale soient égales. On nomme alors ***constante magique*** la valeur de ces sommes.\n",
|
||||
"\n",
|
||||
"<table style=\"margin : 0 auto 0 auto; width:100px;text-align:center;\">\n",
|
||||
" <caption style=\"caption-side:bottom;\">Fig 1.1 - Carré magique avec sa constante égale à 34</caption>\n",
|
||||
"<tr style=\"border:none;\"><th style=\"border : none;\"></th><td>16</td><td>3</td><td>2</td><td>13</td><th style=\"border : none;padding-left:.5em;\">→34</th></tr>\n",
|
||||
"<tr style=\"border:none;\"><th style=\"border : none;\"></th><td>5</td><td>10</td><td>11</td><td>8</td><th style=\"border : none;padding-left:.5em;\">→34</th></tr>\n",
|
||||
"<tr style=\"border:none;\"><th style=\"border : none;\"></th><td>9</td><td>6</td><td>7</td><td>12</td><th style=\"border : none;padding-left:.5em;\">→34</th></tr>\n",
|
||||
"<tr style=\"border:none;\"><th style=\"border : none;\"></th><td>4</td><td>15</td><td>14</td><td>1</td><th style=\"border : none;padding-left:.5em;\">→34</th></tr>\n",
|
||||
"<tr style=\"border:none;\"><th style=\"border : none;\">↙ 34</th><th style=\"border:none;\">↓ 34</th><th style=\"border:none;\">↓ 34</th><th style=\"border:none;\">↓ 34</th><th style=\"border:none;\">↓ 34</th><th style=\"border:none;\">↘ 34</th></tr>\n",
|
||||
"</table>\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"> Écrire un prédicat `est_magique` qui prend une matrice d'entiers en paramètre et indique si le carré est magique ou non."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def est_magique(matrice):\n",
|
||||
" '''\n",
|
||||
" Indique si le carré est magique ou non\n",
|
||||
" :param matrice: (list) un carré d'entiers\n",
|
||||
" :return: (bool) True si les sommes de chaque ligne, colonne et diagonale sont égales.\n",
|
||||
" :doctest:\n",
|
||||
" >>> est_magique([[2, 7, 6], [9, 5, 1], [4, 3, 8]])\n",
|
||||
" True\n",
|
||||
" >>> est_magique([[2, 7, 6], [9, 1, 5], [4, 3, 8]])\n",
|
||||
" False\n",
|
||||
" >>> est_magique([[16, 3, 2, 13], [5, 10, 11, 8], [9, 6, 7, 12], [4, 15, 14, 1]])\n",
|
||||
" True\n",
|
||||
" '''\n",
|
||||
" constante = somme(matrice[0])\n",
|
||||
" return (\n",
|
||||
" all([somme(ligne(matrice, i)) == constante for i in range(1, len(matrice))]) and\n",
|
||||
" all([somme(colonne(matrice, i)) == constante for i in range(0, len(matrice[0]))]) and\n",
|
||||
" somme(diagonale_nord_ouest(matrice)) == constante and\n",
|
||||
" somme(diagonale_nord_est(matrice)) == constante\n",
|
||||
" )"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"#### Carré magique de lettres\n",
|
||||
"\n",
|
||||
"Un ***carré magique de lettres***, également appelé « ***mots carrés*** », est une forme de mots croisés disposé en carré, ne comportant pas de case noire et constitué de mots valides dans une langue définie. Ils peuvent, par définition, être lus horizontalement et verticalement et présentent dans ces deux sens les mêmes mots.\n",
|
||||
"\n",
|
||||
"<table style=\"margin : 0 auto 0 auto; width : 100px;text-align:center;\">\n",
|
||||
" <caption style=\"caption-side:bottom;\">Fig.2.1 - Carré magique de lettres d'ordre 3</caption>\n",
|
||||
"<tr><td>T</td><td>E</td><td>L</td></tr>\n",
|
||||
"<tr><td>E</td><td>T</td><td>E</td></tr>\n",
|
||||
"<tr><td>L</td><td>E</td><td>S</td></tr>\n",
|
||||
"</table>\n",
|
||||
"\n",
|
||||
"<table style=\"margin : 0 auto 0 auto; width : 100px;text-align:center;\">\n",
|
||||
" <caption style=\"caption-side:bottom;\">Fig.2.2 - Carré magique de lettres d'ordre 5</caption>\n",
|
||||
"<tr><td>C</td><td>U</td><td>L</td><td>T</td><td>E</td></tr>\n",
|
||||
"<tr><td>U</td><td>N</td><td>I</td><td>E</td><td>S</td></tr>\n",
|
||||
"<tr><td>L</td><td>I</td><td>O</td><td>N</td><td>S</td></tr>\n",
|
||||
"<tr><td>T</td><td>E</td><td>N</td><td>T</td><td>A</td></tr>\n",
|
||||
"<tr><td>E</td><td>S</td><td>S</td><td>A</td><td>I</td></tr>\n",
|
||||
"</table>\n",
|
||||
"\n",
|
||||
"> Écrire un prédicat `est_magique_lettres` qui prend une matrice de caractères en paramètre et indique si le carré est magique de lettres ou non."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def est_magique_lettres(matrice):\n",
|
||||
" '''\n",
|
||||
" Indique si une matrice de caractères est un carré magique ou non\n",
|
||||
" :param matrice: (list) une matrice de caractères\n",
|
||||
" :return: (bool) True si la matrice est un carré magique de lettres, False sinon\n",
|
||||
" :doctest:\n",
|
||||
" >>> est_magique_lettres([['T', 'E', 'L'], ['E', 'T', 'E'], ['L', 'E', 'S']])\n",
|
||||
" True\n",
|
||||
" >>> est_magique_lettres([['T', 'E', 'L'], ['E', 'R', 'E'], ['L', 'A', 'S']])\n",
|
||||
" False\n",
|
||||
" >>> est_magique_lettres([['S', 'A', 'T', 'O', 'R'], ['A', 'R', 'E', 'P', 'O'], ['T', 'E', 'N', 'E', 'T'], ['O', 'P', 'E', 'R', 'A'], ['R', 'O', 'T', 'A', 'S']])\n",
|
||||
" True\n",
|
||||
" '''\n",
|
||||
" return all([ ligne(matrice, i) == colonne(matrice, i) for i in range(len(matrice))])"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"#### Application - Pour aller plus loin\n",
|
||||
"\n",
|
||||
"<table style=\"margin : 0 auto 0 auto; width : 100px;text-align:center;\">\n",
|
||||
" <caption style=\"caption-side:bottom;\">Fig.3 - Dessin d'une maison</caption>\n",
|
||||
"<tr><td>⚪</td><td>⚪</td><td>⚪</td><td>⚫</td><td>⚪</td><td>⚪</td></tr>\n",
|
||||
"<tr><td>⚪</td><td>⚪</td><td>⚫</td><td>⚪</td><td>⚫</td><td>⚪</td></tr>\n",
|
||||
"<tr><td>⚪</td><td>⚫</td><td>⚪</td><td>⚪</td><td>⚪</td><td>⚫</td></tr>\n",
|
||||
"<tr><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td></tr>\n",
|
||||
"<tr><td>⚫</td><td>⚪</td><td>⚫</td><td>⚪</td><td>⚪</td><td>⚫</td></tr>\n",
|
||||
"<tr><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td></tr>\n",
|
||||
"</table>\n",
|
||||
"\n",
|
||||
"Déclaration de la matrice correspondante à la Fig.1 :\n",
|
||||
"```python\n",
|
||||
"matrice = [\n",
|
||||
" ['⚪', '⚪', '⚪', '⚫', '⚪', '⚪'],\n",
|
||||
" ['⚪', '⚪', '⚫', '⚪', '⚫', '⚪'],\n",
|
||||
" ['⚪', '⚫', '⚪', '⚪', '⚪', '⚫'],\n",
|
||||
" ['⚫', '⚫', '⚫', '⚫', '⚫', '⚫'],\n",
|
||||
" ['⚫', '⚪', '⚫', '⚪', '⚪', '⚫'],\n",
|
||||
" ['⚫', '⚫', '⚫', '⚫', '⚫', '⚫']\n",
|
||||
"]\n",
|
||||
"```"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"1. Écrire une méthode `miroir_vertical` qui prend en paramètre une matrice et a pour effet de bord de réaliser l'effet miroir vertical sur les valeurs de la matrice.\n",
|
||||
"\n",
|
||||
"<table style=\"margin : 0 auto 0 auto; width : 100px;text-align:center;\">\n",
|
||||
" <caption style=\"caption-side:bottom;\">Fig.3.1 - Effet miroir vertical de la Fig.4</caption>\n",
|
||||
"<tr><td>⚪</td><td>⚪</td><td>⚫</td><td>⚪</td><td>⚪</td><td>⚪</td></tr>\n",
|
||||
"<tr><td>⚪</td><td>⚫</td><td>⚪</td><td>⚫</td><td>⚪</td><td>⚪</td></tr>\n",
|
||||
"<tr><td>⚫</td><td>⚪</td><td>⚪</td><td>⚪</td><td>⚫</td><td>⚪</td></tr>\n",
|
||||
"<tr><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td></tr>\n",
|
||||
"<tr><td>⚫</td><td>⚪</td><td>⚪</td><td>⚫</td><td>⚪</td><td>⚫</td></tr>\n",
|
||||
"<tr><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td></tr>\n",
|
||||
"</table>"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 1\n",
|
||||
"def miroir_vertical(matrice):\n",
|
||||
" '''\n",
|
||||
" Applique l'effet miroir par rapport à l'axe vertical sur une matrice\n",
|
||||
" :param matrice: (list) une matrice\n",
|
||||
" :doctest:\n",
|
||||
" >>> matrice = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
|
||||
" >>> miroir_vertical(matrice)\n",
|
||||
" >>> matrice\n",
|
||||
" [[3, 2, 1], [6, 5, 4], [9, 8, 7]]\n",
|
||||
" >>> matrice = [['⚫', '⚪', '⚫'], ['⚪', '⚪', '⚫'], ['⚪', '⚫', '⚪']]\n",
|
||||
" >>> miroir_vertical(matrice)\n",
|
||||
" >>> matrice\n",
|
||||
" [['⚫', '⚪', '⚫'], ['⚫', '⚪', '⚪'], ['⚪', '⚫', '⚪']]\n",
|
||||
" '''\n",
|
||||
" for tableau in matrice:\n",
|
||||
" inverser(tableau)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"2. Écrire une méthode `miroir_horizontal` qui prend en paramètre une matrice et a pour effet de bord de réaliser l'effet miroir horizontal sur les valeurs de la matrice.\n",
|
||||
"\n",
|
||||
"<table style=\"margin : 0 auto 0 auto; width : 100px;text-align:center;\">\n",
|
||||
" <caption style=\"caption-side:bottom;\">Fig.3.2 - Effet miroir horizontal de la Fig.4</caption>\n",
|
||||
"<tr><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td></tr>\n",
|
||||
"<tr><td>⚫</td><td>⚪</td><td>⚫</td><td>⚪</td><td>⚪</td><td>⚫</td></tr>\n",
|
||||
"<tr><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td></tr>\n",
|
||||
"<tr><td>⚪</td><td>⚫</td><td>⚪</td><td>⚪</td><td>⚪</td><td>⚫</td></tr>\n",
|
||||
"<tr><td>⚪</td><td>⚪</td><td>⚫</td><td>⚪</td><td>⚫</td><td>⚪</td></tr>\n",
|
||||
"<tr><td>⚪</td><td>⚪</td><td>⚪</td><td>⚫</td><td>⚪</td><td>⚪</td></tr>\n",
|
||||
"</table>"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 2\n",
|
||||
"def miroir_horizontal(matrice):\n",
|
||||
" '''\n",
|
||||
" Applique l'effet miroir par rapport à l'axe horizontal sur une matrice\n",
|
||||
" :param matrice: (list) une matrice\n",
|
||||
" :doctest:\n",
|
||||
" >>> matrice = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
|
||||
" >>> miroir_horizontal(matrice)\n",
|
||||
" >>> matrice\n",
|
||||
" [[7, 8, 9], [4, 5, 6], [1, 2, 3]]\n",
|
||||
" >>> matrice = [['⚫', '⚪', '⚫'], ['⚪', '⚪', '⚫'], ['⚪', '⚫', '⚪']]\n",
|
||||
" >>> miroir_horizontal(matrice)\n",
|
||||
" >>> matrice\n",
|
||||
" [['⚪', '⚫', '⚪'], ['⚪', '⚪', '⚫'], ['⚫', '⚪', '⚫']]\n",
|
||||
" '''\n",
|
||||
" inverser(matrice)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"3. Écrire une fonction `rotation_horaire` qui prend en paramètre une matrice et renvoie une matrice dont les valeurs correspondent à la rotation dans le sens horaire des valeurs de la matrice.\n",
|
||||
"\n",
|
||||
"<table style=\"margin : 0 auto 0 auto; width : 100px;text-align:center;\">\n",
|
||||
" <caption style=\"caption-side:bottom;\">Fig.3.3 - Roration horaire de la Fig.4</caption>\n",
|
||||
"<tr><td>⚫</td><td>⚫</td><td>⚫</td><td>⚪</td><td>⚪</td><td>⚪</td></tr>\n",
|
||||
"<tr><td>⚫</td><td>⚪</td><td>⚫</td><td>⚫</td><td>⚪</td><td>⚪</td></tr>\n",
|
||||
"<tr><td>⚫</td><td>⚫</td><td>⚫</td><td>⚪</td><td>⚫</td><td>⚪</td></tr>\n",
|
||||
"<tr><td>⚫</td><td>⚪</td><td>⚫</td><td>⚪</td><td>⚪</td><td>⚫</td></tr>\n",
|
||||
"<tr><td>⚫</td><td>⚪</td><td>⚫</td><td>⚪</td><td>⚫</td><td>⚪</td></tr>\n",
|
||||
"<tr><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td><td>⚪</td><td>⚪</td></tr>\n",
|
||||
"</table>"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 3\n",
|
||||
"def rotation_horaire(matrice):\n",
|
||||
" '''\n",
|
||||
" :param matrice: (list) une matrice\n",
|
||||
" :doctest:\n",
|
||||
" >>> matrice = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
|
||||
" >>> rotation_horaire(matrice)\n",
|
||||
" [[7, 4, 1], [8, 5, 2], [9, 6, 3]]\n",
|
||||
" >>> matrice = [['⚫', '⚪', '⚫'], ['⚪', '⚪', '⚫'], ['⚪', '⚫', '⚪']]\n",
|
||||
" >>> rotation_horaire(matrice)\n",
|
||||
" [['⚪', '⚪', '⚫'], ['⚫', '⚪', '⚪'], ['⚪', '⚫', '⚫']]\n",
|
||||
" '''\n",
|
||||
" resultat = []\n",
|
||||
" for i in range(len(matrice[0])):\n",
|
||||
" resultat.append(colonne(matrice, i))\n",
|
||||
" miroir_vertical(resultat)\n",
|
||||
" return resultat"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"4. Écrire une fonction `rotation_anti_horaire` qui prend en paramètre une matrice et renvoie une matrice dont les valeurs correspondent à la rotation dans le sens anti-horaire des valeurs de la matrice.\n",
|
||||
"\n",
|
||||
"<table style=\"margin : 0 auto 0 auto; width : 100px;text-align:center;\">\n",
|
||||
" <caption style=\"caption-side:bottom;\">Fig.3.4 - Roration anti-horaire de la Fig.4</caption>\n",
|
||||
"<tr><td>⚪</td><td>⚪</td><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td></tr>\n",
|
||||
"<tr><td>⚪</td><td>⚫</td><td>⚪</td><td>⚫</td><td>⚪</td><td>⚫</td></tr>\n",
|
||||
"<tr><td>⚫</td><td>⚪</td><td>⚪</td><td>⚫</td><td>⚪</td><td>⚫</td></tr>\n",
|
||||
"<tr><td>⚪</td><td>⚫</td><td>⚪</td><td>⚫</td><td>⚫</td><td>⚫</td></tr>\n",
|
||||
"<tr><td>⚪</td><td>⚪</td><td>⚫</td><td>⚫</td><td>⚪</td><td>⚫</td></tr>\n",
|
||||
"<tr><td>⚪</td><td>⚪</td><td>⚪</td><td>⚫</td><td>⚫</td><td>⚫</td></tr>\n",
|
||||
"</table>"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 4\n",
|
||||
"def rotation_anti_horaire(matrice):\n",
|
||||
" '''\n",
|
||||
" :param matrice: (list) une matrice\n",
|
||||
" :doctest:\n",
|
||||
" >>> matrice = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
|
||||
" >>> rotation_anti_horaire(matrice)\n",
|
||||
" [[3, 6, 9], [2, 5, 8], [1, 4, 7]]\n",
|
||||
" >>> matrice = [['⚫', '⚪', '⚫'], ['⚪', '⚪', '⚫'], ['⚪', '⚫', '⚪']]\n",
|
||||
" >>> rotation_anti_horaire(matrice)\n",
|
||||
" [['⚫', '⚫', '⚪'], ['⚪', '⚪', '⚫'], ['⚫', '⚪', '⚪']]\n",
|
||||
" '''\n",
|
||||
" resultat = []\n",
|
||||
" for i in range(len(matrice[0]) - 1, -1, -1):\n",
|
||||
" resultat.append(colonne(matrice, i))\n",
|
||||
" return resultat"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Pour valider vos fonctions, vous pouvez réaliser sur papier les opérations miroir et de rotation sur la Fig.4 et vérifier que les résultats obtenus sont conformes.\n",
|
||||
"\n",
|
||||
"<table style=\"margin : 0 auto 0 auto; width : 100px;text-align:center;\">\n",
|
||||
" <caption style=\"caption-side:bottom;\">Fig.4 - Dessin d'un bateau avec une mouette</caption>\n",
|
||||
"<tr><td>⚪</td><td>⚪</td><td>⚫</td><td>⚪</td><td>⚪</td><td>⚪</td><td>⚪</td></tr>\n",
|
||||
"<tr><td>⚪</td><td>⚫</td><td>⚫</td><td>⚪</td><td>⚫</td><td>⚪</td><td>⚫</td></tr>\n",
|
||||
"<tr><td>⚫</td><td>⚪</td><td>⚫</td><td>⚪</td><td>⚪</td><td>⚫</td><td>⚪</td></tr>\n",
|
||||
"<tr><td>⚪</td><td>⚫</td><td>⚫</td><td>⚪</td><td>⚪</td><td>⚪</td><td>⚪</td></tr>\n",
|
||||
"<tr><td>⚪</td><td>⚪</td><td>⚫</td><td>⚪</td><td>⚪</td><td>⚪</td><td>⚪</td></tr>\n",
|
||||
"<tr><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td></tr>\n",
|
||||
"<tr><td>⚫</td><td>⚪</td><td>⚪</td><td>⚪</td><td>⚪</td><td>⚪</td><td>⚫</td></tr>\n",
|
||||
"<tr><td>⚪</td><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td><td>⚫</td><td>⚪</td></tr>\n",
|
||||
"</table>\n",
|
||||
"\n",
|
||||
"Déclaration de la matrice correspondante à la Fig.4 :\n",
|
||||
"```python\n",
|
||||
"matrice = [\n",
|
||||
" ['⚪', '⚪', '⚫', '⚪', '⚪', '⚪', '⚪'],\n",
|
||||
" ['⚪', '⚫', '⚫', '⚪', '⚫', '⚪', '⚫'],\n",
|
||||
" ['⚫', '⚪', '⚫', '⚪', '⚪', '⚫', '⚪'],\n",
|
||||
" ['⚪', '⚫', '⚫', '⚪', '⚪', '⚪', '⚪'],\n",
|
||||
" ['⚪', '⚪', '⚫', '⚪', '⚪', '⚪', '⚪'],\n",
|
||||
" ['⚫', '⚫', '⚫', '⚫', '⚫', '⚫', '⚫'],\n",
|
||||
" ['⚫', '⚪', '⚪', '⚪', '⚪', '⚪', '⚫'],\n",
|
||||
" ['⚪', '⚫', '⚫', '⚫', '⚫', '⚫', '⚪']\n",
|
||||
"]\n",
|
||||
"```"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"kernelspec": {
|
||||
"display_name": "Python 3",
|
||||
"language": "python",
|
||||
"name": "python3"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": {
|
||||
"name": "ipython",
|
||||
"version": 3
|
||||
},
|
||||
"file_extension": ".py",
|
||||
"mimetype": "text/x-python",
|
||||
"name": "python",
|
||||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.9.7"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 2
|
||||
}
|
||||
108
representation_construits/chapitre_1/tp/README.md
Normal file
108
representation_construits/chapitre_1/tp/README.md
Normal file
@@ -0,0 +1,108 @@
|
||||
---
|
||||
title : Les Drapeaux
|
||||
author: M. BODDAERT
|
||||
license: CC-BY-NC-SA
|
||||
---
|
||||
# TP : Les Drapeaux
|
||||
|
||||
<img src='./assets/france.png'/>
|
||||
|
||||
Fig 1. Drapeau français
|
||||
|
||||
## 1. Contexte
|
||||
|
||||
Un drapeau peut être vu comme une matrice, i.e un tableau de tableaux, de dimension $n \times m$.
|
||||
|
||||
Soient les codes couleurs suivants :
|
||||
|
||||
| Code | Couleur associée |
|
||||
| :--: | :----------------: |
|
||||
| 0 | NOIR |
|
||||
| 1 | ROUGE |
|
||||
| 2 | VERT |
|
||||
| 3 | JAUNE |
|
||||
| 4 | BLEU |
|
||||
| 5 | MAGENTA |
|
||||
| 6 | CYAN |
|
||||
| 7 | BLANC |
|
||||
|
||||
Il est dès lors possible de représenter le drapeau français de la Fig.1 , en python, par la matrice $15 \times 7$ suivante :
|
||||
|
||||
```python
|
||||
>>> drapeau = [
|
||||
[4, 4, 4, 4, 4, 7, 7, 7, 7, 7, 1, 1, 1, 1, 1],
|
||||
[4, 4, 4, 4, 4, 7, 7, 7, 7, 7, 1, 1, 1, 1, 1],
|
||||
[4, 4, 4, 4, 4, 7, 7, 7, 7, 7, 1, 1, 1, 1, 1],
|
||||
[4, 4, 4, 4, 4, 7, 7, 7, 7, 7, 1, 1, 1, 1, 1],
|
||||
[4, 4, 4, 4, 4, 7, 7, 7, 7, 7, 1, 1, 1, 1, 1],
|
||||
[4, 4, 4, 4, 4, 7, 7, 7, 7, 7, 1, 1, 1, 1, 1],
|
||||
[4, 4, 4, 4, 4, 7, 7, 7, 7, 7, 1, 1, 1, 1, 1]
|
||||
]
|
||||
```
|
||||
|
||||
En utilisant le formalisme par compréhension :
|
||||
|
||||
```python
|
||||
>>> drapeau = [ [4] * 5 + [7] * 5 + [1] * 5 for _ in range(7)]
|
||||
```
|
||||
|
||||
Ce formalisme compact traduit le fait que le drapeau français est constitué de ***5 cases bleues, 5 cases blanches et 5 cases rouges, et cela sur 7 lignes***.
|
||||
|
||||
## 2. Matériel fourni
|
||||
|
||||
Le module `paint` dispose de :
|
||||
|
||||
- 8 variables : `NOIR, ROUGE, VERT, JAUNE, BLEU, MAGENTA, CYAN, BLANC`, qui permettent de matérialiser les couleurs,
|
||||
- d'une méthode `dessiner` qui permet d'afficher un drapeau, à partir d'une matrice passée en paramètre, dans la console de l'interpréteur python.
|
||||
|
||||
<figure>
|
||||
<center><img src='./assets/utilisation_paint.png'/></center>
|
||||
<figcaption style='text-align:center;'>Fig 2. Exemple d'utilisation du module paint</figcaption>
|
||||
</figure>
|
||||
|
||||
## 3. Consignes
|
||||
|
||||
Vous devez créer un module `drapeau`.
|
||||
|
||||
Pour chaque drapeau de la liste fournie en Annexe, vous devez :
|
||||
|
||||
- Formaliser la matrice modélisant le drapeau,
|
||||
|
||||
- Identifier la structure algorithmique,
|
||||
|
||||
- Écrire une fonction, dans le module `drapeau` qui permette de créer la matrice modélisant le drapeau.
|
||||
|
||||
***N.B : Vous devez utiliser le formalisme par compréhension ou l'utilisation de boucle mais il est interdit d'utiliser l'affectation par valeur, case par case.***
|
||||
|
||||
Le module sera exécutable de la manière suivante :
|
||||
|
||||
> python3 drapeau.py france
|
||||
|
||||
Le résultat attendu étant l'affichage du drapeau du pays passé en paramètre.
|
||||
|
||||
## 4. Annexe : Liste des pays et drapeaux
|
||||
|
||||
| Pays | Drapeau | Consigne |
|
||||
| :--: | :--: | :-- |
|
||||
| Belgique | <img src='./assets/belgique.png'/> | Le drapeau est de dimension $ 15 \times 7$ |
|
||||
| Pays-Bas |<img src='./assets/pays_bas.png'/> | Le drapeau est de dimension $ 15 \times 6$ |
|
||||
| Suède | <img src='./assets/suede.png'/>| Le drapeau est de dimension $ 15 \times 7$ |
|
||||
| Finlande | <img src='./assets/finlande.png'/> | Le drapeau est de dimension $ 15 \times 7$ |
|
||||
| Irlande | <img src='./assets/irlande.png'/>| Le drapeau est de dimension $ 15 \times 7$ |
|
||||
| Côte d'Ivoire |<img src='./assets/cote_ivoire.png'/> | Vous devez utiliser la fonction de création du drapeau d'Irlande. |
|
||||
| Bénin | <img src='./assets/benin.png'/>| Le drapeau est de dimension $ 15 \times 6$ |
|
||||
| Suisse | <img src='./assets/suisse.png'/>| Le drapeau est de dimension $ 15 \times 7$ |
|
||||
| Guinée | <img src='./assets/guinee.png'/>| Le drapeau est de dimension $ 15 \times 7$ |
|
||||
| Mali |<img src='./assets/mali.png'/> | Vous devez utiliser la fonction de création du drapeau de Guinée. |
|
||||
| Botswana | <img src='./assets/botswana.png'/> | Le drapeau est de dimension $ 15 \times 7$ |
|
||||
| Monaco | <img src='./assets/monaco.png'/>| Le drapeau est de dimension $ 15 \times 6$ |
|
||||
| Pologne | <img src='./assets/pologne.png'/>| Vous devez utiliser la fonction de création du drapeau de Monaco. |
|
||||
| Japon | <img src='./assets/japon.png'/>| Le drapeau est de dimension $ 15 \times 7$ |
|
||||
| Hongrie | <img src='./assets/hongrie.png'/>| Le drapeau est de dimension $ 15 \times 7$ |
|
||||
| Iran | <img src='./assets/iran.png'/>| Vous devez utiliser la fonction de création du drapeau de Hongrie. |
|
||||
| Palaos | <img src='./assets/palaos.png'/>| Le drapeau est de dimension $ 15 \times 7$ |
|
||||
| Grèce |<img src='./assets/grece.png'/> | Le drapeau est de dimension $ 15 \times 6$ |
|
||||
| Etats-Unis |<img src='./assets/etats_unis.png'/> | Le drapeau est de dimension $ 15 \times 6$ |
|
||||
| République du Congo | <img src='./assets/republique_congo.png'/>| Le drapeau est de dimension $ 15 \times 7$ |
|
||||
| Trinidad et Tobago |<img src='./assets/trinidad.png'/> | Le drapeau est de dimension $ 15 \times 7$ |
|
||||
| Jamaique |<img src='./assets/jamaique.png'/> | Le drapeau est de dimension $ 15 \times 7$ |
|
||||
BIN
representation_construits/chapitre_1/tp/assets/belgique.png
Normal file
BIN
representation_construits/chapitre_1/tp/assets/belgique.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 7.5 KiB |
BIN
representation_construits/chapitre_1/tp/assets/benin.png
Normal file
BIN
representation_construits/chapitre_1/tp/assets/benin.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 7.4 KiB |
BIN
representation_construits/chapitre_1/tp/assets/botswana.png
Normal file
BIN
representation_construits/chapitre_1/tp/assets/botswana.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 7.4 KiB |
BIN
representation_construits/chapitre_1/tp/assets/cote_ivoire.png
Normal file
BIN
representation_construits/chapitre_1/tp/assets/cote_ivoire.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 7.5 KiB |
BIN
representation_construits/chapitre_1/tp/assets/etats_unis.png
Normal file
BIN
representation_construits/chapitre_1/tp/assets/etats_unis.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 7.6 KiB |
BIN
representation_construits/chapitre_1/tp/assets/finlande.png
Normal file
BIN
representation_construits/chapitre_1/tp/assets/finlande.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 7.6 KiB |
BIN
representation_construits/chapitre_1/tp/assets/france.png
Normal file
BIN
representation_construits/chapitre_1/tp/assets/france.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 3.5 KiB |
BIN
representation_construits/chapitre_1/tp/assets/grece.png
Normal file
BIN
representation_construits/chapitre_1/tp/assets/grece.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 7.5 KiB |
BIN
representation_construits/chapitre_1/tp/assets/guinee.png
Normal file
BIN
representation_construits/chapitre_1/tp/assets/guinee.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 7.5 KiB |
BIN
representation_construits/chapitre_1/tp/assets/hongrie.png
Normal file
BIN
representation_construits/chapitre_1/tp/assets/hongrie.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 7.3 KiB |
BIN
representation_construits/chapitre_1/tp/assets/iran.png
Normal file
BIN
representation_construits/chapitre_1/tp/assets/iran.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 7.4 KiB |
BIN
representation_construits/chapitre_1/tp/assets/irlande.png
Normal file
BIN
representation_construits/chapitre_1/tp/assets/irlande.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 7.5 KiB |
BIN
representation_construits/chapitre_1/tp/assets/jamaique.png
Normal file
BIN
representation_construits/chapitre_1/tp/assets/jamaique.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 8.1 KiB |
BIN
representation_construits/chapitre_1/tp/assets/japon.png
Normal file
BIN
representation_construits/chapitre_1/tp/assets/japon.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 7.6 KiB |
BIN
representation_construits/chapitre_1/tp/assets/mali.png
Normal file
BIN
representation_construits/chapitre_1/tp/assets/mali.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 7.5 KiB |
BIN
representation_construits/chapitre_1/tp/assets/monaco.png
Normal file
BIN
representation_construits/chapitre_1/tp/assets/monaco.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 7.4 KiB |
BIN
representation_construits/chapitre_1/tp/assets/palaos.png
Normal file
BIN
representation_construits/chapitre_1/tp/assets/palaos.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 7.9 KiB |
BIN
representation_construits/chapitre_1/tp/assets/pays_bas.png
Normal file
BIN
representation_construits/chapitre_1/tp/assets/pays_bas.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 7.4 KiB |
BIN
representation_construits/chapitre_1/tp/assets/pologne.png
Normal file
BIN
representation_construits/chapitre_1/tp/assets/pologne.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 7.4 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 7.6 KiB |
BIN
representation_construits/chapitre_1/tp/assets/suede.png
Normal file
BIN
representation_construits/chapitre_1/tp/assets/suede.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 7.5 KiB |
BIN
representation_construits/chapitre_1/tp/assets/suisse.png
Normal file
BIN
representation_construits/chapitre_1/tp/assets/suisse.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 7.6 KiB |
BIN
representation_construits/chapitre_1/tp/assets/trinidad.png
Normal file
BIN
representation_construits/chapitre_1/tp/assets/trinidad.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 7.7 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 21 KiB |
276
representation_construits/chapitre_1/tp/correction.py
Normal file
276
representation_construits/chapitre_1/tp/correction.py
Normal file
@@ -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())}')
|
||||
44
representation_construits/chapitre_1/tp/paint.py
Normal file
44
representation_construits/chapitre_1/tp/paint.py
Normal file
@@ -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('')
|
||||
Reference in New Issue
Block a user