Explorer d'autres structures de données (dictionnaires)

Introduction aux dictionnaires : les paires clé-valeur en Python

Après avoir exploré les listes, qui sont des séquences ordonnées d'éléments accessibles par un indice numérique, il est temps de découvrir une autre structure de données fondamentale en Python : le dictionnaire. Imaginez un dictionnaire de langue : vous cherchez un mot (la clé) pour trouver sa définition (la valeur). Les dictionnaires Python fonctionnent sur un principe similaire de paires clé-valeur. Ils permettent de stocker des informations de manière non ordonnée (avant Python 3.7) ou ordonnée par insertion (depuis Python 3.7), où chaque valeur est associée à une clé unique qui sert à la récupérer.

Pourquoi utiliser des dictionnaires ? Leur principal avantage réside dans leur capacité à organiser et à récupérer des données de manière intuitive et efficace lorsque l'accès ne se fait pas naturellement par une position numérique, mais plutôt par un identifiant unique. Par exemple, pour stocker des informations sur un utilisateur (nom, âge, ville), un dictionnaire avec des clés comme "nom", "age", "ville" est bien plus explicite qu'une liste où l'on devrait se souvenir que l'élément à l'indice 0 est le nom, l'indice 1 l'âge, etc. La recherche d'une valeur par sa clé est également très rapide, ce qui rend les dictionnaires performants pour de grandes quantités de données.

Les dictionnaires sont extrêmement polyvalents. Ils peuvent contenir des valeurs de n'importe quel type (nombres, chaînes, listes, et même d'autres dictionnaires), et les clés sont généralement des chaînes de caractères ou des nombres, bien qu'elles puissent être n'importe quel type d'objet immuable. Cette flexibilité en fait un outil indispensable pour représenter des objets du monde réel, des configurations, des compteurs, ou pour manipuler des formats de données structurées comme le JSON.

Création et syntaxe des dictionnaires en Python

En Python, un dictionnaire est créé en utilisant des accolades {}. A l'intérieur des accolades, les paires clé-valeur sont séparées par des virgules, et chaque clé est séparée de sa valeur par un deux-points :.

Voici comment créer un dictionnaire vide :

mon_dictionnaire_vide = {}
# ou en utilisant le constructeur dict()
autre_dictionnaire_vide = dict()

print(mon_dictionnaire_vide)    # Affiche: {}
print(type(mon_dictionnaire_vide)) # Affiche: 

Pour créer un dictionnaire avec des éléments initiaux, vous spécifiez les paires clé-valeur :

contact = {
    "nom": "Dupont",
    "prenom": "Jean",
    "age": 30,
    "ville": "Paris",
    "hobbies": ["lecture", "randonnée"]
}

print(contact)

Dans cet exemple, "nom", "prenom", "age", "ville", et "hobbies" sont les clés, et "Dupont", "Jean", 30, "Paris", et la liste ["lecture", "randonnée"] sont leurs valeurs respectives.

Concernant les clés, elles doivent être uniques au sein d'un dictionnaire. Si vous essayez d'ajouter une clé qui existe déjà, la nouvelle valeur écrasera l'ancienne. De plus, les clés doivent être d'un type immuable. Cela signifie que vous pouvez utiliser des chaînes de caractères, des nombres (entiers, flottants), ou des tuples (s'ils ne contiennent que des éléments immuables) comme clés. Les listes, par exemple, ne peuvent pas être utilisées comme clés car elles sont mutables. Les valeurs, en revanche, peuvent être de n'importe quel type de données et peuvent être dupliquées.

# Clés valides
dict_valide = {
    "nom_utilisateur": "Alice123",
    42: "La réponse",
    (1, 2): "Un tuple comme clé"
}

# Tentative de clé invalide (liste)
# dict_invalide = {["a", "b"]: "valeur"}  # Ceci lèverait une TypeError: unhashable type: 'list'

# Duplication de clé (la dernière valeur est conservée)
dict_duplication = {"a": 1, "b": 2, "a": 3}
print(dict_duplication)  # Affiche: {'a': 3, 'b': 2}

Accéder, ajouter et modifier des éléments dans un dictionnaire

Pour accéder à la valeur associée à une clé dans un dictionnaire, vous utilisez la syntaxe nom_du_dictionnaire[clé]. Si la clé existe, sa valeur correspondante est retournée. Si la clé n'existe pas, une erreur de type KeyError sera levée, interrompant votre programme si elle n'est pas gérée.

contact = {"nom": "Dupont", "age": 30}

print(contact["nom"])  # Affiche: Dupont
print(contact["age"])  # Affiche: 30

# Tenter d'accéder à une clé inexistante
# print(contact["ville"])  # Lèverait une KeyError: 'ville'

Pour éviter une KeyError, vous pouvez utiliser la méthode get(). Cette méthode prend la clé en premier argument et, optionnellement, une valeur par défaut en second argument. Si la clé est trouvée, sa valeur est retournée. Si la clé n'est pas trouvée, get() retourne None (si aucun second argument n'est fourni) ou la valeur par défaut que vous avez spécifiée.

