Python: Les dictionnaires

Pour une lecture plus agréable (page plus large), je vous invite à cliquer sur ce lien et à lire ce chapitre dans la rubrique consacrée au langage Python.

J’habite en Allemagne et l’idiome guttural de ce pays n’est pas ma langue maternelle. Par conséquent, lorsqu’un mot me manque, je consulte un dictionnaire. Je me rends directement à l’emplacement précis du mot français, par exemple Ambulance, et ce mot français est comme une clé qui me donne accès à la valeur correspondante dans la langue de Rammstein :

Ambulance : Krankenwagen

Figurez-vous qu’il existe exactement le même procédé en Python et c’est bien plus pratique qu’une liste. Les dictionnaires sont la solution idéale pour réaliser un test d’appartenance et en extraire une valeur.

dico
Ne jamais laver un dictionnaire à 60°!

Limitation des listes

Le problème des listes, c’est qu’il s’agit d’une séquence d’objets indicés, c’est-à dire que pour avoir accès à un élément précis, il faut connaitre son indice :

mots_fr = ["Ambulance", "Hôpital","Infirmière"]
mots_allemands = ["Krankenwagen", "Krankenhaus","Krankenschwester"]

Par exemple, je sais que l’indice d’Infirmière est le nombre entier 2. Je consulte la liste allemande. Que trouve-t-on à l’indice 2? Krankenschwester.

Pas très pratique tout ça! En plus, est-ce que je suis sûr que les traductions sont rangées dans le bon ordre. Est-ce que le mot allemand qui est à l’indice 1 (Krankenhaus) correspond bien au mot français au même indice (Hôpital)? Si ça se trouve, c’est tout dans le désordre!

Pour éviter ce genre de désagréments, on pourrait alors imaginer une liste de listes contenant des paires mot_allemand – mot_français:

dictionnaire = [["Ambulance", "Krankenwagen"], ["Hôpital", "Krankenhaus"],["Infirmière", "Krankenschwester"], [(...), (...)]]

Et pour trouver la traduction, on pourrait utiliser ce code:

dictionnaire =[["Ambulance", "Krankenwagen"], ["Hôpital", "Krankenhaus"],["Infirmière", "Krankenschwester"]]
for i, element in enumerate (dictionnaire):
    if "Hôpital" in dictionnaire[i]:
        print(dictionnaire[i][1])

Résultat: « Krankenhaus »

« Ça marche, Ordinosor! On l’a, notre dictionnaire français-allemand ».

Ne t’emballe pas, jeune fou! je te rappelle que les listes sont des séquences. Cela signifie que pour faire un test d’appartenance, elles sont parcourues de l’indice 0 jusqu’à l’indice de l’élément recherché. En clair, si tu cherches la traduction de zygomatique qui se trouve à la fin du dictionnaire, il va falloir que tu tournes toutes les pages une par une et que tu lises tous les mots un par un! Tu n’as pas le choix, ton dictionnaire est une liste.

Tu sais quoi? On va se donner rendez-vous en 2025. Tu m’apporteras ta traduction. Allez vas-y, tourne les pages!

Bon… en attendant, entrons dans le vif du sujet.

Définition et déclaration d’un dictionnaire

Définition

Un dictionnaire est un ensemble dont les éléments sont des paires clé-valeur . Au niveau syntaxique, un dictionnaire est contenu entre deux accolades. Les éléments sont séparés par des virgules tandis que les paires clé-valeur sont séparées par deux points. Voici ce que ça donne:

nom_du_dictionnaire = {clé : valeur, clé : valeur, clé : valeur, (…) : (…)}

Un dictionnaire est modifiable et les valeurs peuvent être n’importe quel objet (immuable ou modifiable, il n’y a aucune restriction) mais les clés doivent absolument être des objets immuables (string, nombre entier, nombre décimal, tuple). Si la clé est un tuple, celui-ci ne doit contenir que des éléments immuables. Par exemple, ce genre de clé ([0, 1], [2, 3]) qui est un tuple contenant des listes modifiables va lever une exception (erreur):

TypeError: unhashable type: ‘list’

Déclarer un dictionnaire

  • Pour déclarer un dictionnaire, on utilise des accolades :
dictionnaire = {} # dictionnaire vide
  • Je viens de créer un dictionnaire vide mais je peux très bien créer un dictionnaire et y placer des éléments dès sa déclaration :
capitales = {"France":"Paris", "Allemagne" : "Berlin"}

