@@ -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 | |||
========================== | |||
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() |