Informatique au lycée

Python : les dictionnaires

Numérique et sciences informatiques

Les dictionnaires

Un dictionnaire est de type dict en Python. Il est constitué de paires non ordonnées clé : valeur.
Chaque clé est présente de façon unique dans le dictionnaire.
Un dictionnaire s'écrit avec des accolades {clé : valeur …}.
On accède à une valeur d'un dictionnaire à l'aide d'une clé.
Les clés doivent être de types immuables (ne peuvent pas être modifiées).
Les dictionnaires sont des collections non ordonnées d'objets, c'est-à-dire qu'il n'y a pas de notion d'ordre (i.e. pas d'indice). On accède aux valeurs d'un dictionnaire par des clés.

Cours Lumni sur les dictionnaires

Pour initialiser un dictionnaire , on utile la syntaxe suivante:

mon_garage = {}

>>> mon_garage = dict()

Comment ajouter des valeurs dans un dictionnaire python?

Pour ajouter des valeurs à un dictionnaire il faut indiquer une clé ainsi qu'une valeur:

>>> mon_garage = {}
>>> mon_garage["Ferrari"] = 1
>>> mon_garage["Porche"] = 2
>>> mon_garage["Bentley"] = 1
>>> mon_garage
{'Ferrari': 1, 'Porche': 2, 'Bentley' : 1}

Vous pouvez utiliser des clés numériques comme dans la logique des listes .

Comment récupérer une valeur dans un dictionnaire python?

La méthode get vous permet de récupérer une valeur dans un dictionnaire et si la clé est introuvable, vous pouvez donner une valeur à retourner par défaut:

mon_garage = {"Ferrari": 1, "Porche": 2, "Bentley": 1}
print(mon_garage.get("Ferrari"))
print(mon_garage.get("Citroën", "Voiture inconnue"))
>>> 1
>>> Voiture inconnue

Autre solution : mon_garage[cle] renvoie la valeur associée à cle si elle est présente dans le dictionnaire, sinon une erreur KeyError se produit.

mon_garage = {"Ferrari": 1, "Porche": 2, "Bentley": 1}
print(mon_garage["Ferrari"])
print(mon_garage["Citroën"])

Comment supprimer une entrée dans un dictionnaire python?

Il est possible de supprimer une entrée en indiquant sa clé, comme pour les listes:

	>>> del mon_garage["Bentley"]  # voiture cassée
>>> mon_garage
{"Ferrari": 1, "Porche": 2}

ou avec la méthode pop

>>> mon_garage.pop("Bentley")
>>> mon_garage
{"Ferrari": 1, "Porche": 2}

Comment récupérer les clés d'un dictionnaire python par une boucle ?

Les dictionnaires en Python utilisent une table de hashage pour stocker les clés.

Pour récupérer les clés on utilise la méthode keys .

>>> mon_garage = {"Ferrari":1, "Porche":2}
>>> for cle in mon_garage.keys():
...     print (cle)
... 
Ferrari
Porche

Comment récupérer les valeurs d'un dictionnaire python par une boucle ?

Pour cela on utilise la méthode values .

mon_garage = {"Ferrari":1, "Porche":2}
for valeur in mon_garage.values():
	print (valeur)

Comment récupérer les clés et les valeurs d'un dictionnaire python par une boucle ?

Pour récupérer les clés et les valeurs en même temps, on utilise la méthode items qui retourne un tuple .

mon_garage = {"Ferrari":1,"Porche":2}
for cle,valeur in mon_garage.items():
	print (cle, valeur)

Comment utiliser des tuples comme clé dans un dictionnaire python?

Une des forces de python est la combinaison tuple/dictionnaire qui fait des merveilles dans certains cas comme lors de l'utilisation de coordonnées.

b = {}
b[(3,2)]=12
b[(4,5)]=13
print(b)

Comment créer une copie indépendante d'un dictionnaire python?

Comme pour toute variable, vous ne pouvez pas copier un dictionnaire en faisant dic1 = dic2 :

>>> d = {"k1":2, "k2":1}
>>> e = d
>>> d["k1"] = "XXX"
>>> >>>e
>>>{"k2": 1, "k1": "XXX"}

Pour créer une copie indépendante vous pouvez utiliser la méthode copy :

