ajout representation construits
This commit is contained in:
@@ -0,0 +1,478 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "bb1cfae9",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Représentation des données : Les Dictionnaires "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "c09a37ee",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"-------------"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "38d1e9f4",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"> ***Contenue*** : Notions introduites : le type dictionnaire\n",
|
||||
"\n",
|
||||
"> ***Compétences*** : Construire une entrée de dictionnaire, savoir itérer sur es élèments d'un dictionnaire, connaître les méthodes."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "0beaa407",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Le programme"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "dcbf1fd3",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"-----"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "57421c29",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
""
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "401edcc8",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Apport de connaissances"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "717cce94",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"--------"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "0fc298dc",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Les dictionnaires Python permettent d'associer des valeurs à des clés : À partir d'une clé, on peut alors accéder directement à la valeur qui lui est associée."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "607fa703",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Propriétés"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "9e023220",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Les dictionnaires sont des conteneurs, comme les listes et tuples, vus précédemment, et sont mutables : *on peut donc modifier, ajouter ou supprimer du contenu.*\n",
|
||||
"\n",
|
||||
"Par contre, contrairement aux types de conteneurs précédémment étudiés, on ne peut pas accéder au contenu d'un dictionnaire à l'aide d'un indice : un dictionnaire n'est pas une séquence.\n",
|
||||
"\n",
|
||||
"Si on peut bien modifier les valeurs dans un dictionnaire, chaque clé est *unique et non mutable*. Elle peut être une chaîne de caractères, un nombre, un tulle de nombre...\n",
|
||||
"\n",
|
||||
"Enfin, les valeurs, quant à elles, peuvent être quelconques."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "555ca300",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"------"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "21761a39",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Création et accès"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "e219df29",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Pour initialiser un dictionnaire vide : "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 1,
|
||||
"id": "09f0144b",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"dico = {}\n",
|
||||
"#ou\n",
|
||||
"dico = dict()"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "766eeca7",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Pour initialiser un dictionnaire avec des valeurs :"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 3,
|
||||
"id": "8523655d",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"perso = {\"prenom\" : \"Bilbo\", \"age\" : 111}"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "7f350ef3",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"On a donc la clé en premier, ici, prenom & age sont deux chaines de caractères faisant office de clés.\n",
|
||||
"\n",
|
||||
"Accéder à une valeur d'un dictionnaire : on donne la clé à laquelle est associée la valeur recherchée (il faut donc que la clé existe)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 5,
|
||||
"id": "c1124575",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"'Bilbo'"
|
||||
]
|
||||
},
|
||||
"execution_count": 5,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"perso [\"prenom\"]\n",
|
||||
"'Bilbo'"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 6,
|
||||
"id": "094043d5",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"ename": "KeyError",
|
||||
"evalue": "'taille'",
|
||||
"output_type": "error",
|
||||
"traceback": [
|
||||
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
|
||||
"\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)",
|
||||
"\u001b[0;32m/var/folders/nb/7k573f_13zj2tnc5xd0020l40000gn/T/ipykernel_27744/399847934.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mperso\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"taille\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
|
||||
"\u001b[0;31mKeyError\u001b[0m: 'taille'"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"perso[\"taille\"]"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "a29f8a7f",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Tout comme les listes, on peut utiliser la fonction ***len*** pour connaître le nombre de couples stockés."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 7,
|
||||
"id": "1e8c5e32",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"2"
|
||||
]
|
||||
},
|
||||
"execution_count": 7,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"len(perso)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "865d51b5",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"-----"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "a1984b3d",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Modification et parcours"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "dfd2f41e",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
" On ajoute très simplement un couple clé / valeur :"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 8,
|
||||
"id": "24211303",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"{'prenom': 'Bilbo', 'age': 111, 'taille': 112}"
|
||||
]
|
||||
},
|
||||
"execution_count": 8,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"perso [\"taille\"] = 112\n",
|
||||
"perso"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "24fbdfae",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
" Pour modifier une valeur, c'est la même méthode : on ajoute un couple deja existant, et cela va écraser la valeur précédente :"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 9,
|
||||
"id": "83ad4a74",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"{'prenom': 'Bilbo', 'age': 131, 'taille': 112}"
|
||||
]
|
||||
},
|
||||
"execution_count": 9,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"perso[\"age\"] = 131\n",
|
||||
"perso"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "4fa255d5",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Pour supprimer une clé et sa valeur associée, on peut utiliser la fonction ***del***:"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 12,
|
||||
"id": "fc43064d",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"del perso[\"age\"]"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "c9021bee",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"------"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "225cf727",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Comme les listes et les tuples, les dictionnaires sont intérables : on itère sur les clés, les valeurs, ou les couples clé / valeur\n",
|
||||
"\n",
|
||||
"- Itération sur les clés :"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 14,
|
||||
"id": "2be77c4a",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"prenom\n",
|
||||
"taille\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"for cle in perso.keys():\n",
|
||||
" print (cle)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "6a0ddd68",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"- Itération sur les valeurs :"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 15,
|
||||
"id": "534dbdba",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Bilbo\n",
|
||||
"112\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"for val in perso.values():\n",
|
||||
" print(val)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "d77a9b92",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"- Itération sur les couples clé / valeur:"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 16,
|
||||
"id": "21a715ba",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"prenom -> Bilbo\n",
|
||||
"taille -> 112\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"for (cle, val) in perso.items():\n",
|
||||
" print(cle, \"->\", val)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "222e7ae8",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"✏ Par défaut, on itère sur les clés."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "c310b73d",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### À retenir"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "65893b5c",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"| Opération | Résultat |\n",
|
||||
"| ---------------------- | ------------------------------------------------------------ |\n",
|
||||
"| dico[k] | renvoie la valeur associée à la clé k |\n",
|
||||
"| x in dico.values() | renvoie True si une valeur de dico est égale à x, False sinon |\n",
|
||||
"| x not in dico.values() | renvoie True si aucune valeur de dico n'est égale à x, False sinon |\n",
|
||||
"| x in dico.keys() | renvoie True si une clé de dico est égale à x, False sinon |\n",
|
||||
"| dico[k] = v | Modifie la valeur v associée à la clé k ou l'ajoute si elle n'existe pas |\n",
|
||||
"| dico.get(k, v) | Renvoie la valeur associé à la clé k. Si la clé k n'existe pas, renvoie la valeur v |\n",
|
||||
"| del dico(k) | Enlève du dictionnaire la clé k |"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"kernelspec": {
|
||||
"display_name": "Python 3 (ipykernel)",
|
||||
"language": "python",
|
||||
"name": "python3"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": {
|
||||
"name": "ipython",
|
||||
"version": 3
|
||||
},
|
||||
"file_extension": ".py",
|
||||
"mimetype": "text/x-python",
|
||||
"name": "python",
|
||||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.8.8"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 5
|
||||
}
|
||||
478
representation_construits/chapitre_2/README.ipynb
Normal file
478
representation_construits/chapitre_2/README.ipynb
Normal file
@@ -0,0 +1,478 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "bb1cfae9",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Représentation des données : Les Dictionnaires "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "c09a37ee",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"-------------"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "38d1e9f4",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"> ***Contenue*** : Notions introduites : le type dictionnaire\n",
|
||||
"\n",
|
||||
"> ***Compétences*** : Construire une entrée de dictionnaire, savoir itérer sur es élèments d'un dictionnaire, connaître les méthodes."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "0beaa407",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Le programme"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "dcbf1fd3",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"-----"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "57421c29",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
""
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "401edcc8",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Apport de connaissances"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "717cce94",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"--------"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "0fc298dc",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Les dictionnaires Python permettent d'associer des valeurs à des clés : À partir d'une clé, on peut alors accéder directement à la valeur qui lui est associée."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "607fa703",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Propriétés"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "9e023220",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Les dictionnaires sont des conteneurs, comme les listes et tuples, vus précédemment, et sont mutables : *on peut donc modifier, ajouter ou supprimer du contenu.*\n",
|
||||
"\n",
|
||||
"Par contre, contrairement aux types de conteneurs précédémment étudiés, on ne peut pas accéder au contenu d'un dictionnaire à l'aide d'un indice : un dictionnaire n'est pas une séquence.\n",
|
||||
"\n",
|
||||
"Si on peut bien modifier les valeurs dans un dictionnaire, chaque clé est *unique et non mutable*. Elle peut être une chaîne de caractères, un nombre, un tulle de nombre...\n",
|
||||
"\n",
|
||||
"Enfin, les valeurs, quant à elles, peuvent être quelconques."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "555ca300",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"------"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "21761a39",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Création et accès"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "e219df29",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Pour initialiser un dictionnaire vide : "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 1,
|
||||
"id": "09f0144b",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"dico = {}\n",
|
||||
"#ou\n",
|
||||
"dico = dict()"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "766eeca7",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Pour initialiser un dictionnaire avec des valeurs :"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 3,
|
||||
"id": "8523655d",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"perso = {\"prenom\" : \"Bilbo\", \"age\" : 111}"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "7f350ef3",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"On a donc la clé en premier, ici, prenom & age sont deux chaines de caractères faisant office de clés.\n",
|
||||
"\n",
|
||||
"Accéder à une valeur d'un dictionnaire : on donne la clé à laquelle est associée la valeur recherchée (il faut donc que la clé existe)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 5,
|
||||
"id": "c1124575",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"'Bilbo'"
|
||||
]
|
||||
},
|
||||
"execution_count": 5,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"perso [\"prenom\"]\n",
|
||||
"'Bilbo'"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 6,
|
||||
"id": "094043d5",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"ename": "KeyError",
|
||||
"evalue": "'taille'",
|
||||
"output_type": "error",
|
||||
"traceback": [
|
||||
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
|
||||
"\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)",
|
||||
"\u001b[0;32m/var/folders/nb/7k573f_13zj2tnc5xd0020l40000gn/T/ipykernel_27744/399847934.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mperso\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"taille\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
|
||||
"\u001b[0;31mKeyError\u001b[0m: 'taille'"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"perso[\"taille\"]"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "a29f8a7f",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Tout comme les listes, on peut utiliser la fonction ***len*** pour connaître le nombre de couples stockés."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 7,
|
||||
"id": "1e8c5e32",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"2"
|
||||
]
|
||||
},
|
||||
"execution_count": 7,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"len(perso)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "865d51b5",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"-----"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "a1984b3d",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Modification et parcours"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "dfd2f41e",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
" On ajoute très simplement un couple clé / valeur :"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 8,
|
||||
"id": "24211303",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"{'prenom': 'Bilbo', 'age': 111, 'taille': 112}"
|
||||
]
|
||||
},
|
||||
"execution_count": 8,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"perso [\"taille\"] = 112\n",
|
||||
"perso"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "24fbdfae",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
" Pour modifier une valeur, c'est la même méthode : on ajoute un couple deja existant, et cela va écraser la valeur précédente :"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 9,
|
||||
"id": "83ad4a74",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"{'prenom': 'Bilbo', 'age': 131, 'taille': 112}"
|
||||
]
|
||||
},
|
||||
"execution_count": 9,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"perso[\"age\"] = 131\n",
|
||||
"perso"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "4fa255d5",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Pour supprimer une clé et sa valeur associée, on peut utiliser la fonction ***del***:"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 12,
|
||||
"id": "fc43064d",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"del perso[\"age\"]"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "c9021bee",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"------"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "225cf727",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Comme les listes et les tuples, les dictionnaires sont intérables : on itère sur les clés, les valeurs, ou les couples clé / valeur\n",
|
||||
"\n",
|
||||
"- Itération sur les clés :"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 14,
|
||||
"id": "2be77c4a",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"prenom\n",
|
||||
"taille\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"for cle in perso.keys():\n",
|
||||
" print (cle)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "6a0ddd68",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"- Itération sur les valeurs :"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 15,
|
||||
"id": "534dbdba",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Bilbo\n",
|
||||
"112\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"for val in perso.values():\n",
|
||||
" print(val)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "d77a9b92",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"- Itération sur les couples clé / valeur:"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 16,
|
||||
"id": "21a715ba",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"prenom -> Bilbo\n",
|
||||
"taille -> 112\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"for (cle, val) in perso.items():\n",
|
||||
" print(cle, \"->\", val)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "222e7ae8",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"✏ Par défaut, on itère sur les clés."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "c310b73d",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### À retenir"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "65893b5c",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"| Opération | Résultat |\n",
|
||||
"| ---------------------- | ------------------------------------------------------------ |\n",
|
||||
"| dico[k] | renvoie la valeur associée à la clé k |\n",
|
||||
"| x in dico.values() | renvoie True si une valeur de dico est égale à x, False sinon |\n",
|
||||
"| x not in dico.values() | renvoie True si aucune valeur de dico n'est égale à x, False sinon |\n",
|
||||
"| x in dico.keys() | renvoie True si une clé de dico est égale à x, False sinon |\n",
|
||||
"| dico[k] = v | Modifie la valeur v associée à la clé k ou l'ajoute si elle n'existe pas |\n",
|
||||
"| dico.get(k, v) | Renvoie la valeur associé à la clé k. Si la clé k n'existe pas, renvoie la valeur v |\n",
|
||||
"| del dico(k) | Enlève du dictionnaire la clé k |"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"kernelspec": {
|
||||
"display_name": "Python 3 (ipykernel)",
|
||||
"language": "python",
|
||||
"name": "python3"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": {
|
||||
"name": "ipython",
|
||||
"version": 3
|
||||
},
|
||||
"file_extension": ".py",
|
||||
"mimetype": "text/x-python",
|
||||
"name": "python",
|
||||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.8.8"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 5
|
||||
}
|
||||
131
representation_construits/chapitre_2/README.md
Normal file
131
representation_construits/chapitre_2/README.md
Normal file
@@ -0,0 +1,131 @@
|
||||
## Représentation des données : Les Dictionnaires
|
||||
|
||||
-------------
|
||||
|
||||
> ***Contenue*** : Notions introduites : le type dictionnaire
|
||||
> ***Compétences*** : Construire une entrée de dictionnaire, savoir itérer sur es élèments d'un dictionnaire, connaître les méthodes.
|
||||
|
||||
## Le programme
|
||||
|
||||
-----------
|
||||
|
||||
|
||||
|
||||
## Apport de connaissances
|
||||
|
||||
--------
|
||||
|
||||
Les dictionnaires Python permettent d'associer des valeurs à des clés : À partir d'une clé, on peut alors accéder directement à la valeur qui lui est associée.
|
||||
|
||||
### Propriétés
|
||||
|
||||
Les dictionnaires sont des conteneurs, comme les listes et tuples, vus précédemment, et sont mutables : *on peut donc modifier, ajouter ou supprimer du contenu.*
|
||||
|
||||
Par contre, contrairement aux types de conteneurs précédémment étudiés, on ne peut pas accéder au contenu d'un dictionnaire à l'aide d'un indice : un dictionnaire n'est pas une séquence.
|
||||
|
||||
Si on peut bien modifier les valeurs dans un dictionnaire, chaque clé est *unique et non mutable*. Elle peut être une chaîne de caractères, un nombre, un tulle de nombre...
|
||||
|
||||
Enfin, les valeurs, quant à elles, peuvent être quelconques.
|
||||
|
||||
-----------------
|
||||
|
||||
### Création et accès
|
||||
|
||||
Pour initialiser un dictionnaire vide :
|
||||
|
||||
```python
|
||||
dico = {}
|
||||
#ou
|
||||
dico = dict()
|
||||
```
|
||||
|
||||
Pour initialiser un dictionnaire avec des valeurs :
|
||||
|
||||
```pytho
|
||||
perso = {"prenom" : "Bilbo", "age" : 111}
|
||||
```
|
||||
|
||||
On a donc la clé en premier, ici, prenom & age sont deux chaines de caractères faisant office de clés.
|
||||
|
||||
Accéder à une valeur d'un dictionnaire : on donne la clé à laquelle est associée la valeur recherchée (il faut donc que la clé existe)
|
||||
|
||||
```python
|
||||
perso ["prenom"]
|
||||
'Bilbo'
|
||||
perso["taille"]
|
||||
KeyError "taille"
|
||||
```
|
||||
|
||||
Tout comme les listes, on peut utiliser la fonction ***len*** pour connaître le nombre de couples stockés.
|
||||
|
||||
```python
|
||||
len(perso)
|
||||
2
|
||||
```
|
||||
|
||||
--------------
|
||||
|
||||
### Modification et parcours
|
||||
|
||||
On ajoute très simplement un couple clé / valeur :
|
||||
|
||||
```python
|
||||
perso ["taille"] = 112
|
||||
perso
|
||||
{"prenom" : 'Bilbo', 'age' : 111, 'taille' : 112}
|
||||
```
|
||||
|
||||
Pour modifier une valeur, c'est la même méthode : on ajoute un couple deja existant, et cela va écraser la valeur précédente :
|
||||
|
||||
```python
|
||||
perso["age"] = 131
|
||||
perso
|
||||
{'prenom' : 'Bilbo', 'age' : 131, 'taille' : 112}
|
||||
```
|
||||
|
||||
Pour supprimer une clé et sa valeur associée, on peut utiliser la fonction ***del***:
|
||||
|
||||
```python
|
||||
del perso["age"]
|
||||
```
|
||||
|
||||
-----
|
||||
|
||||
Comme les listes et les tuples, les dictionnaires sont intérables : on itère sur les clés, les valeurs, ou les couples clé / valeur
|
||||
|
||||
- Itération sur les clés :
|
||||
|
||||
```python
|
||||
for cle in perso.keys():
|
||||
print (cle)
|
||||
```
|
||||
|
||||
- Itération sur les valeurs :
|
||||
|
||||
```python
|
||||
for val in perso.values():
|
||||
print(val)
|
||||
```
|
||||
|
||||
- Itération sur les couples clé / valeur:
|
||||
|
||||
```python
|
||||
for (cle, val) in perso.items():
|
||||
print(cle, "->", val)
|
||||
```
|
||||
|
||||
✏ Par défaut, on itère sur les clés.
|
||||
|
||||
--------
|
||||
|
||||
### À retenir
|
||||
|
||||
| Opération | Résultat |
|
||||
| ---------------------- | ------------------------------------------------------------ |
|
||||
| dico[k] | renvoie la valeur associée à la clé k |
|
||||
| x in dico.values() | renvoie True si une valeur de dico est égale à x, False sinon |
|
||||
| x not in dico.values() | renvoie True si aucune valeur de dico n'est égale à x, False sinon |
|
||||
| x in dico.keys() | renvoie True si une clé de dico est égale à x, False sinon |
|
||||
| dico[k] = v | Modifie la valeur v associée à la clé k ou l'ajoute si elle n'existe pas |
|
||||
| dico.get(k, v) | Renvoie la valeur associé à la clé k. Si la clé k n'existe pas, renvoie la valeur v |
|
||||
| del dico(k) | Enlève du dictionnaire la clé k |
|
||||
166
representation_construits/chapitre_2/exercices/CORRECTION.md
Normal file
166
representation_construits/chapitre_2/exercices/CORRECTION.md
Normal file
@@ -0,0 +1,166 @@
|
||||
## Exercice
|
||||
|
||||
### Itérer sur les éléments d'un dictionnaire
|
||||
|
||||
Au zoo de Beauval, il y a 5 éléphants d'Asie, 17 écureuils d'Asie, 7 hippopotames d'Afrique...
|
||||
|
||||
On représente cet inventaire à l'aide d'un dictionnaire, de la façon suivante:
|
||||
|
||||
```python
|
||||
zoo_Beauval = {
|
||||
'elephant' : ('Asie', 5),
|
||||
'ecureuil' : ('Asie', 17),
|
||||
'panda' : ('Asie', 2),
|
||||
'hippopotame' : ('Afrique', 7),
|
||||
'girafe' : ('Afrique', 4)
|
||||
}
|
||||
```
|
||||
|
||||
De la même manière, on peut représenter le zoo de La Flèche :
|
||||
|
||||
```python
|
||||
zoo_LaFleche = {
|
||||
'ours' : ('Europe', 4),
|
||||
'tigre' : ('Asie', 7),
|
||||
'girafe' : ('Afrique', 11),
|
||||
'hippopotame' : ('Afrique', 3)
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
|
||||
#### Question n°1
|
||||
|
||||
On souhaite créer une fonction *plus_grand_nombre* ( ) qui prend un zoo en paramètre et renvoie le nom de l'animal le plus présent au sein du zoo.
|
||||
|
||||
Exemples :
|
||||
|
||||
```python
|
||||
>> plus_grand_nombre(zoo_LaFleche)
|
||||
>> 'girafe'
|
||||
```
|
||||
|
||||
```python
|
||||
>> plus_grand_nombre(zoo_Beauval)
|
||||
>> 'ecureuil'
|
||||
```
|
||||
|
||||
On aura besoin d'une boucle utilisant
|
||||
|
||||
```python
|
||||
for (cle, valeur) in dico.items()
|
||||
```
|
||||
|
||||
À votre avis, pourquoi ?
|
||||
|
||||
**Nous avons besoin à la fois des clés ainsi que des valeurs**
|
||||
|
||||
Écrire la fonction :
|
||||
|
||||
```python
|
||||
def plus_grand_nombre(zoo):
|
||||
"""
|
||||
:param: zoo est un dictionnaire dont les clés sont des str (noms des animaux)
|
||||
:param: les valeurs de ces clés sont des tuples (origine, nombre) avec origine : str et nombre : int
|
||||
:return: le nom de l'animal le plus représenté dans le zoo, sous la forme d'une chaîne de caractères
|
||||
"""
|
||||
|
||||
nom_max = 0
|
||||
nombre_max = 0
|
||||
for (nom, (x, nombre)) in zoo.items():
|
||||
if nombre > nombre_max:
|
||||
nom_max = nom
|
||||
nombre_max = nombre
|
||||
return nom_max
|
||||
```
|
||||
|
||||
|
||||
|
||||
Note : ici, la variable **x** fait référence à une donnée que nous n'utilisons pas.
|
||||
|
||||
#### Question n°2
|
||||
|
||||
On souhaite se doter d'une fonction *nombre_total* ( ) qui prend un zoo ainsi que le nom d'un continent en paramètre, et qui renvoie le nombre d'animaux originaires de ce continent dans le zoo.
|
||||
|
||||
Exemples :
|
||||
|
||||
```python
|
||||
>> nombre_total(zoo_LaFleche, 'Afrique')
|
||||
>> 14
|
||||
```
|
||||
|
||||
```python
|
||||
>> nombre_total(zoo_Beauval, 'Asie')
|
||||
>> 24
|
||||
```
|
||||
|
||||
On utilisera une boucle
|
||||
|
||||
```python
|
||||
for valeur in dico.values()
|
||||
```
|
||||
|
||||
Pourquoi ?
|
||||
|
||||
**Parce que l'on a uniquement besoin des valeurs, l'espèce animal n'est pas importante**
|
||||
|
||||
Écrire la fonction :
|
||||
|
||||
```python
|
||||
def nombre_total(zoo, continent):
|
||||
"""
|
||||
:param: zoo est un dictionnaire dont les clés sont des chaines, correspondantes aux noms des animaux
|
||||
:param: et dont les valeurs sont des tuples (origine, nombre), origine étant une chaine, nombre un int
|
||||
:param: continent est une chaine comprenant le nom d'un continent d'où sont originaires les animaux
|
||||
:return: la fonction renvoie le nombre d'animaux originaires de 'continent' dans ce zoo
|
||||
"""
|
||||
|
||||
|
||||
total = 0
|
||||
for (origine, nombre) in zoo.values():
|
||||
if continent == origine:
|
||||
total = total + nombre
|
||||
return total
|
||||
```
|
||||
|
||||
|
||||
|
||||
#### Question n°3
|
||||
|
||||
Enfin, on souhaite écrire une fonction nombre, qui prendun zoo ainsi qu'un nom d'animal en paramètre, et qui renvoie le nombre de représentants de cet animal dans le zoo.
|
||||
|
||||
Exemples :
|
||||
|
||||
````python
|
||||
>> nombre(zoo_LaFleche, 'panda')
|
||||
>> 0
|
||||
````
|
||||
|
||||
```python
|
||||
>> nombre(zoo_Beauval, 'panda')
|
||||
>> 2
|
||||
```
|
||||
|
||||
|
||||
|
||||
Quel type de boucle va t-on utiliser ici ?
|
||||
|
||||
**Aucune, car nous n'avons uniquement besoin que de la clé, qui est un paramètre de la fonction.**
|
||||
|
||||
Écrire la fonction
|
||||
|
||||
```python
|
||||
def nombre(zoo, animal):
|
||||
"""
|
||||
:param: zoo est un dictionnaire dont les clés sont des chaines, correspondantes aux noms des animaux
|
||||
:param: et dont les valeurs sont des tuples (origine, nombre), origine étant une chaine, nombre un int
|
||||
:param: animal est une chaine comprenant le nom d'un animal
|
||||
:return: la fonction renvoie le nombre de représentants du paramètre 'animal' dans ce zoo
|
||||
"""
|
||||
|
||||
if animal not in zoo.keys():
|
||||
return 0
|
||||
else:
|
||||
return zoo[animal][1]
|
||||
```
|
||||
|
||||
@@ -0,0 +1,80 @@
|
||||
## Exercice n°2
|
||||
|
||||
|
||||
|
||||
Pour remplir le pokedex de Sacha, on modélise les informations sur les Pokemons de la façon suivante :
|
||||
|
||||
```python
|
||||
liste_pokemons = {
|
||||
'Bulbizarre' : (70, 7),
|
||||
'Herbizarre' : (100,13),
|
||||
'Abo' : (200, 7),
|
||||
'Pikachu' : (40, 6)
|
||||
}
|
||||
```
|
||||
|
||||
Les tuples représentent la taille en centimètres, ainsi que le poids en kilogramme du Pokemon.
|
||||
|
||||
#### Questions :
|
||||
|
||||
- Quel est le type de *liste_pokemons* ?
|
||||
- **Il s'agit d'un dictionnaire, dont les clés sont des chaines de caractères représentant les nomsdes Pokemons, et les valeurs des tuples de deux entiers correspondant à la taille en cm et au poids en kg**
|
||||
|
||||
- Quelle instruction permet d'ajouter à cette structure de données le Pokemon Goupil qui mesure 60 cm et pèse 10 kg ?
|
||||
- **liste_pokemons["Goupix"] = (60, 10)**
|
||||
|
||||
On donne le code suivant :
|
||||
|
||||
```python
|
||||
def le_plus_grand(pokemons):
|
||||
grand = None
|
||||
taille_max = None
|
||||
for (nom,(taille, poids)) in pokemons.items():
|
||||
taille_max = taille
|
||||
grand = nom
|
||||
return(grand,taille_max)
|
||||
```
|
||||
|
||||
- Quelle est la valeur de *le_plus_grand(liste_pokemons)* ?
|
||||
- **Il s'agira du nom et de la taille du Pokemon le plus grand rencontré dans le dictionnaire (en cas d'égalité, il s'agira du premier Pokémon rencontré) sous la forme d'un tuple**
|
||||
|
||||
- Écrire le code d'une fonction *le_plus_leger(liste_pokemons)* qui prend des Pokémons en paramètre et renvoie un tuple correspondant au nom ainsi qu'au poids de Pokémon le plus léger.
|
||||
|
||||
```python
|
||||
>> le_plus_leger(liste_pokemons)
|
||||
>> ('Pikachu', 6)
|
||||
```
|
||||
|
||||
```python
|
||||
def le_plus_leger(liste_pokemons):
|
||||
leger = None
|
||||
poids_min = None
|
||||
for (nom, (taille, poids)) in liste_pokemons.items():
|
||||
if poids_min > poids
|
||||
poids_min = poids
|
||||
leger = nom
|
||||
return (leger, poids_min)
|
||||
```
|
||||
|
||||
|
||||
|
||||
- Écrire une fonction *taille* qui prend en paramère un dictionnaire de Pokémons ainsi que le nom d'un Pokémon, et qui renvoie la taille de ce Pokémon.
|
||||
|
||||
```python
|
||||
>> taille(liste_pokemons, 'Abo')
|
||||
>> 200
|
||||
```
|
||||
|
||||
```python
|
||||
>> taille(liste_pokemons, 'Dracaufeu')
|
||||
>> None
|
||||
```
|
||||
|
||||
```python
|
||||
def taille(liste_pokemons, nom):
|
||||
if noms in liste_pokemons:
|
||||
return pokemon[nom][0]
|
||||
else:
|
||||
return None
|
||||
```
|
||||
|
||||
148
representation_construits/chapitre_2/exercices/README.md
Normal file
148
representation_construits/chapitre_2/exercices/README.md
Normal file
@@ -0,0 +1,148 @@
|
||||
## Exercice
|
||||
|
||||
### Itérer sur les éléments d'un dictionnaire
|
||||
|
||||
Au zoo de Beauval, il y a 5 éléphants d'Asie, 17 écureuils d'Asie, 7 hippopotames d'Afrique...
|
||||
|
||||
On représente cet inventaire à l'aide d'un dictionnaire, de la façon suivante:
|
||||
|
||||
```python
|
||||
zoo_Beauval = {
|
||||
'elephant' : ('Asie', 5),
|
||||
'ecureuil' : ('Asie', 17),
|
||||
'panda' : ('Asie', 2),
|
||||
'hippopotame' : ('Afrique', 7),
|
||||
'girafe' : ('Afrique', 4)
|
||||
}
|
||||
```
|
||||
|
||||
De la même manière, on peut représenter le zoo de La Flèche :
|
||||
|
||||
```python
|
||||
zoo_LaFleche = {
|
||||
'ours' : ('Europe', 4),
|
||||
'tigre' : ('Asie', 7),
|
||||
'girafe' : ('Afrique', 11),
|
||||
'hippopotame' : ('Afrique', 3)
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
|
||||
#### Question n°1
|
||||
|
||||
On souhaite créer une fonction *plus_grand_nombre* ( ) qui prend un zoo en paramètre et renvoie le nom de l'animal le plus présent au sein du zoo.
|
||||
|
||||
Exemples :
|
||||
|
||||
```python
|
||||
>> plus_grand_nombre(zoo_LaFleche)
|
||||
>> 'girafe'
|
||||
```
|
||||
|
||||
```python
|
||||
>> plus_grand_nombre(zoo_Beauval)
|
||||
>> 'ecureuil'
|
||||
```
|
||||
|
||||
On aura besoin d'une boucle utilisant
|
||||
|
||||
```python
|
||||
for (cle, valeur) in dico.items()
|
||||
```
|
||||
|
||||
À votre avis, pourquoi ?
|
||||
|
||||
|
||||
|
||||
Écrire la fonction :
|
||||
|
||||
```python
|
||||
def plus_grand_nombre(zoo):
|
||||
"""
|
||||
:param: zoo est un dictionnaire dont les clés sont des str (noms des animaux)
|
||||
:param: les valeurs de ces clés sont des tuples (origine, nombre) avec origine : str et nombre : int
|
||||
:return: le nom de l'animal le plus représenté dans le zoo, sous la forme d'une chaîne de caractères
|
||||
"""
|
||||
|
||||
pass
|
||||
```
|
||||
|
||||
|
||||
|
||||
#### Question n°2
|
||||
|
||||
On souhaite se doter d'une fonction *nombre_total* ( ) qui prend un zoo ainsi que le nom d'un continent en paramètre, et qui renvoie le nombre d'animaux originaires de ce continent dans le zoo.
|
||||
|
||||
Exemples :
|
||||
|
||||
```python
|
||||
>> nombre_total(zoo_LaFleche, 'Afrique')
|
||||
>> 14
|
||||
```
|
||||
|
||||
```python
|
||||
>> nombre_total(zoo_Beauval, 'Asie')
|
||||
>> 24
|
||||
```
|
||||
|
||||
On utilisera une boucle
|
||||
|
||||
```python
|
||||
for valeur in dico.values()
|
||||
```
|
||||
|
||||
Pourquoi ?
|
||||
|
||||
|
||||
|
||||
Écrire la fonction :
|
||||
|
||||
```python
|
||||
def nombre_total(zoo, continent):
|
||||
"""
|
||||
:param: zoo est un dictionnaire dont les clés sont des chaines, correspondantes aux noms des animaux
|
||||
:param: et dont les valeurs sont des tuples (origine, nombre), origine étant une chaine, nombre un int
|
||||
:param: continent est une chaine comprenant le nom d'un continent d'où sont originaires les animaux
|
||||
:return: la fonction renvoie le nombre d'animaux originaires de 'continent' dans ce zoo
|
||||
"""
|
||||
|
||||
pass
|
||||
```
|
||||
|
||||
|
||||
|
||||
#### Question n°3
|
||||
|
||||
Enfin, on souhaite écrire une fonction nombre, qui prendun zoo ainsi qu'un nom d'animal en paramètre, et qui renvoie le nombre de représentants de cet animal dans le zoo.
|
||||
|
||||
Exemples :
|
||||
|
||||
````python
|
||||
>> nombre(zoo_LaFleche, 'panda')
|
||||
>> 0
|
||||
````
|
||||
|
||||
```python
|
||||
>> nombre(zoo_Beauval, 'panda')
|
||||
>> 2
|
||||
```
|
||||
|
||||
|
||||
|
||||
Quel type de boucle va t-on utiliser ici ?
|
||||
|
||||
Écrire la fonction
|
||||
|
||||
```python
|
||||
def nombre(zoo, animal):
|
||||
"""
|
||||
:param: zoo est un dictionnaire dont les clés sont des chaines, correspondantes aux noms des animaux
|
||||
:param: et dont les valeurs sont des tuples (origine, nombre), origine étant une chaine, nombre un int
|
||||
:param: animal est une chaine comprenant le nom d'un animal
|
||||
:return: la fonction renvoie le nombre de représentants du paramètre 'animal' dans ce zoo
|
||||
"""
|
||||
|
||||
pass
|
||||
```
|
||||
|
||||
58
representation_construits/chapitre_2/exercices/README_2.md
Normal file
58
representation_construits/chapitre_2/exercices/README_2.md
Normal file
@@ -0,0 +1,58 @@
|
||||
## Exercice n°2
|
||||
|
||||
|
||||
|
||||
Pour remplir le pokedex de Sacha, on modélise les informations sur les Pokemons de la façon suivante :
|
||||
|
||||
```python
|
||||
liste_pokemons = {
|
||||
'Bulbizarre' : (70, 7),
|
||||
'Herbizarre' : (100,13),
|
||||
'Abo' : (200, 7),
|
||||
'Pikachu' : (40, 6)
|
||||
}
|
||||
```
|
||||
|
||||
Les tuples représentent la taille en centimètres, ainsi que le poids en kilogramme du Pokemon.
|
||||
|
||||
#### Questions :
|
||||
|
||||
- Quel est le type de *liste_pokemons* ?
|
||||
|
||||
- Quelle instruction permet d'ajouter à cette structure de données le Pokemon Goupil qui mesure 60 cm et pèse 10 kg ?
|
||||
|
||||
On donne le code suivant :
|
||||
|
||||
```python
|
||||
def le_plus_grand(pokemons):
|
||||
grand = None
|
||||
taille_max = None
|
||||
for (nom,(taille, poids)) in pokemons.items():
|
||||
taille_max = taille
|
||||
grand = nom
|
||||
return(grand,taille_max)
|
||||
```
|
||||
|
||||
- Quelle est la valeur de *le_plus_grand(liste_pokemons)* ?
|
||||
|
||||
- Écrire le code d'une fonction *le_plus_leger(liste_pokemons)* qui prend des Pokémons en paramètre et renvoie un tuple correspondant au nom ainsi qu'au poids de Pokémon le plus léger.
|
||||
|
||||
```python
|
||||
>> le_plus_leger(liste_pokemons)
|
||||
>> ('Pikachu', 6)
|
||||
```
|
||||
|
||||
|
||||
|
||||
- Écrire une fonction *taille* qui prend en paramère un dictionnaire de Pokémons ainsi que le nom d'un Pokémon, et qui renvoie la taille de ce Pokémon.
|
||||
|
||||
```python
|
||||
>> taille(liste_pokemons, 'Abo')
|
||||
>> 200
|
||||
```
|
||||
|
||||
```python
|
||||
>> taille(liste_pokemons, 'Dracaufeu')
|
||||
>> None
|
||||
```
|
||||
|
||||
279
representation_construits/chapitre_2/td/TD.ipynb
Normal file
279
representation_construits/chapitre_2/td/TD.ipynb
Normal file
@@ -0,0 +1,279 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# TD - Les dictionnaires"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Exercice 1 - Fruits\n",
|
||||
"\n",
|
||||
"On considère le dictionnaire suivant qui contient différents fruits ainsi que leurs quantités."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"fruits = {\"pommes\": 8, \"melons\": 3, \"poires\": 6}"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"1. Quelle instruction permet d'accéder au nombre de melons ?"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"2. On a acheté 16 clémentines et utilisé 4 pommes pour faire une tarte. Quelles instructions permettent de mettre à jour le dictionnaire ?"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Exercice 2 - Encore des fruits"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Répondez aux questions suivantes __sans exécuter les scripts proposés__. \n",
|
||||
"\n",
|
||||
"_Vous les exécuterez pour vérifier vos réponses._\n",
|
||||
"\n",
|
||||
"1. Qu'affiche le programme suivant ?\n",
|
||||
"```python\n",
|
||||
"fruits = {'pommes': 4, 'melons': 3, 'poires': 6, 'clémentines': 16}\n",
|
||||
"for c in fruits.keys():\n",
|
||||
" print(c)\n",
|
||||
"```\n",
|
||||
"2. Qu'affiche le programme suivant ?\n",
|
||||
"```python\n",
|
||||
"fruits = {'pommes': 4, 'melons': 3, 'poires': 6, 'clémentines': 16}\n",
|
||||
"for cle, valeur in fruits.items():\n",
|
||||
" print(cle, \"->\", valeur)\n",
|
||||
"```\n",
|
||||
"3. Qu'affiche le programme suivant ?\n",
|
||||
"```python\n",
|
||||
"fruits = {'pommes': 4, 'melons': 3, 'poires': 6, 'clémentines': 16}\n",
|
||||
"for v in fruits.values():\n",
|
||||
" print(v)\n",
|
||||
"```"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Exercice 3 - Agenda\n",
|
||||
"\n",
|
||||
"Dans un agenda, un contact est modélisé par un dictionnaire :\n",
|
||||
"\n",
|
||||
"- La clé du dictionnaire est le nom des contacts. \n",
|
||||
"- La valeur du dictionnaire est un tuple dont la première valeur est leur âge (type int) et la seconde leur ville natale (str).\n",
|
||||
"\n",
|
||||
"Voici une petite liste de contact :\n",
|
||||
"\n",
|
||||
"* Pierre a 37 ans et est né à Lille.\n",
|
||||
"* Zoé a 21 ans et est née à Nice.\n",
|
||||
"* Ali a 54 ans et est né à Bordeaux.\n",
|
||||
"* Aymeric a 72 ans et est né à Nice.\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"1. Définissez le dictionnaire de contacts.\n",
|
||||
"2. Donnez les commandes pour :\n",
|
||||
" 1. accéder à l'âge de Zoé\n",
|
||||
" 2. accéder à la ville natale d'Ali.\n",
|
||||
" 3. décider si 'Jean' est dans le dictionnaire ou pas.\n",
|
||||
"3. Écrire le prédicat `est_present(dic, nom)` qui renvoie `True` si le _nom_ est présent dans le dictionnaire _dic_ e t`False` sinon.\n",
|
||||
"\n",
|
||||
"4. Écrire la fonction `renvoyer_age(dic, nom)` qui, si le _nom_ est présent dans le dictionnaire _dic_, renvoie son âge.\n",
|
||||
"\n",
|
||||
"5. Écrire la fonction `renvoyer_ville(dic, nom)` qui, si le _nom_ est présent dans le dictionnaire _dic_, renvoie sa ville natale.\n",
|
||||
"\n",
|
||||
"6. Écrire la fonction `renvoyer_noms(dic, ville)` qui renvoie un tableau de tous les noms dont la ville de naissance est _ville_.\n",
|
||||
"\n",
|
||||
"7. Écrire la procédure `ajouter(dic, nom, age, ville)` qui, si le _nom_ est n'est pas présent dans le dictionnaire _dic_, l'y ajoute.\n",
|
||||
"\n",
|
||||
"> _Remarques :_\n",
|
||||
">\n",
|
||||
"> * Documentez les fonction\n",
|
||||
"> * Réalisez les doctests significatifs."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 1\n",
|
||||
"\n",
|
||||
"# Question 2.A\n",
|
||||
"\n",
|
||||
"# Question 2.B\n",
|
||||
"\n",
|
||||
"# Question 2.C\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 3"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 4"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 5"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 6"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 7"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Exercice 4 - le SCRABBLE\n",
|
||||
"\n",
|
||||
"Voici un descriptif des valeurs des lettres au scrabble français. \n",
|
||||
"\n",
|
||||
"- 0 point : **Joker** ×2 (appelés en français *jokers* ou *lettres blanches*)\n",
|
||||
"- *1 point* : **E** ×15, **A** ×9, **I** ×8, **N** ×6, **O** ×6, **R** ×6, **S** ×6, **T** ×6, **U** ×6, **L** ×5\n",
|
||||
"- *2 points* : **D** ×3, **M** ×3, **G** ×2\n",
|
||||
"- *3 points* : **B** ×2, **C** ×2, **P** ×2\n",
|
||||
"- *4 points* : **F** ×2, **H** ×2, **V** ×2\n",
|
||||
"- *8 points* : **J** ×1, **Q** ×1\n",
|
||||
"- *10 points* : **K** ×1, **W** ×1, **X** ×1, **Y** ×1, **Z** ×1\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"1. Définissez un dictionnaire _score_ qui prend les lettres majuscules en clés et leur score en valeur\n",
|
||||
"2. Écrire une fonction `calculer_score` qui prend une chaîne de caractère _mot_ en paramètre et renvoie le score du mot s'il est possible de l'écrire avec les lettres du scrabble et `None` sinon.\n",
|
||||
"3. Écrire une fonction `calculer_scores` qui prend un tableau de _mots_ et renvoie un tableau de score de chaque mot.\n",
|
||||
"\n",
|
||||
"> _Remarques :_\n",
|
||||
">\n",
|
||||
"> * Documentez la fonction\n",
|
||||
"> * Réalisez les doctests significatifs.\n",
|
||||
"> * Pour tester vos fonctions, il est possible d'utiliser la liste de mots suivante :\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"liste_mots = ['extenue', 'ligner', 'serier', 'delasse', 'doperas', 'drapes', 'gelee', 'doucir', 'lamparo', 'salee', 'gueri', 'mulots', 'trolley', 'houppe', 'hesitez', 'vogues', 'embelli', 'etonnez', 'mers', 'riviere', 'risquer', 'grogner', 'postale', 'beler', 'lofer', 'rincent', 'boni', 'charter', 'censeur', 'glaise','sauts', 'striee', 'perclus', 'dessous', 'tireras', 'gommant', 'cooptes', 'bombyx', 'gauches', 'filiere', 'devoree', 'viriez', 'murit', 'miteux', 'empenne', 'soudez', 'cochers', 'dejoua', 'tuer', 'present']\n",
|
||||
"```"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 1"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 2"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 3"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"kernelspec": {
|
||||
"display_name": "Python 3",
|
||||
"language": "python",
|
||||
"name": "python3"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": {
|
||||
"name": "ipython",
|
||||
"version": 3
|
||||
},
|
||||
"file_extension": ".py",
|
||||
"mimetype": "text/x-python",
|
||||
"name": "python",
|
||||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.9.7"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 2
|
||||
}
|
||||
394
representation_construits/chapitre_2/td/correction.ipynb
Normal file
394
representation_construits/chapitre_2/td/correction.ipynb
Normal file
@@ -0,0 +1,394 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# TD - Les dictionnaires"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Exercice 1 - Fruits\n",
|
||||
"\n",
|
||||
"On considère le dictionnaire suivant qui contient différents fruits ainsi que leurs quantités."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 1,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"fruits = {\"pommes\": 8, \"melons\": 3, \"poires\": 6}"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"1. Quelle instruction permet d'accéder au nombre de melons ?"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"fruits['melons']"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"2. On a acheté 16 clémentines et utilisé 4 pommes pour faire une tarte. Quelles instructions permettent de mettre à jour le dictionnaire ?"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"fruits['clementines'] = 16\n",
|
||||
"fruits['pommes'] = fruits['pommes'] - 4"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Exercice 2 - Encore des fruits"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Répondez aux questions suivantes __sans exécuter les scripts proposés__. \n",
|
||||
"\n",
|
||||
"_Vous les exécuterez pour vérifier vos réponses._\n",
|
||||
"\n",
|
||||
"1. Qu'affiche le programme suivant ?\n",
|
||||
"```python\n",
|
||||
"fruits = {'pommes': 4, 'melons': 3, 'poires': 6, 'clémentines': 16}\n",
|
||||
"for c in fruits.keys():\n",
|
||||
" print(c)\n",
|
||||
"```\n",
|
||||
"2. Qu'affiche le programme suivant ?\n",
|
||||
"```python\n",
|
||||
"fruits = {'pommes': 4, 'melons': 3, 'poires': 6, 'clémentines': 16}\n",
|
||||
"for cle, valeur in fruits.items():\n",
|
||||
" print(cle, \"->\", valeur)\n",
|
||||
"```\n",
|
||||
"3. Qu'affiche le programme suivant ?\n",
|
||||
"```python\n",
|
||||
"fruits = {'pommes': 4, 'melons': 3, 'poires': 6, 'clémentines': 16}\n",
|
||||
"for v in fruits.values():\n",
|
||||
" print(v)\n",
|
||||
"```"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Exercice 3 - Agenda\n",
|
||||
"\n",
|
||||
"Dans un agenda, un contact est modélisé par un dictionnaire :\n",
|
||||
"\n",
|
||||
"- La clé du dictionnaire est le nom des contacts. \n",
|
||||
"- La valeur du dictionnaire est un tuple dont la première valeur est leur âge (type int) et la seconde leur ville natale (str).\n",
|
||||
"\n",
|
||||
"Voici une petite liste de contact :\n",
|
||||
"\n",
|
||||
"* Pierre a 37 ans et est né à Lille.\n",
|
||||
"* Zoé a 21 ans et est née à Nice.\n",
|
||||
"* Ali a 54 ans et est né à Bordeaux.\n",
|
||||
"* Aymeric a 72 ans et est né à Nice.\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"1. Définissez le dictionnaire de contacts.\n",
|
||||
"2. Donnez les commandes pour :\n",
|
||||
" 1. accéder à l'âge de Zoé\n",
|
||||
" 2. accéder à la ville natale d'Ali.\n",
|
||||
" 3. décider si 'Jean' est dans le dictionnaire ou pas.\n",
|
||||
"3. Écrire le prédicat `est_present(dic, nom)` qui renvoie `True` si le _nom_ est présent dans le dictionnaire _dic_ e t`False` sinon.\n",
|
||||
"\n",
|
||||
"4. Écrire la fonction `renvoyer_age(dic, nom)` qui, si le _nom_ est présent dans le dictionnaire _dic_, renvoie son âge.\n",
|
||||
"\n",
|
||||
"5. Écrire la fonction `renvoyer_ville(dic, nom)` qui, si le _nom_ est présent dans le dictionnaire _dic_, renvoie sa ville natale.\n",
|
||||
"\n",
|
||||
"6. Écrire la fonction `renvoyer_noms(dic, ville)` qui renvoie un tableau de tous les noms dont la ville de naissance est _ville_.\n",
|
||||
"\n",
|
||||
"7. Écrire la procédure `ajouter(dic, nom, age, ville)` qui, si le _nom_ est n'est pas présent dans le dictionnaire _dic_, l'y ajoute.\n",
|
||||
"\n",
|
||||
"> _Remarques :_\n",
|
||||
">\n",
|
||||
"> * Documentez les fonction\n",
|
||||
"> * Réalisez les doctests significatifs."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 1,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"21\n",
|
||||
"Bordeaux\n",
|
||||
"False\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# Question 1\n",
|
||||
"contacts = { 'Pierre' : (37, 'Lille'), 'Zoé' : (21, 'Nice'), 'Ali' : (54, 'Bordeaux'), 'Aymeric' : (72, 'Lorient')}\n",
|
||||
"\n",
|
||||
"# Question 2.A\n",
|
||||
"print(contacts['Zoé'][0])\n",
|
||||
"\n",
|
||||
"# Question 2.B\n",
|
||||
"print(contacts['Ali'][1])\n",
|
||||
"\n",
|
||||
"# Question 2.C\n",
|
||||
"print('Jean' in contacts)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 3\n",
|
||||
"def est_present(dic, nom):\n",
|
||||
" '''\n",
|
||||
" Détermine si un nom est présent dans le dictionnaire\n",
|
||||
" :param dic: (dict) un dictionnaire\n",
|
||||
" :param nom: (str) un nom de contact\n",
|
||||
" :return: (bool) True si le nom est dans le dictionnaire, False sinon\n",
|
||||
" :doctest:\n",
|
||||
" >>> est_present({}, 'Thomas')\n",
|
||||
" False\n",
|
||||
" >>> est_present({ 'Thomas' : (15, 'Cannes')}, 'Thomas')\n",
|
||||
" True\n",
|
||||
" >>> est_present({ 'Tham' : (15, 'Cannes')}, 'Thomas')\n",
|
||||
" False\n",
|
||||
" '''\n",
|
||||
" return nom in dic"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 4\n",
|
||||
"def renvoyer_age(dic, nom):\n",
|
||||
" '''\n",
|
||||
" Renvoie l'âge du contact, s'il est présent dans le dictionnaire\n",
|
||||
" :param dic: (dict) un dictionnaire\n",
|
||||
" :param nom: (str) un nom de contact\n",
|
||||
" :return: (int) L'âge du contact\n",
|
||||
" :doctest:\n",
|
||||
" >>> renvoyer_age({}, 'Thomas')\n",
|
||||
" None\n",
|
||||
" >>> renvoyer_age({ 'Thomas' : (15, 'Cannes')}, 'Thomas')\n",
|
||||
" 15\n",
|
||||
" '''\n",
|
||||
" if est_present(dic, nom):\n",
|
||||
" return dic[nom][0]\n",
|
||||
" return None"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 5\n",
|
||||
"def renvoyer_ville(dic, nom):\n",
|
||||
" '''\n",
|
||||
" Renvoie la ville natale du contact, s'il est présent dans le dictionnaire\n",
|
||||
" :param dic: (dict) un dictionnaire\n",
|
||||
" :param nom: (str) un nom de contact\n",
|
||||
" :return: (str) La ville natale du contact\n",
|
||||
" :doctest:\n",
|
||||
" >>> renvoyer_ville({}, 'Thomas')\n",
|
||||
" None\n",
|
||||
" >>> renvoyer_ville({ 'Thomas' : (15, 'Cannes')}, 'Thomas')\n",
|
||||
" 'Cannes'\n",
|
||||
" '''\n",
|
||||
" if est_present(dic, nom):\n",
|
||||
" return dic[nom][1]\n",
|
||||
" return None"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 6\n",
|
||||
"def renvoyer_noms(dic, ville):\n",
|
||||
" '''\n",
|
||||
" Renvoie un tableau de tous les noms dont la ville de naissance est ville\n",
|
||||
" :param dic: (dict) un dictionnaire\n",
|
||||
" :param ville: (str) ville natale des contacts\n",
|
||||
" :return: (list) tableau de tous les noms de contacts nés dans la ville\n",
|
||||
" :doctest:\n",
|
||||
" >>> renvoyer_noms({}, 'Nice')\n",
|
||||
" []\n",
|
||||
" >>> renvoyer_noms({ 'Pierre' : (37, 'Lille'), 'Zoé' : (21, 'Nice'), 'Ali' : (54, 'Bordeaux'), 'Aymeric' : (72, 'Lorient')}\n",
|
||||
", 'Nice')\n",
|
||||
" ['Zoé', 'Aymeric']\n",
|
||||
" '''\n",
|
||||
" noms = []\n",
|
||||
" for contact in dic:\n",
|
||||
" if dic[contact][1] == ville:\n",
|
||||
" noms.append(contact)\n",
|
||||
" return noms"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 7\n",
|
||||
"def ajouter(dic, nom, age, ville):\n",
|
||||
" '''\n",
|
||||
" Ajoute un contact s'il n'est pas présent dans le dictionnaire\n",
|
||||
" :param dic: (dict) un dictionnaire\n",
|
||||
" :param nom: (str) nom du contact\n",
|
||||
" :param age: (int) age du contact\n",
|
||||
" :param ville: (str) ville natale du contact\n",
|
||||
" :return: (None)\n",
|
||||
" :Effet de bord: Ajoute le contact au dictionnaire\n",
|
||||
" '''\n",
|
||||
" if not est_present(dic, nom):\n",
|
||||
" dic[nom] = (age, ville)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Exercice 4 - le SCRABBLE\n",
|
||||
"\n",
|
||||
"Voici un descriptif des valeurs des lettres au scrabble français. \n",
|
||||
"\n",
|
||||
"- 0 point : **Joker** ×2 (appelés en français *jokers* ou *lettres blanches*)\n",
|
||||
"- *1 point* : **E** ×15, **A** ×9, **I** ×8, **N** ×6, **O** ×6, **R** ×6, **S** ×6, **T** ×6, **U** ×6, **L** ×5\n",
|
||||
"- *2 points* : **D** ×3, **M** ×3, **G** ×2\n",
|
||||
"- *3 points* : **B** ×2, **C** ×2, **P** ×2\n",
|
||||
"- *4 points* : **F** ×2, **H** ×2, **V** ×2\n",
|
||||
"- *8 points* : **J** ×1, **Q** ×1\n",
|
||||
"- *10 points* : **K** ×1, **W** ×1, **X** ×1, **Y** ×1, **Z** ×1\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"1. Définissez un dictionnaire _score_ qui prend les lettres majuscules en clés et leur score en valeur\n",
|
||||
"2. Écrire une fonction `calculer_score` qui prend une chaîne de caractère _mot_ en paramètre et renvoie le score du mot s'il est possible de l'écrire avec les lettres du scrabble et `None` sinon.\n",
|
||||
"3. Écrire une fonction `calculer_scores` qui prend un tableau de _mots_ et renvoie un tableau de score de chaque mot.\n",
|
||||
"\n",
|
||||
"> _Remarques :_\n",
|
||||
">\n",
|
||||
"> * Documentez la fonction\n",
|
||||
"> * Réalisez les doctests significatifs.\n",
|
||||
"> * Pour tester vos fonctions, il est possible d'utiliser la liste de mots suivante :\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"liste_mots = ['extenue', 'ligner', 'serier', 'delasse', 'doperas', 'drapes', 'gelee', 'doucir', 'lamparo', 'salee', 'gueri', 'mulots', 'trolley', 'houppe', 'hesitez', 'vogues', 'embelli', 'etonnez', 'mers', 'riviere', 'risquer', 'grogner', 'postale', 'beler', 'lofer', 'rincent', 'boni', 'charter', 'censeur', 'glaise','sauts', 'striee', 'perclus', 'dessous', 'tireras', 'gommant', 'cooptes', 'bombyx', 'gauches', 'filiere', 'devoree', 'viriez', 'murit', 'miteux', 'empenne', 'soudez', 'cochers', 'dejoua', 'tuer', 'present']\n",
|
||||
"```"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 1\n",
|
||||
"score = {'A' : 1, 'B' : 3, 'C': 3, 'D': 2, 'E' : 1, 'F' : 4, 'G': 2, 'H': 4, 'I': 1, 'J': 8, 'K': 10, 'L': 1, 'M': 2, 'N': 1, 'O': 1, 'P': 3, 'Q': 8, 'R': 1, 'S': 1, 'T': 1, 'U': 1, 'V': 4, 'W': 10, 'X': 10, 'Y': 10, 'Z': 10}"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 2\n",
|
||||
"def calculer_score(mot):\n",
|
||||
" '''\n",
|
||||
" Détermine le score d'un mot\n",
|
||||
" :param mot: (str) un mot\n",
|
||||
" :return: (int) Le score du mot\n",
|
||||
" '''\n",
|
||||
" _score = 0\n",
|
||||
" for lettre in mot.upper():\n",
|
||||
" _score += score[lettre]\n",
|
||||
" return _score"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Question 3\n",
|
||||
"def calculer_scores(mots):\n",
|
||||
" '''\n",
|
||||
" Détermine les scores d'un tableau de mots\n",
|
||||
" :param mot: (str) un mot\n",
|
||||
" :return: (list) Le tableau des scores des mots\n",
|
||||
" '''\n",
|
||||
" scores = []\n",
|
||||
" for mot in mots:\n",
|
||||
" scores.append(calculer_score(mot))\n",
|
||||
" return scores"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"kernelspec": {
|
||||
"display_name": "Python 3",
|
||||
"language": "python",
|
||||
"name": "python3"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": {
|
||||
"name": "ipython",
|
||||
"version": 3
|
||||
},
|
||||
"file_extension": ".py",
|
||||
"mimetype": "text/x-python",
|
||||
"name": "python",
|
||||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.9.7"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 2
|
||||
}
|
||||
Reference in New Issue
Block a user