Gérer les dictionnaires en Python

Introduction

Dans ce laboratoire, vous acquerrez une expérience pratique avec les dictionnaires Python, une structure de données essentielle pour stocker des données sous forme de paires clé-valeur. Vous apprendrez à créer et à inspecter des dictionnaires, à accéder à leurs éléments et à les modifier, à ajouter et à supprimer des éléments, ainsi qu'à travailler avec les objets de vue de dictionnaire (dictionary view objects). À la fin de ce laboratoire, vous maîtriserez l'exécution des opérations courantes sur les dictionnaires.

Créer et inspecter des dictionnaires

Dans cette étape, vous apprendrez à créer et à inspecter des dictionnaires. Un dictionnaire est une collection de paires clé-valeur où chaque clé doit être unique. Les dictionnaires sont créés avec des accolades {} ou le constructeur dict(). Depuis Python 3.7, les dictionnaires conservent l'ordre dans lequel les éléments ont été insérés.

Tout d'abord, ouvrez le fichier main.py depuis l'explorateur de fichiers situé sur le côté gauche de l'éditeur VS Code.

Ajoutez le code suivant à main.py. Ce script démontre différentes manières de créer un dictionnaire.

## Create an empty dictionary using curly braces
empty_dict = {}
print(f"Empty dictionary: {empty_dict}")
print(f"Type of empty_dict: {type(empty_dict)}")

## Create a dictionary with initial key-value pairs
student_info = {'name': 'Alice', 'age': 25, 'major': 'Computer Science'}
print(f"\nStudent info: {student_info}")

## Create a dictionary using the dict() constructor with keyword arguments
student_info_kw = dict(name='Bob', age=22, major='Physics')
print(f"Student info (from keywords): {student_info_kw}")

## Create a dictionary from a list of key-value tuples
student_info_tuples = dict([('name', 'Charlie'), ('age', 28), ('major', 'Chemistry')])
print(f"Student info (from tuples): {student_info_tuples}")

Après avoir ajouté le code, enregistrez le fichier en appuyant sur Ctrl + S.

Exécutez maintenant le script en ouvrant un terminal dans l'éditeur VS Code (Ctrl + ~) et en exécutant la commande suivante :

python main.py

Vous devriez voir la sortie suivante, qui montre les différents dictionnaires que vous avez créés :

Empty dictionary: {}
Type of empty_dict: <class 'dict'>

Student info: {'name': 'Alice', 'age': 25, 'major': 'Computer Science'}
Student info (from keywords): {'name': 'Bob', 'age': 22, 'major': 'Physics'}
Student info (from tuples): {'name': 'Charlie', 'age': 28, 'major': 'Chemistry'}

Cette étape vous a enseigné les méthodes fondamentales pour créer des dictionnaires en Python, à la fois vides et avec des données initiales.

Accéder et modifier les éléments de dictionnaire

Dans cette étape, vous apprendrez à accéder et à modifier les éléments au sein d'un dictionnaire. Vous pouvez récupérer une valeur en faisant référence à sa clé entre crochets [].

Tout d'abord, effacez le contenu précédent de main.py. Ensuite, ajoutez le code suivant au fichier. Ce script démontre comment accéder et modifier les données du dictionnaire.

## Define a sample dictionary
student_info = {'name': 'Alice', 'age': 25, 'major': 'Computer Science'}
print(f"Original dictionary: {student_info}")

## Access elements using square brackets
student_name = student_info['name']
print(f"\nStudent Name: {student_name}")

## Using the get() method to access an element
student_age = student_info.get('age')
print(f"Student Age (using get()): {student_age}")

## The get() method can provide a default value if the key is not found
student_city = student_info.get('city', 'Not Specified')
print(f"Student City (with default): {student_city}")

## Modify the value of an existing key
print(f"\nOriginal age: {student_info['age']}")
student_info['age'] = 26
print(f"Modified age: {student_info['age']}")

print(f"\nUpdated dictionary: {student_info}")

Enregistrez le fichier (Ctrl + S) et exécutez le script depuis le terminal :

python main.py

La sortie montre comment récupérer des valeurs et à quoi ressemble le dictionnaire après une modification :

Original dictionary: {'name': 'Alice', 'age': 25, 'major': 'Computer Science'}

Student Name: Alice
Student Age (using get()): 25
Student City (with default): Not Specified

Original age: 25
Modified age: 26

Updated dictionary: {'name': 'Alice', 'age': 26, 'major': 'Computer Science'}

Notez que l'utilisation des crochets [] pour accéder à une clé inexistante lèvera une KeyError, tandis que get() offre une manière plus sûre d'accéder aux clés qui pourraient ne pas exister.

Ajouter et supprimer des éléments de dictionnaire

Cette étape couvre l'ajout de nouveaux éléments à un dictionnaire et la suppression de ceux qui existent. Vous pouvez ajouter une nouvelle paire clé-valeur en assignant une valeur à une nouvelle clé.