Dans cet exemple, « France » est une clé tandis que « Paris » est une valeur.

  • Il existe une autre méthode pour créer un dictionnaire. Elle consiste à créer une liste de tuples que l’on transforme en dictionnaire grâce au constructeur dict().
liste_capitales = [("France","Paris"), ("Allemagne","Berlin")]
capitales = dict(liste_capitales)
print(capitales)

Résultat : {‘Allemagne’: ‘Berlin’, ‘France’: ‘Paris’}

  • Il n’est pas possible de dupliquer une clé. Si on le fait, ce sera la dernière valeur entrée pour cette clé qui sera prise en compte.
capitales = {"France":"Paris", "Allemagne" : "Berlin", "France" : "Marseille"}
print(capitales)

Résultat: {‘Allemagne’: ‘Berlin’, ‘France’: ‘Marseille’}

Ajouter un élément (paire clé-valeur)

Si je veux rajouter un élément, c’est très simple, je créé une nouvelle paire clé-valeur. La clé  est contenue entre des crochets et la valeur se trouve à la droite du signe d’affectation. La syntaxe est donc la suivante :

nom_du_dico[clé] = valeur

capitales['Islande'] = "Reykjavik"
print(capitales)

Résultat : {‘Allemagne’: ‘Berlin’, ‘Islande’: ‘Reykjavik’, ‘France’: ‘Paris’}

Diantre! Les éléments ne sont plus dans le même ordre? Comment se fait-ce?

Ça n’a aucune espèce d’importance. L’ordre est aléatoire car un dictionnaire n’est pas une séquence, c’est une implémentation de tables de hachage. Pour retrouver une valeur, nous avons seulement besoin de connaître sa clé.

Accéder à une valeur

Voici comment on accède à une valeur:

capitales = {'Allemagne': 'Berlin', 'Islande': 'Reykjavik', 'France': 'Paris'}
result = capitales["Allemagne"] #Je stocke le résultat dans une variable.
print(result)

Résultat : « Berlin »

C’est simple et instantané! Le programme n’a pas besoin de parcourir le dictionnaire du début à la fin. Grâce à la clé (« Allemagne »), Python est en mesure de se rendre directement à la « page » souhaitée pour trouver la valeur et renvoyer cette dernière. Que le dictionnaire contienne dix éléments ou cinq cent millions, la vitesse d’exécution sera de toute façon identique!

Et si j’utilise une clé qui n’est pas dans le dictionnaire, Python lève une exception (erreur):

result = capitales["Syldavie"]
print(result)

KeyError: ‘Syldavie’

La méthode get() comme test d’appartenance

Pour contourner cette exception et éviter d’avoir un message d’erreur qui stoppe le programme, il suffit d’utiliser la méthode get() en lui passant deux arguments : la clé et le résultat renvoyé au cas où la clé serait absente du dictionnaire. Reprenons le code précédent :

result = capitales.get("Syldavie", "Non répertorié.")
print(result)

Résultat : Non répertorié.

Tester l’appartenance avec l’instruction in

Il est possible de tester l’appartenance d’une clé à un dictionnaire grâce à la puissante instruction in.

capitales = {"France":"Paris", "Allemagne" : "Berlin","Islande": "Reykjavik"}
if "Islande" in capitales:
    print(capitales["Islande"])

Résultat : Reykjavik

Je précise que l’instruction in ne teste que l’appartenance des clés et non pas l’appartenance des valeurs.

capitales = {"France":"Paris", "Allemagne" : "Berlin","Islande": "Reykjavik"}
if "Reykjavik" in capitales:
    print("Test d'appartenance réussi")
else:
    print("Cette clé est absente du dictionnaire")

Résultat: Cette clé est absente du dictionnaire

Mettre à jour une valeur

Si on souhaite mettre à jour une valeur, c’est fort simple. Voici comment on procède:

capitales = {"France":"Paris", "Allemagne" : "Berlin","Islande": "Reykjavik"}
capitales["France"] = "Marseille"
print(capitales)

Résultat: {‘France’: ‘Marseille’, ‘Allemagne’: ‘Berlin’, ‘Islande’: ‘Reykjavik’}

Utiliser un tuple comme clé

C’est tout à fait possible, à la condition que le tuple ne contienne que des objets immuables. Quant à la valeur, elle peut être constituée par n’importe quel objet donc une liste ne pose aucun problème.

Dès lors, on peut très bien imaginer un dictionnaire avec en guise de clés, des tuples contenant les noms de capitales et les noms de pays et en guise de valeurs, des listes contenant la latitude et la longitude.

