diff --git a/cours/source/08-dictionnaires/01-bases.rst b/cours/source/08-dictionnaires/01-bases.rst new file mode 100644 index 0000000..4378924 --- /dev/null +++ b/cours/source/08-dictionnaires/01-bases.rst @@ -0,0 +1,113 @@ +Prinipes fondamentaux +===================== + +Définition +---------- + +Un dictionaire est une *association* entre des clés et des valeurs. + +* Les clés sont uniques +* Les valeurs sont arbitraires + +Création de dictionnaires +------------------------- + +Les dictionaires sont entourés par des accolades: ``{``, ``}`` :: + + dictionaire_vide = {} + +Ensuite, chaque paire de clé/valeur est séparée par des virgules ``,`` +avec ``:`` ente la clé et la valer :: + + une_clé_une_valeur = {"a": 42} + + deux_clés_deux_valeurs = {"a": 42, "b": 53} + + +Accès aux valeurs +------------------ + +Avec ``[]``, comme pour les listes, mais avec une *clé* à la place d'un *index*:: + + scores = {"john": 10, "bob": 42} + + print(scores["john"]) + # affiche: 10 + + print(scores["bob"]) + # affiche: 42 + + print(scores["charlie"]) + # erreur: KeyError + + +Modifier la valeur d'une clé +----------------------------- + +Comme pour les listes, avec une assignation:: + + scores = {"john": 10, "bob": 42} + scores["john"] = 20 + print(scores) + # affiche: {"john": 20, "bob": 42} + +Créer une nouvelle clé +----------------------- + +Même mécanisme que pour la modification des clés existantes:: + + scores = {"john": 10, "bob": 42} + scores["charlie"] = 30 + print(scores) + # affiche: {"john": 20, "bob": 42, "charlie": 30} + +*rappel*: ceci ne fonctionne pas avec les listes: on ne peut +pas "créer" de nouveaux éléments dans la liste juste +avec un index:: + + ma_liste = ["a", "b"] + ma_liste[1] = "c" + print(ma_liste) + # affiche: ["a", "c"] + + ma_liste[3] = "d" + # erreur: IndexError + +del +--- + +Détruire une clé ++++++++++++++++++ + +Avec ``del`` - un nouveau mot-clé:: + + scores = {"john": 10, "bob": 42} + del scores["bob"] + print(scores) + # affiche: {"john": 10} + +Détruire un élément d'une liste +++++++++++++++++++++++++++++++++ + +Aussi avec ``del``:: + + fruits = ["pomme", "banane", "poire"] + del fruits[1] + print(fruits) + # affiche: ["pomme", "poire"] + +Détruire une variable ++++++++++++++++++++++ + +Encore et toujours ``del``:: + + mon_entier = 42 + mon_entier += 3 + print(mon_entier) + # affiche: 45 + + del mon_entier + mon_entier += 1 + # erreur: NameError + + diff --git a/cours/source/08-dictionnaires/02-itération.rst b/cours/source/08-dictionnaires/02-itération.rst new file mode 100644 index 0000000..a50c7a9 --- /dev/null +++ b/cours/source/08-dictionnaires/02-itération.rst @@ -0,0 +1,21 @@ +Itération et dictionaires +========================== + +Itérer sur les clés +------------------- + +Avec ``for ... in ...``, comme pour les listes:: + + scores = {"john": 10, "bob": 42} + for nom in scores: + # on assigne la valeur "john" à la variable `nom`, puis "bob" + score_associé_au_nom = scores[nom] + # on assigne la valeur 10 puis la valeur 42 à la variable + # score_associé_au_nom + print(nom, score_associé_au_nom) + +.. code-block:: + + john 10 + bob 42 + diff --git a/cours/source/08-dictionnaires/03-booléens.rst b/cours/source/08-dictionnaires/03-booléens.rst new file mode 100644 index 0000000..1e6511a --- /dev/null +++ b/cours/source/08-dictionnaires/03-booléens.rst @@ -0,0 +1,42 @@ +Dictionnaires et booléens +========================= + +Falsy et truthy +---------------- + +Les dictionaires vides sont falsy, et tous les autres dictionaires sont truthy:: + + mon_dico = {"a": 1, "b": 2} + if mon_dico: + print("mon_dico est truthy") + else: + print("mon_dico est falsy") + # affiche: mon_dico est truthy + + mon_autre_dico = {} + if mon_autre_dico: + print("mon_autre_dico n'est pas vide") + else: + print("mon_autre_dico est vide") + # affiche: mon_autre_dico est vide + +Test d'appartenance +--------------------- + +Avec ``in``, comme le listes:: + + scores = {"john": 10, "bob": 42} + print("charlie" in scores) + # affiche: False + + +Comparaisons de dictionaires +----------------------------- + +Deux dictionaires sont considérés égaux s'ils ont les mêmes clés +et les mêmes valeurs. L'ordre n'importe pas:: + + {"a":1, "b":2} == {"a":1, "b":2} # True + {"a":1, "b":2} == {"b":2, "a":1} # True + {"a":1, "b":2} == {"a":1, "b":3} # False + diff --git a/cours/source/08-dictionnaires/04-exercice.rst b/cours/source/08-dictionnaires/04-exercice.rst new file mode 100644 index 0000000..4c1556d --- /dev/null +++ b/cours/source/08-dictionnaires/04-exercice.rst @@ -0,0 +1,48 @@ +Exercice +======== + +Consignes +--------- + +Le but de l'exercice est d'implémenter un convertisseur d'unités de distance. + +Il faut être capables de convertir des kilomètres, des miles, des yards, etc.. + +Le programme doit s'utiliser comme suit: + +.. code-block:: console + + python convertisseur.py 1 km miles + +Il y a trois "mots" après le nom du fichier, séparés par des espaces. +On appelle ces mots les "arguments" du programme. + +Ici, ``1`` est la valeur de départ, ``km`` l'unité d'arrivée +et ``miles`` l'unité d'arrivée. + +Squelette +---------- + +Vous pouvez partir du code suivant: + + + +.. literalinclude:: /extraits/convertisseur.py + + +Vous noterez que le programme est capable de récupérer la valeur, +l'unité de départ et l'unité d'arrivée correctement, mais que le +résultat est toujours égal à 1.0. + +Votre objectif est de finir l'implémentation pour réaliser effectivement +la conversion. + +À noter : vous n'avez pas besoin de changer l'implémentation des +fonctions ``main()`` et ``convertir()``, et ne vous inquiétez pas si +vous ne comprenez pas exactement ce que fait la fonction ``main()``, on +expliquera en détail comment elle fonctionne dans un chapitre ultérieur. +Pour terminer l'exercice, vous n'avez besoin que de modifier les +fonctions ``trouver_coefficient()``, ``conversion_en_mètres()`` et +``conversion_depuis_mètres()``. + +À vous de jouer! diff --git a/cours/source/08-dictionnaires/index.rst b/cours/source/08-dictionnaires/index.rst index 33eb2c7..7d30532 100644 --- a/cours/source/08-dictionnaires/index.rst +++ b/cours/source/08-dictionnaires/index.rst @@ -1,147 +1,11 @@ Chapitre 8 - Dictionnaires ========================== -Définition ----------- -Un dictionaire est une *association* entre des clés et des valeurs. - -* Les clés sont uniques -* Les valeurs sont arbitraires - -Création de dictionnaires -------------------------- - -Avec des accolades: ``{``, ``}`` :: - - dictionaire_vide = {} - - une_clé_une_valeur = {"a": 42} - - deux_clés_deux_valeurs = {"a": 42, "b": 53} - -Note: tous les dictionnaires sont truthy, sauf les dictionnaires vides. - -Accès aux valeurs ------------------- - -Avec ``[]``, comme pour les listes, mais avec une *clé* à la place d'un *index*:: - - scores = {"john": 10, "bob": 42} - - print(scores["john"]) - # affiche: 10 - - print(scores["bob"]) - # affiche: 42 - - print(scores["charlie"]) - # erreur: KeyError - -Test d'appartenance ---------------------- - -Avec ``in``, comme le listes:: - - scores = {"john": 10, "bob": 42} - print("charlie" in scores) - # affiche: False - -Modifier la valeur d'une clé ------------------------------ - -Comme pour les listes, avec une assignation:: - - scores = {"john": 10, "bob": 42} - scores["john"] = 20 - print(scores) - # affiche: {"john": 20, "bob": 42} - -Créer une nouvelle clé ------------------------ - -Même mécanisme que pour la modification des clés existantes:: - - scores = {"john": 10, "bob": 42} - scores["charlie"] = 30 - print(scores) - # affiche: {"john": 20, "bob": 42, "charlie": 30} - -*rappel*: ceci ne fonctionne pas avec les listes: on ne peut -pas "créer" de nouveaux éléments dans la liste juste -avec un index:: - - ma_liste = ["a", "b"] - ma_liste[1] = "c" - print(ma_liste) - # affiche: ["a", "c"] - - ma_liste[3] = "d" - # erreur: IndexError - -Itérer sur les clés -------------------- - -Avec ``for ... in ...``, comme pour les listes:: - - scores = {"john": 10, "bob": 42} - for nom in scores: - # on assigne la valeur "john" à la variable `nom`, puis "bob" - score_associé_au_nom = scores[nom] - # on assigne la valeur 10 puis la valeur 42 à la variable - # score_associé_au_nom - print(nom, score_associé_au_nom) - -.. code-block:: - - john 10 - bob 42 - -del ---- - -Détruire une clé -+++++++++++++++++ - -Avec ``del`` - un nouveau mot-clé:: - - scores = {"john": 10, "bob": 42} - del scores["bob"] - print(scores) - # affiche: {"john": 10} - -Détruire un élément d'une liste -++++++++++++++++++++++++++++++++ - -Aussi avec ``del``:: - - fruits = ["pomme", "banane", "poire"] - del fruits[1] - print(fruits) - # affiche: ["pomme", "poire"] - -Détruire une variable -+++++++++++++++++++++ - -Encore et toujours ``del``:: - - mon_entier = 42 - mon_entier += 3 - print(mon_entier) - # affiche: 45 - - del mon_entier - mon_entier += 1 - # erreur: NameError - - -Comparaisons de dictionaires ------------------------------ - -Deux dictionaires sont considérés égaux s'ils ont les mêmes clés -et les mêmes valeurs. L'ordre n'importe pas:: - - {"a":1, "b":2} == {"a":1, "b":2} # True - {"a":1, "b":2} == {"b":2, "a":1} # True - {"a":1, "b":2} == {"a":1, "b":3} # False +.. toctree:: + :maxdepth: 1 + ./01-bases.rst + ./02-itération.rst + ./03-booléens.rst + ./04-exercice.rst diff --git a/cours/source/extraits/convertisseur.py b/cours/source/extraits/convertisseur.py new file mode 100644 index 0000000..ecb25b7 --- /dev/null +++ b/cours/source/extraits/convertisseur.py @@ -0,0 +1,36 @@ +import sys + + +def trouver_coefficient(unité): + return 1.0 + + +def conversion_en_mètres(valeur, unité_de_départ): + coefficient = trouver_coefficient(unité_de_départ) + return valeur * coefficient + + +def conversion_depuis_mètres(valeur, unité_d_arrivée): + return 1.0 + + +def convertir(valeur, unité_de_départ, unité_d_arrivée): + print("Conversion de", valeur, "en", unité_de_départ, "vers", unité_d_arrivée) + en_mètres = conversion_en_mètres(valeur, unité_de_départ) + résultat = conversion_depuis_mètres(en_mètres, unité_d_arrivée) + return résultat + + +def main(): + nombre_arguments = len(sys.argv) - 1 + if nombre_arguments != 3: + print("3 arguments attendus, mais", nombre_arguments, "reçu(s)") + return + valeur = float(sys.argv[1]) + unité_de_départ = sys.argv[2] + unité_d_arrivée = sys.argv[3] + valeur_de_sortie = convertir(valeur, unité_de_départ, unité_d_arrivée) + print(f"{valeur_de_sortie:.6}") + + +main()