python lecture dico

Identification

Infoforall

17 - 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 :

  1. On ne peut pas tester toutes les valeurs possibles des clés
  2. 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. 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') ''' return None 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 if __name__ == '__main__' : import doctest doctest.testmod()

✎ 03° 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ée

Ca 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
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 ''' return None if __name__ == '__main__' : import doctest doctest.testmod()

Dans quel cas utiliser values plutôt que keys ?

  • Si vous avez juste besoin d'obtenir les valeurs : utilisez values().
  • Si vous avez juste besoin d'obtenir les clés : utilisez keys().
  • Si vous avez besoin de modifier les valeurs : utilisez keys. De cette façon, vous pourrez noter des codes du type dictionnaire[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.

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) ''' return None 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 if __name__ == '__main__' : import doctest doctest.testmod()

✎ 07° 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 !

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 de la valeur (ingredients[cle][0] * 2, ingredients[cle][1])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

On retiendra donc qu'il existe trois méthodes qu'on associe avec une boucle FOR.

  • La méthode keys permet d'obtenir les clés
  • La méthode values permet d'obtenir les valeurs
  • La méthode items permet d'obtenir les couples (clé, valeur) sous forme d'un tuple.

Activité publiée le 15 06 2020
Dernière modification : 15 06 2020
Auteur : ows. h.