Dictionnaires Python

Introduction

En Python, un dictionnaire est une collection ordonnée (depuis Python 3.7) de paires clé: valeur. Les dictionnaires sont utilisés pour stocker des valeurs de données d'une manière qui est mutable, indexée et qui n'autorise pas les clés dupliquées. Les opérations principales sur un dictionnaire sont le stockage d'une valeur avec une clé et l'extraction de la valeur étant donnée la clé.

Par exemple, vous pouvez créer un dictionnaire pour stocker des informations sur un chat :

## Dictionary: collection of key-value pairs
my_cat = {
    'size': 'fat',          ## key: 'size', value: 'fat'
    'color': 'gray',        ## key: 'color', value: 'gray'
    'disposition': 'loud'   ## key: 'disposition', value: 'loud'
}

Dans ce laboratoire, vous apprendrez à créer des dictionnaires, à accéder et modifier leurs données, à les parcourir (itérer) et à utiliser diverses méthodes utilitaires pour travailler efficacement avec eux.

Accéder et Modifier les Données du Dictionnaire

Dans cette étape, vous apprendrez à créer un dictionnaire, à ajouter de nouvelles paires clé-valeur, à mettre à jour celles qui existent et à récupérer des valeurs en utilisant l'opérateur de sous-script [].

Vous pouvez ajouter ou mettre à jour une entrée de dictionnaire en assignant une valeur à une clé en utilisant l'opérateur []. Si la clé existe déjà, sa valeur est mise à jour. Si la clé n'existe pas, une nouvelle paire clé-valeur est ajoutée.

Note: Si vous n'êtes pas familier avec l'utilisation de WebIDE (similaire à VS Code), veuillez vous familiariser d'abord avec ce lab.

Commençons par créer un fichier pour écrire notre code.

Tout d'abord, ouvrez le fichier main.py situé dans le répertoire ~/project depuis l'explorateur de fichiers à gauche.

Maintenant, ajoutez le code suivant à main.py. Ce code définit un dictionnaire puis lui ajoute une nouvelle paire clé-valeur.

## Add or update dictionary entry using subscript operator
my_cat = {
 'size': 'fat',
 'color': 'gray',
 'disposition': 'loud',
}
my_cat['age_years'] = 2  ## Add new key-value pair
print(my_cat)

Pour exécuter le script, ouvrez un terminal et exécutez la commande suivante :

python3 main.py

Vous devriez voir le dictionnaire mis à jour s'afficher dans la console :

{'size': 'fat', 'color': 'gray', 'disposition': 'loud', 'age_years': 2}

Vous pouvez également récupérer une valeur en utilisant la clé à l'intérieur de l'opérateur de sous-script []. Modifions le fichier main.py pour accéder et afficher la valeur associée à la clé 'size'.

Remplacez le contenu de main.py par le code suivant :

my_cat = {
 'size': 'fat',
 'color': 'gray',
 'disposition': 'loud',
}
print(my_cat['size'])

Exécutez à nouveau le script :

python3 main.py

Le résultat sera la valeur de la clé 'size' :

fat

Sachez que si vous essayez d'accéder à une clé qui n'est pas dans le dictionnaire, Python lèvera une KeyError. Voyons cela en action. Remplacez le code dans main.py par ceci :

my_cat = {
 'size': 'fat',
 'color': 'gray',
 'disposition': 'loud',
}
print(my_cat['eye_color'])

Exécutez le script :

python3 main.py

Ceci entraînera une KeyError car la clé 'eye_color' n'existe pas dans le dictionnaire my_cat.

Traceback (most recent call last):
  File "/home/labex/project/main.py", line 5, in <module>
    print(my_cat['eye_color'])
KeyError: 'eye_color'

Pour la vérification, veuillez rétablir main.py au premier exemple qui ajoute une nouvelle clé et affiche le dictionnaire entier.

## Add or update dictionary entry using subscript operator
my_cat = {
 'size': 'fat',
 'color': 'gray',
 'disposition': 'loud',
}
my_cat['age_years'] = 2  ## Add new key-value pair
print(my_cat)

Itérer sur les Dictionnaires

Dans cette étape, vous explorerez différentes manières de parcourir un dictionnaire. Python fournit plusieurs méthodes pour itérer sur les clés, les valeurs, ou les deux d'un dictionnaire.

Itération sur les Valeurs avec values()

La méthode values() retourne un objet vue qui affiche une liste de toutes les valeurs du dictionnaire. Vous pouvez parcourir cet objet pour accéder à chaque valeur.

Effacez le fichier main.py et ajoutez le code suivant :

## Iterate over dictionary values using .values() method
pet = {'color': 'red', 'age': 42}
for value in pet.values():  ## Loop through all values
    print(value)

Exécutez le script :

python3 main.py

Le résultat affichera chaque valeur sur une nouvelle ligne :

red
42

Itération sur les Clés avec keys()

De manière similaire, la méthode keys() retourne un objet vue contenant les clés du dictionnaire. Bien que vous puissiez utiliser pet.keys(), itérer directement sur le dictionnaire lui-même est la manière la plus courante et la plus "Pythonique" de parcourir ses clés.