contact = {"nom": "Dupont", "age": 30}

ville = contact.get("ville")
print(f"Ville (avec get, sans défaut) : {ville}")  # Affiche: Ville (avec get, sans défaut) : None

pays = contact.get("pays", "France")
print(f"Pays (avec get, avec défaut) : {pays}")    # Affiche: Pays (avec get, avec défaut) : France

nom_existant = contact.get("nom", "Inconnu")
print(f"Nom (clé existante) : {nom_existant}")     # Affiche: Nom (clé existante) : Dupont

Ajouter une nouvelle paire clé-valeur à un dictionnaire est simple : il suffit d'assigner une valeur à une nouvelle clé en utilisant la syntaxe nom_du_dictionnaire[nouvelle_clé] = valeur.

contact = {"nom": "Dupont"}
print(f"Avant ajout : {contact}") # Avant ajout : {'nom': 'Dupont'}

contact["age"] = 30
contact["ville"] = "Paris"
print(f"Après ajout : {contact}") # Après ajout : {'nom': 'Dupont', 'age': 30, 'ville': 'Paris'}

Modifier la valeur associée à une clé existante se fait de la même manière que l'ajout : en réassignant une nouvelle valeur à cette clé. Si la clé existe déjà, sa valeur est mise à jour.

contact = {"nom": "Dupont", "age": 30}
print(f"Avant modification : {contact}") # Avant modification : {'nom': 'Dupont', 'age': 30}

contact["age"] = 31  # Modification de la valeur de la clé 'age'
print(f"Après modification : {contact}") # Après modification : {'nom': 'Dupont', 'age': 31}

Opérations courantes : suppression, vérification et obtention d'informations

Pour supprimer une paire clé-valeur d'un dictionnaire, vous pouvez utiliser l'instruction del suivie du nom du dictionnaire et de la clé entre crochets. Si la clé n'existe pas, une KeyError sera levée.

contact = {"nom": "Dupont", "age": 30, "ville": "Paris"}
print(f"Avant suppression : {contact}")

del contact["ville"]  # Suppression de la clé 'ville' et de sa valeur
print(f"Après suppression de 'ville' : {contact}")

# del contact["pays"]  # Lèverait une KeyError car 'pays' n'existe pas

Une autre méthode pour supprimer un élément et récupérer sa valeur est pop(). La méthode pop(clé[, valeur_par_défaut]) supprime la clé spécifiée et retourne sa valeur. Si la clé n'est pas trouvée et qu'une valeur_par_défaut est fournie, cette valeur est retournée. Sinon (clé non trouvée et pas de valeur par défaut), une KeyError est levée.

contact = {"nom": "Dupont", "age": 30, "profession": "Ingénieur"}

age_supprime = contact.pop("age")
print(f"Age supprimé : {age_supprime}")             # Age supprimé : 30
print(f"Contact après pop('age') : {contact}")    # Contact après pop('age') : {'nom': 'Dupont', 'profession': 'Ingénieur'}

ville_supprimee = contact.pop("ville", "Non spécifiée")
print(f"Ville supprimée (avec défaut) : {ville_supprimee}") # Ville supprimée (avec défaut) : Non spécifiée
print(f"Contact après pop('ville') : {contact}") # Contact après pop('ville') : {'nom': 'Dupont', 'profession': 'Ingénieur'}

# contact.pop("pays") # Lèverait une KeyError

Pour vérifier si une clé existe dans un dictionnaire, utilisez l'opérateur in. Il retourne True si la clé est présente, et False sinon.

contact = {"nom": "Dupont", "age": 30}

print(f"'nom' est dans contact ? {"nom" in contact}")      # Affiche: 'nom' est dans contact ? True
print(f"'ville' est dans contact ? {"ville" in contact}")  # Affiche: 'ville' est dans contact ? False
print(f"'Dupont' est dans contact ? {"Dupont" in contact}") # Affiche: 'Dupont' est dans contact ? False (in vérifie les clés, pas les valeurs)

Les dictionnaires possèdent des méthodes utiles pour obtenir des collections de leurs clés, valeurs ou paires clé-valeur (appelées "items") :

• keys(): retourne un objet de vue affichant une liste de toutes les clés.
• values(): retourne un objet de vue affichant une liste de toutes les valeurs.
• items(): retourne un objet de vue affichant une liste de paires (tuple) clé-valeur.

contact = {"nom": "Alice", "age": 25, "ville": "Lyon"}

cles = contact.keys()
valeurs = contact.values()
items = contact.items()

print(f"Clés : {list(cles)}")       # Clés : ['nom', 'age', 'ville']
print(f"Valeurs : {list(valeurs)}") # Valeurs : ['Alice', 25, 'Lyon']
print(f"Items : {list(items)}")     # Items : [('nom', 'Alice'), ('age', 25), ('ville', 'Lyon')]