Remplacez le contenu de main.py par le code suivant. Ce script démontre le cycle de vie complet des éléments du dictionnaire : les ajouter, les mettre à jour et les supprimer de différentes manières.

## Define a sample dictionary
student_info = {'name': 'Alice', 'age': 26, 'major': 'Computer Science'}
print(f"Initial dictionary: {student_info}")

## Add a new key-value pair
student_info['city'] = 'New York'
print(f"After adding 'city': {student_info}")

## Delete an element using pop()
## pop() removes the key and returns its value
removed_major = student_info.pop('major')
print(f"\nRemoved major: {removed_major}")
print(f"After pop('major'): {student_info}")

## Delete the last inserted element using popitem()
## popitem() removes and returns the (key, value) pair
removed_item = student_info.popitem()
print(f"\nRemoved item: {removed_item}")
print(f"After popitem(): {student_info}")

## Delete an element using the 'del' statement
del student_info['age']
print(f"\nAfter del student_info['age']: {student_info}")

## The clear() method removes all elements from the dictionary
student_info.clear()
print(f"After clear(): {student_info}")

Enregistrez le fichier (Ctrl + S) et exécutez le script :

python main.py

La sortie affichera le dictionnaire à chaque étape de modification :

Initial dictionary: {'name': 'Alice', 'age': 26, 'major': 'Computer Science'}
After adding 'city': {'name': 'Alice', 'age': 26, 'major': 'Computer Science', 'city': 'New York'}

Removed major: Computer Science
After pop('major'): {'name': 'Alice', 'age': 26, 'city': 'New York'}

Removed item: ('city', 'New York')
After popitem(): {'name': 'Alice', 'age': 26}

After del student_info['age']: {'name': 'Alice'}
After clear(): {}

Dans cette étape, vous avez appris à ajouter de nouveaux éléments et à les supprimer en utilisant pop(), popitem(), del et clear().

Explorer les objets de vue de dictionnaire

Dans cette étape, vous allez explorer les objets de vue de dictionnaire. Ce sont des objets dynamiques qui fournissent une vue des clés, des valeurs ou des éléments d'un dictionnaire. Tout changement apporté au dictionnaire se reflète immédiatement dans la vue.

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

## Define a sample dictionary
student_info = {'name': 'Alice', 'age': 26, 'major': 'Computer Science'}
print(f"Original dictionary: {student_info}\n")

## Get the view objects
keys_view = student_info.keys()
values_view = student_info.values()
items_view = student_info.items()

print(f"Keys View: {keys_view}")
print(f"Values View: {values_view}")
print(f"Items View: {items_view}")

## Views are dynamic and reflect dictionary changes
print("\n--- Modifying Dictionary ---")
student_info['city'] = 'New York'
print(f"Dictionary after adding 'city': {student_info}")
print(f"Keys View after modification: {keys_view}")
print(f"Values View after modification: {values_view}")

## You can iterate over view objects
print("\n--- Iterating over Keys View ---")
for key in keys_view:
    print(key)

## You can convert views to other data types like lists
keys_list = list(keys_view)
print(f"\nKeys view converted to a list: {keys_list}")

Enregistrez le fichier (Ctrl + S) et exécutez le script :

python main.py

La sortie démontre la création, la nature dynamique et l'itération des objets de vue :

Original dictionary: {'name': 'Alice', 'age': 26, 'major': 'Computer Science'}

Keys View: dict_keys(['name', 'age', 'major'])
Values View: dict_values(['Alice', 26, 'Computer Science'])
Items View: dict_items([('name', 'Alice'), ('age', 26), ('major', 'Computer Science')])

--- Modifying Dictionary ---
Dictionary after adding 'city': {'name': 'Alice', 'age': 26, 'major': 'Computer Science', 'city': 'New York'}
Keys View after modification: dict_keys(['name', 'age', 'major', 'city'])
Values View after modification: dict_values(['Alice', 26, 'Computer Science', 'New York'])

--- Iterating over Keys View ---
name
age
major
city

Keys view converted to a list: ['name', 'age', 'major', 'city']

Cette étape vous a montré comment utiliser keys(), values() et items() pour obtenir des vues dynamiques du contenu d'un dictionnaire, ce qui est utile pour de nombreuses tâches de programmation.

Résumé

Dans ce laboratoire, vous avez acquis une expérience pratique avec les dictionnaires Python. Vous avez commencé par créer des dictionnaires en utilisant les accolades {} et le constructeur dict(). Vous avez ensuite appris à accéder et à modifier les éléments du dictionnaire en utilisant la notation entre crochets [] et la méthode get(). Ensuite, vous vous êtes exercé à ajouter de nouvelles paires clé-valeur et à les supprimer avec diverses méthodes, notamment pop(), popitem(), l'instruction del et clear(). Enfin, vous avez exploré les objets de vue de dictionnaire dynamiques (keys(), values() et items()), en comprenant comment ils reflètent les changements dans le dictionnaire et comment les parcourir (itérer).