Mettez à jour main.py avec le code suivant :

## Iterating over dictionary directly loops through keys (default behavior)
pet = {'color': 'red', 'age': 42}
for key in pet:  ## Equivalent to for key in pet.keys()
    print(key)

Exécutez le script :

python3 main.py

Vous verrez les clés s'afficher :

color
age

Itération sur les Paires Clé-Valeur avec items()

La méthode items() est très utile lorsque vous avez besoin à la fois de la clé et de la valeur pendant l'itération. Elle retourne un objet vue où chaque élément est un tuple (clé, valeur).

Mettez à jour main.py pour utiliser items() :

## Iterate over key-value pairs using .items() method
pet = {'color': 'red', 'age': 42}
for key, value in pet.items():  ## Unpack tuple into key and value
    print(f'Key: {key} Value: {value}')

Ici, nous utilisons le dépaquetage de tuple (for key, value in ...) pour assigner le premier élément du tuple à key et le second à value à chaque itération.

Exécutez le script :

python3 main.py

Le résultat sera des chaînes formatées montrant chaque paire clé-valeur :

Key: color Value: red
Key: age Value: 42

Accès Sécurisé et Ajout d'Éléments

Dans cette étape, vous apprendrez comment récupérer des valeurs en toute sécurité sans provoquer de KeyError et comment ajouter des éléments conditionnellement.

Récupération Sécurisée avec get()

Comme vous l'avez vu à l'Étape 1, essayer d'accéder à une clé inexistante avec [] lève une KeyError. La méthode get() offre une manière plus sûre d'accéder aux clés. Elle retourne la valeur d'une clé si elle existe, mais si elle n'existe pas, elle retourne None au lieu de lever une erreur.

Effacez main.py et ajoutez le code suivant :

## .get() method: safely retrieve value, returns None if key doesn't exist
wife = {'name': 'Rose', 'age': 33}

print(f'My wife name is {wife.get("name")}')
print(f'She is deeply in love with {wife.get("husband")}')

Exécutez le script :

python3 main.py

Le résultat montre que get() a retourné la valeur pour 'name' et None pour la clé manquante 'husband' :

My wife name is Rose
She is deeply in love with None

Vous pouvez également fournir une valeur par défaut à get() comme deuxième argument. Cette valeur sera retournée si la clé n'est pas trouvée.

Modifiez main.py pour fournir une valeur par défaut :

wife = {'name': 'Rose', 'age': 33}

print(f'She is deeply in love with {wife.get("husband", "lover")}')

Exécutez à nouveau :

python3 main.py

Maintenant, le résultat utilise votre valeur par défaut personnalisée :

She is deeply in love with lover

Ajout Conditionnel avec setdefault()

La méthode setdefault() offre une manière concise d'ajouter une paire clé-valeur uniquement si la clé n'existe pas déjà. Elle vérifie la clé ; si elle est présente, elle retourne la valeur de la clé. Si elle n'est pas présente, elle insère la clé avec la valeur spécifiée et retourne cette valeur.

Mettez à jour main.py pour utiliser setdefault() :

wife = {'name': 'Rose', 'age': 33}
wife.setdefault('has_hair', True) ## 'has_hair' does not exist, so it's added.
wife.setdefault('name', 'Lily') ## 'name' exists, so the dictionary is not changed.
print(wife)

Exécutez le script :

python3 main.py

Le résultat montre que 'has_hair' a été ajouté, mais que la valeur de 'name' n'a pas été mise à jour :

{'name': 'Rose', 'age': 33, 'has_hair': True}

Supprimer des Éléments d'un Dictionnaire

Dans cette étape, vous vous entraînerez avec diverses méthodes pour supprimer des éléments d'un dictionnaire.

Suppression avec pop()

La méthode pop() supprime un élément avec la clé spécifiée et retourne sa valeur. Si la clé n'est pas trouvée, elle lève une KeyError à moins qu'une valeur par défaut ne soit fournie.

Effacez main.py et ajoutez le code suivant pour voir pop() en action :

wife = {'name': 'Rose', 'age': 33, 'hair': 'brown'}
removed_value = wife.pop('age')
print(f"Removed value: {removed_value}")
print(wife)

Exécutez le script :

python3 main.py

Le résultat montre la valeur supprimée et le dictionnaire après la suppression :

Removed value: 33
{'name': 'Rose', 'hair': 'brown'}

Suppression avec popitem()

La méthode popitem() supprime le dernier élément inséré dans un dictionnaire (dans Python 3.7+). Elle retourne l'élément supprimé sous forme de tuple (clé, valeur).

Modifiez main.py pour utiliser popitem() :

wife = {'name': 'Rose', 'age': 33, 'hair': 'brown'}
removed_item = wife.popitem()
print(f"Removed item: {removed_item}")
print(wife)

Exécutez le script :

python3 main.py

Le dernier élément, ('hair', 'brown'), est supprimé et affiché :

Removed item: ('hair', 'brown')
{'name': 'Rose', 'age': 33}