coords = {("Paris","France"):["48° 51′ N", "2° 21′ E"], ("Berlin","Allemagne"): ["52° 31′ N", "13° 24′ O"]}
result = coords[("Paris", "France")]
print(result)

Résultat : [’48° 51′ N’, ‘2° 21′ E’]

code_dict
Visualisation du code avec Pythontutor

Supprimer un élément grâce à l’instruction del

Nous avons vu comment rajouter un élément dans un dictionnaire. C’est d’une simplicité enfantine. Pas besoin de faire appel à la méthode append().

Pour supprimer un élément, on utilise l’instruction del. En fait, on supprime la clé et par conséquent, la valeur qui lui est associée.

capitales = {"France":"Paris", "Allemagne" : "Berlin","Islande": "Reykjavik"}
del capitales["Allemagne"]
print(capitales)

Résultat : {‘France’: ‘Paris’, ‘Islande’: ‘Reykjavik’}

Supprimer tout le dictionnaire grâce à l’instruction del

Notez bien que l’instruction del permet également de supprimer tout le dictionnaire. Il suffit pour cela, de ne pas lui passer de clé entre crochets.

capitales = {"France":"Paris", "Allemagne" : "Berlin","Islande": "Reykjavik"}
del capitales
print(capitales)

NameError: name ‘capitales’ is not defined

Ce message d’erreur nous confirme que le dictionnaire n’existe plus.

Utiliser la fonction intégrée len()

On peut également utiliser la fonction intégrée len() pour connaître le nombre de paires clé-valeur contenues dans un dictionnaire.

capitales = {"France":"Paris", "Allemagne" : "Berlin","Islande": "Reykjavik"}
print(len(capitales))

Résultat: 3

Aperçu de quelques méthodes associées aux dictionnaires

  • dict.clear() supprime tous les éléments d’un dictionnaire. En clair, il le vide.
capitales = {"France":"Paris", "Allemagne" : "Berlin","Islande": "Reykjavik"}
capitales.clear() # Vide le dictionnaire
print(capitales)

Résultat: {}

  • dict.items() retourne toutes les paires clé-valeur sous la forme d’une liste de tuples
capitales = {"France":"Paris", "Allemagne" : "Berlin","Islande": "Reykjavik"}
result = capitales.items()
print(result)

Résultat: dict_items([(‘Islande’, ‘Reykjavik’), (‘France’, ‘Paris’), (‘Allemagne’, ‘Berlin’)])

  • dict.keys() retourne toutes les clés du dictionnaire sous la forme d’une liste
capitales = {"France":"Paris", "Allemagne" : "Berlin","Islande": "Reykjavik"}
result = capitales.keys()
print(result)

Résultat: dict_keys([‘Islande’, ‘Allemagne’, ‘France’])

  • dict.values() retourne toutes les valeur du dictionnaire sous la forme d’une liste
capitales = {"France":"Paris", "Allemagne" : "Berlin","Islande": "Reykjavik"}
result = capitales.values()
print(result)

Résultat: dict_values([‘Berlin’, ‘Reykjavik’, ‘Paris’])

Conclusion

Un dictionnaire est un ensemble non ordonné de paires clé-valeur. Chaque clé donne accès à la valeur qui lui est associée. Plus puissant qu’une liste, Un dictionnaire est idéal pour réaliser un test d’appartenance. En effet, comme il s’agit d’une implémentation de table de hachage et non pas d’une séquence, la vitesse d’exécution du test d’appartenance n’est pas liée au nombre d’éléments que le dictionnaire contient.

Il existe des compréhensions de dictionnaire qui feront l’objet d’un chapitre ultérieur.

Publicités

Auteur : Ordinosor

Bienvenue sur Miamondo, mon blog personnel. "Mia mondo", c'est de l'espéranto et ça signifie "Mon monde" en français. Je m'appelle Benoît alias Ordinosor, Français expatrié en Allemagne. Mes centres d'intérêt sont les distributions GNU/Linux, le langage de programmation Python, la science-fiction et l'espéranto.

Laisser un commentaire

Entrez vos coordonnées ci-dessous ou cliquez sur une icône pour vous connecter:

Logo WordPress.com

Vous commentez à l'aide de votre compte WordPress.com. Déconnexion / Changer )

Image Twitter

Vous commentez à l'aide de votre compte Twitter. Déconnexion / Changer )

Photo Facebook

Vous commentez à l'aide de votre compte Facebook. Déconnexion / Changer )

Photo Google+

Vous commentez à l'aide de votre compte Google+. Déconnexion / Changer )

Connexion à %s