@@ -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 | |||||
@@ -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 | |||||
@@ -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 | |||||
@@ -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! |
@@ -1,147 +1,11 @@ | |||||
Chapitre 8 - Dictionnaires | 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 |
@@ -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() |