Créer et lire le contenue un dictionnaire
Ranger les données... Dans un tableau, c'est bien mais il faut un index pour atteindre une case.
Si on peut associer un index à chaque donnée de façon évidente, c'est correct.
Mais pour un dictionnaire par exemple (le livre, celui avec les mots), on fait comment ? On donne un numéro à chaque mot ?
Si on veut recenser les arbres et leurs positions dans un parc ?
Si on veut recenser les oeuvres et leurs positions dans une exposition ?
Si on veut connaitre le nombre de malades pour une maladie donnée par pays ?
Si on veut connaitre les mots les plus utilisés dans un discours politique ?
Bref, vous l'aurez compris : les tableaux, c'est bien, c'est rapide mais ça n'est qu'une structure de données parmi d'autres.
Aujourd'hui, nous allons donc voir le dictionnaire.
Logiciel nécessaire pour l'activité : Python 3 : Spyder, Edupython, IDLE ...
A rendre ✎ : questions 5-6-8-10-11-12-13-14-15.
1 - Création d'un dictionnaire
Prenons l'exemple d'un dictionnaire au sens usuel du terme, le dico, le livre plein de mots et de définitions.
Je suis parti sur le site d'un éditeur bien connu de dictionnaire.
Et je suis parti voir ce qu'on y disait de l'encodage.
Voici la réponse :
On retrouve donc bien le fait qu'il s'agit de transformer un contenu quelconque (image, vidéo, texte, ...) en une suite d'octets par exemple.
Autre façon de présenter les choses :
| Clé (plutôt qu'index) | Elément ou valeur associée à cette clé |
|---|---|
| "encodage" | "Transcription de données d'un format dans un autre" |
| "cryptage" | "Procédé de cryptographie grâce auquel on souhaite rendre la compréhension d'un document impossible à toute personne qui n'a pas la clé de (dé)chiffrement. On parle également de chiffrement." |
Et voilà : un dictionnaire informatique peut donc être vu comme une sorte de tableau dont on accède aux éléments à l'aide d'une clé,
plutôt qu'à l'aide d'un index numériques.
Comment mémoriser ces définitions avec Python ?
1 - Déclaration d'un dictionnaire en Python
Les éléments délimitateurs sont les accolades.
Chaque élément du dictionnaire est séparé des autres par une virgule.
On donne d'abord la clé, suivi du symbole : puis de la valeur associée à la clé.
Exemple avec un dictionnaire de traduction FRANCAIS (pour la clé) et ANGLAIS (pour la valeur)
1 | dicoFR_AN = {'encodage' : "encoding", 'cryptage' : "encryption"}
|
Pour plus de clarté, on pourrait taper le code ainsi :
1
2
3
4 | dicoFR_AN = {
'encodage' : "encoding",
'cryptage' : "encryption"
}
|
Une fois, cette variable en mémoire, on peut chercher son type :
>>> type(dicoFR_AN)
<class 'dict'>
Comme vous pouvez le voir, le type de l'objet que nous utilisons pour gérer les dictionnaires (dictionary en anglais) dans Python se nomme dict.
2 - Nombre de couples clés-valeurs enregistrées
On peut utiliser la fonction native len pour obtenir le nombre de clés-valeurs enregistrées dans un dictionnaire.
Exemple
>>> mon_dico = {'encodage' : "encoding", 'cryptage' : "encryption"}
>>> nbr = len(mon_dico)
>>> nbr
2
Le dictionnaire contient bien 2 ensembles clés-valeurs, et pas 4 éléments indépendants.
3 - Rajouter une clé et sa valeur associée
Contrairement aux tableaux, on peut facilement rajouter des éléments dans un dictionnaire.
Par contre, attention à la syntaxe : on utilise des crochets et pas des accolades !
Exemple
>>> mon_dico = {'encodage' : "encoding", 'cryptage' : "encryption"}
>>> mon_dico
{'encodage': 'encoding', 'cryptage': 'encryption'}
>>> mon_dico['balise'] = "tag"
>>> mon_dico
{'encodage': 'encoding', 'cryptage': 'encryption', 'balise': 'tag'}
>>> nbr = len(mon_dico)
>>> nbr
3
Le dictionnaire contient bien maintenant 3 ensembles clés-valeurs.
01° Trouver à l'aide d'un programme Python, le nombre de couples clés-valeurs présents dans le dictionnaire suivant :
1
|
|
...CORRECTION...
1
2
3
4mon_dico = {'encodage' : "encoding", 'cryptage' : "encryption", 'attribut' : "attribute", 'tableau' : "array", 'lier' : "to bind", 'bit' : "bit", 'octet' : "byte (eight-bit byte)", 'multiplet' : "byte", 'retenue' : "carry", 'événement' : "event", "gestionnaire d'événement" : "event handler", "drapeau" : "flag", "nombre à virgule flottante" : "float", "fonction" : "function", "caché" : "hidden", "cachés" : "hidden", "cachée" : "hidden" , "cachées" : "hidden", "entier" : "integer"}
nbr_couples = len(mon_dico)
print(nbr_couples)
Le programme affiche alors 19 dans le Shell. Il y a donc 19 couples clés-valeurs.
02° Maintenant que le dictionnaire est en mémoire, tapez dans le shell le code permettant par exemple de rajouter que 'boucle' peut se traduire par 'loop' et 'dépassement' par 'overflow'.
Tapez ensuite une instruction permettant de visualiser que vous avez bien 21 couples clés-valeurs après le rajout des deux nouveaux couples.
...CORRECTION...
>>> mon_dico['boucle'] = 'loop'
>>> mon_dico['dépassement'] = 'overflow'
>>> len(mon_dico)
21
Le programme affiche alors 21. Il y a donc 21 couples clés-valeurs.
4 - Accès à l'une des valeurs
Pour accéder à l'un des éléments en particulier, on peut noter le nom de la variable-dictionnaire suivi de crochets et y placer la clé voulue.
Comme avec un tableau mais avec la clé plutôt qu'avec un index chiffré.
Cela donne donc la notation monDictionnaire[maCle] donne maValeur.
Exemple
>>> mon_dico['boucle']
'loop'
>>> mon_dico['tableau']
'array'
>>> mon_dico['lapin']
'Traceback (most recent call last):
File "", line 1, in
mon_dico['lapin']
KeyError: 'lapin'
On remarquera que tenter d'accéder à une clé inconnue crée une erreur et une interruption du programme.
Comme lorsqu'on demande l'index 20 d'un tableau qui ne comporte que 10 éléments.
La correspondance clé - valeur donne ceci sur l'exemple
| Clé | 'boucle' | 'tableau' |
| Elément | 'loop' | 'array' |
5 - Que peut-on utiliser pour faire une clé ?
A peu près tout.
Imaginons par exemple qu'on veuille réaliser un état des lieux des lieux d'aggression dans une ville.
On pourrait indiquer dans la valeur la nature du crime en fournissant comme clé la localisation du lieu sous la forme (latitude, longitude).
Exemple
>>> crimes = {}
>>> crimes[("50°19'59\"", "3°22'59.99\"")] = 'Recopiage de DM'
>>> crimes
{("50°19'59\"", "3°22'59.99\""): 'Recopiage de DM'}
Cette clé n'est sans doute pas facile à taper pour un humain mais elle est tout à fait valide pour l'ordinateur.
Et pouquoi noter \" et pas juste " ?
Sinon l'interpréteur Python va croire qu'on veut fermer le string : on utilise donc un caractère d'échappement. Nous l'avons déjà rencontré.
Le plus fort, c'est que les clés n'ont pas à être du même type !
On pourrait, dans un même dictionnaire, créer des clés ayant le nom de la ville, le code postal...
Par contre, sans uniformité de la clé, l'information est sans doute présente mais difficilement exploitable...
La seule chose qui ne puisse pas être une clé, c'est une variable mutable ou un contenu mutable.
>>> toto = ['bonjour']
>>> mon_dico = {toto : "non, pas possible : la list-python est mutable"}
Traceback (most recent call last):
File "<pyshell#5>", line 1, in <module>
mon_dico = {toto : "non, pas possible : la list-python est mutable"}
TypeError: unhashable type: 'list'
>>> toto = ('bonjour',)
>>> mon_dico = {toto : "oui, c'est possible car le tuple est non-mutable"}
>>> mon_dico
{('bonjour',): "oui, c'est possible car le tuple est non-mutable"}
C'est extrêmement intéressant pour gérer des cases sur un plateau de jeu :
toucheCoule = { (10,5):"Bateau", (10,6):"Bateau" }
Ici, on a donc un bateau lignes 10 et colonnes 5 et 6 par exemple.
C'est super pratique pour gérer un plateau sans avoir à stocker plein d'informations sur des cases ... vides.
Il nous reste à voir si les dictionnaires sont mutables (comme les tableaux de Python) ou non-mutables (comme les tuples de Python).
03° Utiliser les codes suivants. Répondre ensuite à la question suivante : les dictionnaires sont-ils mutables en Python ?
>>> dico_ascii = {'A':65, 'B':66, 'C':67}
>>> dico_ascii
{'A': 65, 'B': 66, 'C': 67}
>>> id(dico_ascii)
140578584342600
>>> dico_ascii['A'] = 75
>>> id(dico_ascii)
140578584342600
...CORRECTION...
On parvient bien à modifier les éléments du dictionnaire. On remarque d'ailleurs que l'identifiant reste bien le même : la variable-dictionnaire fait bien référence au même objet en mémoire.
Le programme affiche alors 21. Il y a donc 21 couples clés-valeurs.
6 - Le dictionnaire Python est mutable
Les objets dict sont des objets mutables : on peut modifier leur contenu sans modifier la référence de l'objet en lui-même.
En gros, comme les tableaux.
Du coup, on peut modifier un dictionnaire qu'on passe en paramètre à une fonction par effet de bord.
La puissance de cet objet est que
- Si on veut modifier la valeur associée à une clé existence : on modifie la valeur
- Si on veut "modifier" la valeur associée à une clé qui n'existe pas en réalité : on crée le couple
Un exemple avec un oubli un remplacement initial de overflow par overflaw :
>>> mon_dico = {}
>>> mon_dico['boucle'] = 'loop'
>>> mon_dico['dépassement'] = 'overflaw'
>>> mon_dico
{'boucle': 'loop', 'dépassement': 'overflaw'}
Tentons de changer la valeur associée à "dépassement" :
>>> mon_dico['dépassement'] = 'overflow'
>>> mon_dico
{'boucle': 'loop', 'dépassement': 'overflow'}
Et pour rappel : si la clé n'existe pas, on crée juste une nouvelle entrée :
>>> mon_dico['balise'] = 'tag'
>>> mon_dico
{'boucle': 'loop', 'dépassement': 'overflow', 'balise': 'tag'}
Un dernier élément :
nous avons vu qu'une recherche sur une clé inconue, ça provoque une erreur.
Comment faire alors pour vérifier si une clé existe ou pas ?
7 - Connaître l'existence d'une clé
C'est très facile, puisque c'est fondamental pour ne pas déclencher d'erreur.
Il existe un mot-clé Python qui permet de tester l'existence d'un élément dans un conteneur : in (dans, en anglais)
Il suffit d'évaluer l'expression suivante : cleTestee in monDict : l'interpréteur Python va renvoyer une valeur booléenne : True ou False.
Un exemple :
>>> mon_dico = {}
>>> mon_dico['boucle'] = 'loop'
>>> mon_dico['dépassement'] = 'overflow'
>>> 'boucle' in mon_dico
True
>>> 'toto' in mon_dico
False
>>> 'loop' in mon_dico
False
On notera donc qu'on teste l'existence de la clé et pas l'existence d'une valeur.
D'ailleurs, en réalité, il s'agit d'un raccourci pour l'expression suivante que nous allons voir dans la partie suivante : cleTestee in monDict.keys() : l'interpréteur Python va renvoyer une valeur booléenne : True ou False.
Un exemple :
>>> mon_dico = {}
>>> mon_dico['boucle'] = 'loop'
>>> mon_dico['dépassement'] = 'overflow'
>>> 'boucle' in mon_dico
True
>>> 'toto' in mon_dico
False
>>> 'loop' in mon_dico
False
04° Lire, comprendre et utiliser la fonction suivante.
Lancer le programme pour mémoriser le dictionnaire et la fonction.
Lancer ensuite les commandes suivantes dans le Shell pour en vérifier les réponses.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27 | def incrementer(leDict, laCle):
'''Fonction qui renvoie True si la clé existe déjà et l'incrémente.
Sinon, elle renvoie False et crée une valeur associée de 0
:: param leDict(dic) :: le dictionnaire sur lequel on veut agir
:: param laCle(?) :: la clé qu'on veut tester
:: return (bool) :: True si leDict[laCle] existe
:: exemples ::
>>> nbr_lettres = {'a':45, 'b':12, 'd':5}
>>> incrementer(nbr_lettres, 'z')
False
>>> nbr_lettres
{'a': 45, 'b': 12, 'd': 5, 'z': 1}
'''
if laCle in leDict.keys():
leDict[laCle] = leDict[laCle] + 1 # ou leDict[laCle] += 1
return True
leDict[laCle] = 1 # return ligne 18 : si on arrive ici c'est que c'est faux
return False
comptesLettres = {'a':1, 'b':20, 'c':300}
if __name__ == '__main__' :
import doctest
doctest.testmod()
|
>>> monDico = {}
>>> incrementer(monDico, 'a')
>>> incrementer(monDico, 'a')
>>> incrementer(monDico, 't')
>>> monDico
✎ 05° Tenter de trouver les réponses des commandes suivantes si on les effectue après celles de la question 04.
>>> incrementer(monDico, 'a')
>>> incrementer(monDico, 'b')
>>> incrementer(monDico, 't')
>>> monDico
2 - Lecture des clés avec keys
Nous savons qu'un dictionnaire permet d'associer une clé et une valeur.
Imaginons qu'on désire stocker le contenu des ingrédients d'une recette.
1 | ingredients = {'Farine' : '250 g', 'Lait' : '50 cl', 'Oeufs' : 3, 'Sel' : '1 pincée'}
|
La clé 'Farine' est donc associée à la valeur '250 g'.
Nous aurions pu écrire notre dictionnaire de cette façon dans l'éditeur :
1
2
3
4
5
6 | ingredients = {
'Farine' : '250 g',
'Lait' : '50 cl',
'Oeufs' : 3,
'Sel' : '1 pincée'
}
|
C'est plus clair pour un humain mais ça prend un peu plus de place à l'écran. Lorsque le contenu est conséquent, autant faire comme ça. Sur un petit dictionnaire, on peut choisir de le fournir comme on veut.
Rappel : existence des clés
Nous avons vu qu'on peut savoir si une clé existe en utilisant ceci :
>>> 'Farine' in ingredients
True
>>> 'farine' in ingredients
False
On voit bien ici que la clé 'Farine' existe alors que la clé 'farine' n'existe pas dans le dictionnaire.
Lecture de la valeur associée à une clé précise
Si la clé existe, on peut obtenir la valeur associée à l'aide d'une commande de ce type :
>>> ingredients['Farine']
'250 g'
>>> ingredients['Oeufs']
3
On peut donc tester si une clé existe et, si c'est le cas, lire la valeur associée. Oui mais :
- On ne peut pas tester toutes les valeurs possibles des clés
- Tenter de lire une valeur en donnant une clé inexistance provoque une erreur !
Nous allons donc voir un moyen de lire les clés présentes dans un dictionnaire.
Méthode keys
La méthode des dictionnaires keys permet de créer un ensemble contenant les clés du dictionnaire.
Regardons cet exemple qui permet de comprendre que la méthode renvoie bien une sorte de tableau contenant les clés disponibles pour ce dictionnaire :
>>> ingredients = {'Farine' : '250 g', 'Lait' : '50 cl', 'Oeufs' : 3, 'Sel' : '1 pincée'}
>>> ingredients
{'Farine': '250 g', 'Lait': '50 cl', 'Oeufs': 3, 'Sel': '1 pincée'}
>>> ingredients.keys()
dict_keys(['Farine', 'Lait', 'Oeufs', 'Sel'])
On pourra ainsi le lire une à une avec une boucle for.
1
2
3
4 | ingredients = {'Farine' : '250 g', 'Lait' : '50 cl', 'Oeufs' : 3, 'Sel' : '1 pincée'}
for cle in ingredients.keys():
print(cle)
|
Si on lance le code, nous aurons ceci dans la console :
Farine
Lait
Oeufs
Sel
✎ 06° Tester le code puis fournir un code contenant votre propre dictionnaire sur la recette que vous voulez.
07° Compléter le code de la fonction pour qu'elle réponde bien aux exigences : on veut recevoir en paramètres un dictionnaire et une clé. Si la clé existe, la fonction renvoie la valeur associée. Sinon, elle renvoie None.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 | ingredients = {'Farine' : '250 g', 'Lait' : '50 cl', 'Oeufs' : 3, 'Sel' : '1 pincée'}
def lire_cle(dictionnaire, cle):
'''Fonction qui renvoie None si la clé n'existe pas, la valeur associée sinon
:: param dictionnaire (dict) :: un dictionnaire
:: param cle (divers) :: un paramètre pouvant servir de clé (donc non mutable)
:: return (divers) :: None ou dictionnaire[cle]
:: exemple ::
>>> lire_cle({'a':5}, 'a')
5
>>> lire_cle({'a':5}, 'b')
'''
pass
if __name__ == '__main__' :
import doctest
doctest.testmod()
|
...CORRECTION...
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 | ingredients = {'Farine' : '250 g', 'Lait' : '50 cl', 'Oeufs' : 3, 'Sel' : '1 pincée'}
def lire_cle(dictionnaire, cle):
'''Fonction qui renvoie None si la clé n'existe pas, la valeur associée sinon
:: param dictionnaire (dict) :: un dictionnaire
:: param cle (divers) :: un paramètre pouvant servir de clé (donc non mutable)
:: return (divers) :: None ou dictionnaire[cle]
:: exemple ::
>>> lire_cle({'a':5}, 'a')
5
>>> lire_cle({'a':5}, 'b')
'''
if cle in dictionnaire :
return dictionnaire[cle]
return None # Inutile en réalité : ce serait fait automatiquement
if __name__ == '__main__' :
import doctest
doctest.testmod()
|
✎ 08° Proposer quelques utilisations du Shell permettant de tester la fonction. N'oubliez pas de mettre le code en mémoire en le lançant avant de tenter d'utiliser la fonction !
On remarquera que le Shell Python ne reçoit pas vraiment None, il reçoit juste... rien. None. Nada.
Du coup, nous avons maintenant un moyen de lire les clés une à une.
Si on veut lire les valeurs une par une, nous pourrions donc utiliser un code de ce type :
1
2
3
4 | ingredients = {'Farine' : '250 g', 'Lait' : '50 cl', 'Oeufs' : 3, 'Sel' : '1 pincée'}
for cle in ingredients.keys():
print(ingredients[cle])
|
Si on lance le code, nous aurons ceci dans la console :
250 g
50 cl
3
1 pincéeCa fonctionne. Mais si on veut juste obtenir les valeurs une par une, il y a mieux. Partie suivante.
En réalité, la méthode keys est tellement courante et importante que si vous tentez de 'lire un dictionnaire avec une boucle for', l'interpréteur va l'appliquer par défaut.
1
2
3
4 | ingredients = {'Farine' : '250 g', 'Lait' : '50 cl', 'Oeufs' : 3, 'Sel' : '1 pincée'}
for cle in ingredients :
print(cle)
|
Comme vous pouvez le voir, j'ai tapé for cle in ingredients et pas for cle in ingredients.keys().
Si on lance le code, nous aurons ceci dans la console :
Farine
Lait
Oeufs
Sel
3 - Lecture des valeurs avec values
La méthode keys permet d'obtenir un ensemble qui contient les clés.
La méthode values permet d'obtenir un ensemble qui contient les... valeurs.
Méthode values
Commençons par regarder ce que renvoie cette méthode lorsqu'on l'applique sur un dictionnaire :
>>> ingredients = {'Farine' : '250 g', 'Lait' : '50 cl', 'Oeufs' : 3, 'Sel' : '1 pincée'}
>>> ingredients
{'Farine': '250 g', 'Lait': '50 cl', 'Oeufs': 3, 'Sel': '1 pincée'}
>>> ingredients.values()
dict_values(['250 g', '50 cl', 3, '1 pincée'])
1
2
3
4 | ingredients = {'Farine' : '250 g', 'Lait' : '50 cl', 'Oeufs' : 3, 'Sel' : '1 pincée'}
for valeur in ingredients.values():
print(valeur)
|
Si on lance le code, nous aurons ceci dans la console :
250 g
50 cl
3
1 pincée
09° Tester le code ci-dessus. Modifier un peu le dictionnaire et relancer pour être certain d'avoir bien compris ce que le code va afficher.
✎ 10° Compléter le code de la fonction pour qu'elle réponde bien aux exigences : elle doit renvoyer True si le dictionnaire contient une clé associée à la valeur à tester.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21 | ingredients = {'Farine' : '250 g', 'Lait' : '50 cl', 'Oeufs' : 3, 'Sel' : '1 pincée'}
def tester_valeur(dictionnaire, valeur_x):
'''Fonction qui renvoie True si valeur_x est l'une des ses valeurs
:: param dictionnaire (dict) :: un dictionnaire
:: param valeur_x (divers) :: la valeur qu'on tente de trouver dans le dictionnaire
:: return (bool) :: True si la valeur est donc le dictionnaire, False sinon
:: exemple ::
>>> tester_valeur({'a':5}, 5)
True
>>> tester_valeur({'a':5}, 10)
False
'''
pass
if __name__ == '__main__' :
import doctest
doctest.testmod()
|
Dans quel cas utiliser values plutôt que keys ?
C'est un peu comme l'utilisation du FOR nominatif (pas de modification à faire, lecture pure) contre le FOR pour itérer sur les index :
- Si vous avez juste besoin de lire les valeurs : utilisez
values(). - Si vous voulez lire ou modifier, vous pouvez utilisez
keys(). De cette façon, vous pourrez lire avecleDictionnaire[cle]et modifier avecleDictionnaire[cle] = nouvelle_valeur.
4 - Lecture clé-valeur avec items
Dernière méthode à connaitre : la méthode items. Cette fois, nous allons pouvoir obtenir la clé et la valeur en même temps.
Méthode items
La méthode des dictionnaires items permet de créer un ensemble contenant des tuples : les clés du dictionnaire ET leurs valeurs associées. On pourra ainsi lire une à une clé et valeur avec une boucle for.
>>> ingredients = {'Farine' : '250 g', 'Lait' : '50 cl', 'Oeufs' : 3, 'Sel' : '1 pincée'}
>>> ingredients
{'Farine': '250 g', 'Lait': '50 cl', 'Oeufs': 3, 'Sel': '1 pincée'}
>>> ingredients.items()
dict_items([('Farine', '250 g'), ('Lait', '50 cl'), ('Oeufs', 3), ('Sel', '1 pincée')])
Voici un exemple avec un dictionnaire dont les clés sont les postes de joueurs de football et la valeur associée est le nombre de joueurs de ce type disponibles. Par exemple, on a 9 joueurs disponibles à placer au poste de défenseur.
1
2
3 | nombres = {'Défenseur': 9, 'Attaquant': 10, 'Milieu de terrain': 7, 'Gardien': 4}
for (cle, valeur) in nombres.items():
print(f"La clé {cle} est associée à la valeur {valeur}.")
|
En lançant ce programme, on obtient ceci :
La clé Défenseur est associée à la valeur 9.
La clé Attaquant est associée à la valeur 10.
La clé Milieu de terrain est associée à la valeur 7.
La clé Gardien est associée à la valeur 4.
On notera que cette méthode n'est pas fantastique : on pourrait faire la même chose avec juste keys :
1
2
3 | nombres = {'Défenseur': 9, 'Attaquant': 10, 'Milieu de terrain': 7, 'Gardien': 4}
for cle in nombres.keys():
print(f"La clé {cle} est associée à la valeur {nombres[cle]}.")
|
11° Compléter le code de la fonction pour qu'elle réponde bien aux exigences : elle doit renvoyer la clé associée à la valeur proposée, et None si la valeur proposée ne se trouve pas dans le dictionnaire.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 | ingredients = {'Farine' : '250 g', 'Lait' : '50 cl', 'Oeufs' : 3, 'Sel' : '1 pincée'}
def tester_valeur(dictionnaire, valeur_x):
'''Fonction qui renvoie la clé associée à valeur_x si la valeur est dans le dictionnaire
:: param dictionnaire (dict) :: un dictionnaire
:: param valeur_x (divers) :: la valeur qu'on tente de trouver dans le dictionnaire
:: return (divers) :: la clé trouvé ou None
:: exemple ::
>>> tester_valeur({'a':5}, 5)
'a'
>>> tester_valeur({'a':5}, 10)
'''
pass
if __name__ == '__main__' :
import doctest
doctest.testmod()
|
...CORRECTION...
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23 | ingredients = {'Farine' : '250 g', 'Lait' : '50 cl', 'Oeufs' : 3, 'Sel' : '1 pincée'}
def tester_valeur(dictionnaire, valeur_x):
'''Fonction qui renvoie la clé associée à valeur_x si la valeur est dans le dictionnaire
:: param dictionnaire (dict) :: un dictionnaire
:: param valeur_x (divers) :: la valeur qu'on tente de trouver dans le dictionnaire
:: return (divers) :: la clé trouvé ou None
:: exemple ::
>>> tester_valeur({'a':5}, 5)
'a'
>>> tester_valeur({'a':5}, 10)
'''
for (cle,valeur) in dictionnaire.items():
if valeur == valeur_x :
return cle
return None # Inutile en réalité : ce serait fait automatiquement
if __name__ == '__main__' :
import doctest
doctest.testmod()
|
✎ 12° Proposer quelques utilisations du Shell permettant de tester la fonction. N'oubliez pas de mettre le code en mémoire en le lançant avant de tenter d'utiliser la fonction !
5 - Un exemple d'utilisation
Regardons comment parvenir à réaliser une petite application de cuisine : on veut pouvoir multiplier les ingrédients en fonction du nombre de parts demandées.
Pour cela, nous allons devoir d'abord séparer la valeur de son unité dans les valeurs. Pour cela, nous allons placer des tuples en tant de valeurs.
Voici notre nouveau dictionnaire :
1
2
3
4
5
6 | ingredients = {
'Farine' : (250, 'g'),
'Lait' : (50, 'cl'),
'Oeufs' : (3, ''),
'Sel' : (1, 'pincée')
}
|
Cette fois, voici ce qu'on obtient si on demande à lire la clé 'Farine' :
>>> ingredients['Farine']
(250, 'g')
Comme la réponse est un tuple, on pourra accéder à l'index 0 et à l'index 1 en utilisant des crochets :
>>> ingredients['Farine'][0]
250
>>> ingredients['Farine'][1]
'g'
Voici comment on pourrait parvenir à créer un dictionnaire contenant le double des parts initiales :
1
2
3
4
5
6
7
8
9 | ingredients = {'Farine' : (250, 'g'), 'Lait' : (50, 'cl'), 'Oeufs' : (3, ''), 'Sel' : (1, 'pincée')}
nouveau = {}
for (cle,valeur) in ingredients.items():
nouveau[cle] = (ingredients[cle][0] * 2, ingredients[cle][1])
print(ingredients)
print(nouveau)
|
L'exécution du script donne ceci :
{'Farine': (250, 'g'), 'Lait': (50, 'cl'), 'Oeufs': (3, ''), 'Sel': (1, 'pincée')}
{'Farine': (500, 'g'), 'Lait': (100, 'cl'), 'Oeufs': (6, ''), 'Sel': (2, 'pincée')}
✎ 13° QCM - Quel est le type des données qu'on affecte à la clé sur la ligne 6 ?
- A - Un tableau
- B - Un tuple
- C - Un dictionnaire
- D - Un string
✎ 14° Sur quelle ligne définit-on le fait qu'on veuille deux fois plus de parts ?
Fournir le code permettant de multiplier les parts par 5.
✎ 15° Créer une fonction qui doit recevoir un dictionnaire similaire au précédent : les clés sont les ingrédients et les valeurs des tuples sous la forme (quantité, unité).
Un second paramètre correspond au facteur multiplicateur qu'on doit appliquer.
La fonction renvoie alors un dictionnaire comportant les ingrédients dans les bonnes proportions.
1
2
3
4
5
6
7
8
9
10
11 | ingredients = {'Farine' : (250, 'g'), 'Lait' : (50, 'cl'), 'Oeufs' : (3, ''), 'Sel' : (1, 'pincée')}
def multiplier(dictionnaire, facteur):
'''Fonction qui renvoie les ingrédients multiplés par facteur
:: param dictionnaire (dict) :: un dictionnaire d'ingrédients contenant des tuples (quantité, unité)
:: param facteur (int) :: un entier correspondant au facteur multiplicateur voulu
:: return (dict) :: un dictionnaire d'ingrédients
'''
pass
|
Si vous envoyer un facteur de 2, votre fonction devra donc renvoyer le double des ingrédients.
>>> ingredients = {'Farine' : (250, 'g'), 'Lait' : (50, 'cl'), 'Oeufs' : (3, ''), 'Sel' : (1, 'pincée')}
>>> multiplier(ingredients, 2)
{'Farine': (500, 'g'), 'Lait': (100, 'cl'), 'Oeufs': (6, ''), 'Sel': (2, 'pincée')}
6 - FAQ
rien pour l'instant
Activité publiée le 24 01 2021
Auteur : ows. h.
Modification : Andjekel