29 - Lire le contenu d'un dictionnaire
Nous venons de voir dans l'activité précédente les dictionnaires, une structure de données permettant de retrouver les données en les associant à une valeur par forcément chiffrée contrairement aux index des tableaux.
Nous allons voir aujourd'hui comment parvenir à le lire sans nécessairement connaître les clés utilisées.
Cette activité est plutôt rapide et courte car les méthodes seront vues de nombreuses fois dans beaucoup d'activités. Un résumé de leur fonctionnement sera alors fourni à chaque fois.
Il s'agit donc d'un premier contact, sans chercher à contextualiser les choses.
Prérequis : l'activité précédente sur les dictionnaires.
Evaluation ✎ : questions 01-03-05-07-08-09-10.
1 - 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
✎ 01° Tester le code puis fournir un code contenant votre propre dictionnaire sur la recette que vous voulez.
02° 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()
|
✎ 03° Proposer quelques utilisations de Console 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 la console 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
2 - 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
04° 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.
✎ 05° 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.
3 - 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]}.")
|
06° 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()
|
✎ 07° Proposer quelques utilisations de la console 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 !
4 - 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')}
✎ 08° 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
✎ 09° 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.
✎ 10° 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')}
5 - FAQ
rien pour l'instant
Activité publiée le 15 06 2020
Dernière modification : 05 12 2020
Auteur : ows. h.