Suppression avec le Mot-Clé del

Le mot-clé del peut être utilisé pour supprimer un élément par sa clé. Il ne retourne pas la valeur de l'élément supprimé.

Modifiez main.py pour utiliser del :

wife = {'name': 'Rose', 'age': 33, 'hair': 'brown'}
del wife['age']
print(wife)

Exécutez le script :

python3 main.py

Le dictionnaire est affiché sans la clé 'age' :

{'name': 'Rose', 'hair': 'brown'}

Suppression de Tous les Éléments avec clear()

La méthode clear() supprime tous les éléments d'un dictionnaire, le laissant vide.

Modifiez main.py pour utiliser clear() :

wife = {'name': 'Rose', 'age': 33, 'hair': 'brown'}
wife.clear()
print(wife)

Exécutez le script :

python3 main.py

Le résultat est un dictionnaire vide :

{}

Pour la vérification, veuillez vous assurer que votre main.py utilise pop() pour supprimer la clé 'age' et affiche le dictionnaire final.

wife = {'name': 'Rose', 'age': 33, 'hair': 'brown'}
wife.pop('age')
print(wife)

Opérations Utilitaires sur les Dictionnaires

Dans cette étape, vous découvrirez quelques utilitaires de dictionnaire utiles, y compris la vérification de l'existence des clés et des valeurs, l'impression formatée (pretty-printing) et la fusion de dictionnaires.

Vérification des Clés et des Valeurs avec in

Vous pouvez utiliser l'opérateur in pour vérifier si une clé existe dans un dictionnaire.

Effacez main.py et ajoutez ce code :

person = {'name': 'Rose', 'age': 33}

print(f"'name' in person: {'name' in person}")
print(f"'height' in person: {'height' in person}")

Exécutez le script :

python3 main.py

Le résultat affiche True pour une clé existante et False pour une clé inexistante :

'name' in person: True
'height' in person: False

Vous pouvez également utiliser in avec la méthode values() pour vérifier si une valeur existe dans le dictionnaire.

Modifiez main.py :

person = {'name': 'Rose', 'age': 33}

print(f"'Rose' in person.values(): {'Rose' in person.values()}")
print(f"33 in person.values(): {33 in person.values()}")
print(f"'John' in person.values(): {'John' in person.values()}")

Exécutez-le :

python3 main.py

Résultat :

'Rose' in person.values(): True
33 in person.values(): True
'John' in person.values(): False

Impression Formatée avec pprint

Lorsque les dictionnaires sont volumineux, les imprimer directement peut résulter en une longue ligne difficile à lire. Le module pprint fournit une capacité de "pretty-print" pour les formater d'une manière plus lisible.

Mettez à jour main.py :

import pprint

wife = {'name': 'Rose', 'age': 33, 'has_hair': True, 'hair_color': 'brown', 'height': 1.6, 'eye_color': 'brown'}
pprint.pprint(wife)

Exécutez le script :

python3 main.py

Le résultat est joliment formaté, avec les clés triées par ordre alphabétique :

{'age': 33,
 'eye_color': 'brown',
 'hair_color': 'brown',
 'has_hair': True,
 'height': 1.6,
 'name': 'Rose'}

Fusion de Dictionnaires

Vous pouvez fusionner deux dictionnaires en utilisant l'opérateur de dépaquetage de dictionnaire ** (disponible dans Python 3.5+). S'il y a des clés qui se chevauchent, la valeur du deuxième dictionnaire sera utilisée.

Mettez à jour main.py avec le code suivant :

dict_a = {'a': 1, 'b': 2}
dict_b = {'b': 3, 'c': 4}
dict_c = {**dict_a, **dict_b}
print(dict_c)

Exécutez le script :

python3 main.py

Le résultat est un nouveau dictionnaire contenant tous les éléments des deux. Notez que la valeur pour la clé 'b' est 3, qui provient de dict_b.

{'a': 1, 'b': 3, 'c': 4}

Résumé

Félicitations pour avoir terminé ce laboratoire sur les dictionnaires Python !

Dans ce laboratoire, vous avez appris les opérations fondamentales pour travailler avec l'une des structures de données les plus puissantes de Python. Vous avez couvert :

• Création, Accès et Modification : Utilisation de {} pour créer des dictionnaires et de l'opérateur de sous-script [] pour ajouter, mettre à jour et récupérer des données.
• Itération : Parcours des clés, des valeurs et des paires clé-valeur en utilisant les méthodes keys(), values() et items().
• Opérations Sécurisées : Utilisation de get() pour éviter les KeyError et de setdefault() pour ajouter des éléments conditionnellement.
• Suppression d'Éléments : Utilisation de pop(), popitem(), du mot-clé del et de clear() pour supprimer des éléments.
• Opérations Utilitaires : Vérification de l'appartenance avec l'opérateur in, formatage de la sortie avec pprint, et fusion de dictionnaires avec l'opérateur de dépaquetage **.

La maîtrise des dictionnaires est une étape cruciale pour devenir un programmeur Python compétent. Continuez à pratiquer ces concepts pour construire des applications plus complexes et efficaces.