>>> d = {"k1":2, "k2":1}
>>> e = d.copy()
>>> d["k1"] = "XXX"
>>> >>>e
>>>{k2": 1, "k1": 2}

Comment fusionner des dictionnaires python?

La méthode update permet de fusionner deux dictionnaires .

>>> mon_garage1 = {'Ferrari': '1'}
>>> mon_garage2 = {'Porche': '2'}
>>> mon_garage1.update(mon_garage2)
>>> print(mon_garage1)
{'Ferrari': '1', 'Porche': '2'}

Résumé de cours sur les dictionnaires

Méthode	Description
`mon_dico["ville"]="Paris"`	Ajoute une valeur "Paris" dans `mon_dico` à la clé "ville".
`del mon_dico["rue"]`	Supprime une entrée dans `mon_dico` avec la clé "rue".
`mon_dico.keys()`	Renvoie la liste des clés de `mon_dico`.
`mon_dico.values()`	Renvoie la liste des valeurs de `mon_dico`.
`mon_dico_A.update(mon_dico_B)`	fusionne `mon_dico_A` et `mon_dico_B`.

Entraînement 1: Manipulation de dictionnaires

Soit le dictionnaire suivant :

>>> dico = {"ville": "le moule", "departement": "Guadeloupe", "habitants": 30000}

Implémenter du code pour corriger l'erreur dans habitants, la bonne valeur est 20000, puis afficher le dictionnaire mis à jour.
Implémenter du code pour afficher la liste des clés du dictionnaire (exemple attendu : ['ville', 'departement', 'habitants']).
Implémenter du code pour afficher la liste des valeurs du dictionnaire.
Implémenter du code pour afficher la liste des paires clé/valeur du dictionnaire.
Utiliser les valeurs du dictionnaire pour afficher dynamiquement la phrase « le moule a 20000 habitants » sans écrire directement ces valeurs dans le print.

Soit le dictionnaire :

dico = {"ville": "le moule", "departement": "Guadeloupe", "habitants": 30000}

Implémenter du code pour corriger l'erreur dans habitants, la bonne valeur est 20000.
Implémenter du code pour afficher la liste des clés du dictionnaire.
Implémenter du code pour afficher la liste des valeurs du dictionnaire.
Implémenter du code pour afficher la liste des paires clé/valeur du dictionnaire.
Écrire la phrase "le moule a 20000 habitants" à l'aide du dictionnaire d.

Entraînement 2 : Dictionnaire et fonctions

Le mystérieux sorcier Tom Jedusor devient un élève de Poudlard. Voici son profil :

voldemort = {
    "Nom": "Tom Jedusor",
    "Vie": 55,
    "Défense": 60,
    "Pouvoir": 75,
    "Matières": ["Sortilèges", "Potions"]
}

Récupérer le nom du magicien (Tom Jedusor).
Afficher le nombre de matières suivies.
Corriger la valeur de Pouvoir qui doit être 80, puis afficher le dictionnaire mis à jour.
Ajouter une nouvelle clé "Attaque" avec la valeur 72, puis afficher le dictionnaire mis à jour.
Créer un dictionnaire pour le magicien Pétrus avec :
- Nom : Pétrus
- Défense : 75
- Attaque : 60
- Pouvoir : 40
- Vie : 50
- Matières : ["Potions", "Balais"]

Fonctions à implémenter

Écrire une fonction nombre_matieres qui prend en paramètre dico et renvoie son nombre de matières.
Écrire une fonction get_attaque qui prend en paramètre dico (un magicien sous forme de dictionnaire) et renvoie sa valeur d’attaque.
Écrire une fonction get_defense qui prend en paramètre dico (un magicien sous forme de dictionnaire) et renvoie sa valeur de défense.
Écrire une fonction defense_superieure qui prend en paramètres dico et nb (un entier), et renvoie True si la défense du magicien est supérieure à nb, sinon False.
Écrire une fonction combat_magiciens qui prend en paramètres magicien1 (attaquant) et magicien2 (attaqué) et renvoie le nom du gagnant du combat.
Règle : Le magicien attaquant gagne si sa valeur d'"Attaque" est supérieure à la valeur de "Défense" de son adversaire.
Tester votre fonction avec :
```
combat_magiciens(voldemort, petrus)
```

Entraînement 3 :

On donne un extrait des logins d'accès au réseau du lycée :

toto  to12
tata    ta12
titi    1234

Créer une variable de type dict qui contient les couples identifiant - mot de passe ci-dessus pour que les clés du dictionnaire soient les identifiants et les valeurs soient les mots de passe..
Compléter ce dictionnaire avec un nouvel utilisateur user1 ayant pour mot de passe pass1.
Écrire une fonction verification qui prend en paramètres identifiant et mot_de_passe, et qui renvoie True si l'identifiant et le mot de passe correspondent, sinon False.

Entraînement 4 :

Voici un exemple de données permettant de manipuler un livre de recettes de cuisine`a partir de la liste des ingrédients des recettes :

Recette	Ingrédients
Gâteau au chocolat	chocolat, oeuf, farine, sucre, beurre
Gâteau au yaourt	Yaourt, oeuf, farine, sucre
Crêpes	oeuf, farine, lait, bière
Quatre-quarts	oeuf, farine, beurre, sucre
Kouign-amann	farine, beurre, sucre

On va modéliser en Python un livre de recettes, par un dictionnaire de type dict(str : list(str))dans lequel :

les noms des recettes, de type str, comme clés,
l’ensemble des ingrédients, de type list(str), comme valeurs associées

Construire un dictionnaire mes_recettes correspondant au tableau ci-dessus.

Voir une solution

Définir une fonction nb_ingredients(D, nom) qui à partir d’un dictionnaire de recettes D, défini comme décrit ci-dessus,renvoie le nombre d’ingrédients de la recette nommé nom.
Définir une fonction recherche_recettes(D,i) renvoyant l’ensemble des recettes du dictionnaire D qui utilisent l’ingrédient i.
Définir une fonction recherche_recettes_2(D,i1,i2)renvoyant l’ensemble des recettes du dictionnaire D qui utilisent les ingrédients i1 et i2.
Définir une fonction recherche_recettes_multi(D,Li) renvoyant l’ensemble des recettes du dictionnaire D qui utilisent tous les ingrédients de la liste Li.
Définir une fonction recherche_recettes_sans_multi(D,Li) renvoyant l’ensemble des recettes du dictionnaire D qui n’utilisent aucun des ingrédients de la liste Li.

Entraînement 5 : Occurence

L’occurrence d’un caractère dans une phrase est son apparition dans la phrase.

On souhaite stocker les nombres d'occurrences dans un dictionnaire dont les clés sont les caractères de la phrase et les valeurs le nombre d'occurrences du caractère. Compléter la fonction occurrence_lettres prenant comme paramètre une chaîne de caractères phrase. Cette fonction doit renvoyer un dictionnaire des nombres d'occurrences des caractères présents dans phrase.

Exemple :

>>> nb_occurrences("Bonjour !"")
{"B": 1, "o": 2, "n": 1, "j": 1, "u": 1, "r": 1, " ": 1, "!": 1}
>>> nb_occurrences("ha ! ha ! ha !")
{"h": 3, "a": 3, " ": 5, "!": 3}

def compteur(text): # créer la fonction compteur en utilisant la chaine de caractère text
    """
    fonction qui compte le nombre d'occurence dans un texte
    """
    occurence = {} # creer le dictionnaire occurence vide 
    for caractere in ...: # parcours la liste texte
        if ... not in occurence.keys(): # teste la présence d'une lettre dans le dictionnaire occurence
            occurence[caractere] = ... # rempli le dictionnaire occurence avec l'alphabet
        else:
            occurence[caractere] = ... + ... # ajoute 1 à l'occurence de l'élément caractère
    return ... # renvoie le resultat  = le dictionnaire occurence


assert compteur("Bonjour !") == {"B": 1, "o": 2, "n": 1, "j": 1, "u": 1, "r": 1, " ": 1, "!": 1}
assert compteur("ha ! ha ! ha !") == {"h": 3, "a": 3, " ": 5, "!": 3}

Voir une solution

Savoir faire

Construire une entrée de dictionnaire.
Itérer les éléments d'un dictionnaire.

Fiche de cours

...	Méthode	Description
Notation	`{"rue" : "place de la mairie","numéro" :3}`	Syntaxe : {cle : valeur }
Construction	`mon_dico["ville"]="Paris"`	Ajoute une valeur "Paris" dans `mon_dico` à la clé "ville".
Lecture	`mon_dico[0]`	Renvoie une erreur car la clé 0 n'existe pas
Lecture	`mon_dico["numéro"]`	Renvoie 3
Opération	`mon_dico + dico` ou`mon_dico *3`	Renvoie une erreur. Les clés ne sont pas modifibale.
Modifiable	`mon_dico.pop("rue")`	Supprime la valeur associé a clé "rue" dans `mon_dico`.
Modifiable	`mon_dico["rue"]="Rue de la mairie"`	On peut modifier une valeur pas une clé.
Méthode	`mon_dico.keys()`	Renvoie la liste des clés de `mon_dico`.
Méthode	`mon_dico.values()`	Renvoie la liste des valeurs de `mon_dico`.
Méthode	`mon_dico_A.update(mon_dico_B)`	fusionne `mon_dico_A` et `mon_dico_B`.
Parcours	`for element in mon_dico`	Permet de parcourir les clés de `mon_dico`.
Parcours	`for cle in mon_dico.keys()`	Permet de parcourir les clés de `mon_dico`.
Parcours	`for valeur in mon_dico.values()`	Permet de parcourir les valeurs de `mon_dico`.
Parcours	`for cle,valeur in mon_dico.items()`	Permet de parcourir les clés et les valeurs de `mon_dico`.

Informatique au lycée Faustin Fleret

Représentation des données : types construits