Enfin, pour connaître le nombre de paires clé-valeur dans un dictionnaire, utilisez la fonction len().

contact = {"nom": "Alice", "age": 25}
print(f"Nombre d'éléments : {len(contact)}")  # Affiche: Nombre d'éléments : 2

Parcourir les dictionnaires : itérer sur les clés, valeurs et items

Il est souvent nécessaire de parcourir tous les éléments d'un dictionnaire pour effectuer des opérations sur ses clés, ses valeurs, ou les deux. Python offre plusieurs manières d'itérer sur un dictionnaire à l'aide de boucles for.

Par défaut, lorsque vous itérez directement sur un dictionnaire, vous parcourez ses clés :

scores = {"Alice": 90, "Bob": 85, "Charles": 92}

print("Itération sur les clés (par défaut) :")
for nom in scores:
    print(f"Clé : {nom}, Valeur : {scores[nom]}")
# Output:
# Clé : Alice, Valeur : 90
# Clé : Bob, Valeur : 85
# Clé : Charles, Valeur : 92

C'est équivalent à itérer sur scores.keys().

Si vous souhaitez itérer uniquement sur les valeurs du dictionnaire, vous pouvez utiliser la méthode values() :

scores = {"Alice": 90, "Bob": 85, "Charles": 92}

print("\nItération sur les valeurs :")
for score in scores.values():
    print(f"Score : {score}")
# Output:
# Score : 90
# Score : 85
# Score : 92

La manière la plus courante et souvent la plus utile d'itérer sur un dictionnaire est de parcourir ses paires clé-valeur (items) en utilisant la méthode items(). Cette méthode retourne des tuples (clé, valeur) que vous pouvez dépaqueter directement dans deux variables dans votre boucle for.

scores = {"Alice": 90, "Bob": 85, "Charles": 92}

print("\nItération sur les paires clé-valeur (items) :")
for nom, score in scores.items():
    print(f"Nom : {nom}, Score : {score}")
# Output:
# Nom : Alice, Score : 90
# Nom : Bob, Score : 85
# Nom : Charles, Score : 92

Cette dernière approche est généralement préférée car elle donne accès à la fois à la clé et à la valeur de manière directe et lisible, sans nécessiter un accès supplémentaire au dictionnaire comme scores[nom].

Dictionnaires imbriqués et bonnes pratiques d'utilisation

La puissance des dictionnaires réside aussi dans leur capacité à contenir d'autres structures de données complexes, y compris d'autres dictionnaires. On parle alors de dictionnaires imbriqués. Cela permet de créer des structures de données hiérarchiques et très descriptives.

utilisateurs = {
    "user1": {
        "nom": "Alice",
        "age": 30,
        "email": "alice@example.com"
    },
    "user2": {
        "nom": "Bob",
        "age": 24,
        "email": "bob@example.com",
        "adresse": {
            "rue": "123 Rue Principale",
            "ville": "Quelque part"
        }
    }
}

# Accéder à des données imbriquées
print(utilisateurs["user1"]["nom"])  # Affiche: Alice
print(utilisateurs["user2"]["adresse"]["ville"]) # Affiche: Quelque part

L'accès aux éléments se fait en chaînant les accès par clé.

Python offre également une syntaxe concise pour créer des dictionnaires, appelée compréhension de dictionnaire (dictionary comprehension). Similaire aux compréhensions de listes, elle permet de construire des dictionnaires à partir d'itérables de manière élégante.

nombres = [1, 2, 3, 4]
carres = {x: x*x for x in nombres}
print(carres)  # Affiche: {1: 1, 2: 4, 3: 9, 4: 16}

mots = ["pomme", "banane", "cerise"]
longueurs_mots = {mot: len(mot) for mot in mots}
print(longueurs_mots) # Affiche: {'pomme': 5, 'banane': 6, 'cerise': 6}

Quelques bonnes pratiques pour l'utilisation des dictionnaires :

• Choisissez des clés significatives : Les clés doivent être claires et descriptives pour faciliter la compréhension du code.
• Cohérence des types de clés et de valeurs : Bien que Python soit flexible, essayez de maintenir une certaine cohérence dans les types de clés et de valeurs au sein d'un même dictionnaire si cela a du sens pour vos données.
• Utilisez get() ou vérifiez avec in : Pour éviter les KeyError, préférez la méthode get() pour accéder aux éléments ou vérifiez d'abord l'existence de la clé avec l'opérateur in si vous prévoyez d'utiliser l'accès direct par [].
• Quand utiliser un dictionnaire ? Les dictionnaires sont idéaux lorsque vous avez besoin d'associer des valeurs à des identifiants uniques (clés) et que l'ordre n'est pas la principale préoccupation (bien que l'ordre d'insertion soit maintenant garanti depuis Python 3.7). Ils sont parfaits pour représenter des objets avec des attributs, des compteurs, ou pour des recherches rapides basées sur une clé.