Méthodes des dictionnaires Python

Les dictionnaires Python stockent les données sous forme de paires clé-valeur et disposent d'un riche ensemble de méthodes intégrées pour lire, ajouter, mettre à jour et supprimer des entrées. Ce chapitre couvre toutes les méthodes de dictionnaire disponibles en Python 3, avec des exemples corrects et des notes pratiques sur quand — et quand ne pas — utiliser chacune d'elles.

Pour une introduction générale aux dictionnaires (création, accès aux éléments, imbrication), consultez le chapitre Dictionnaires Python.

Qu'est-ce qu'un dictionnaire Python ?

Un dictionnaire associe des clés uniques à des valeurs. Les clés doivent être hachables (les chaînes, les nombres et les tuples de valeurs hachables fonctionnent ; les listes non). Les valeurs peuvent être n'importe quel objet Python.

person = {"name": "Alice", "age": 28, "city": "Berlin"}

Les dictionnaires maintiennent l'ordre d'insertion depuis Python 3.7 — les itérer renvoie toujours les clés dans l'ordre où elles ont été ajoutées.

Les méthodes des dictionnaires en un coup d'œil

clear()

clear() supprime tous les éléments du dictionnaire en place, laissant un dict vide. Utilisez-le lorsque vous devez réutiliser le même objet dict plutôt que d'en créer un nouveau.

Piège : inventory = {} semble similaire mais crée un nouvel objet dict. Si une autre variable pointe vers le même dict, clear() le vide pour les deux ; la réaffectation ne le fait pas.

a = {"x": 1}
b = a
a.clear()
print(b)   # Output: {}  — b sees the change

a = {"x": 1}
b = a
a = {}
print(b)   # Output: {'x': 1}  — b is unaffected

copy()

copy() retourne une copie superficielle — un nouveau dict avec les mêmes clés et des références aux mêmes valeurs.

Piège : Si une valeur est un objet mutable (liste, dict, ensemble), l'original et la copie partagent cet objet. Utilisez copy.deepcopy() lorsque vous avez besoin d'une indépendance totale.

Pour plus de détails sur la copie sécurisée des dicts, consultez Copier les dictionnaires.

fromkeys()

fromkeys(iterable, value) est une méthode de classe qui construit un nouveau dict à partir d'une séquence de clés, toutes associées à la même valeur (par défaut None).

fields = ["name", "email", "phone"]
record = dict.fromkeys(fields, "")
print(record)
# Output: {'name': '', 'email': '', 'phone': ''}

Piège : Si la valeur par défaut est mutable (par exemple, une liste), toutes les clés partagent le même objet :

bad = dict.fromkeys(["a", "b"], [])
bad["a"].append(1)
print(bad)  # Output: {'a': [1], 'b': [1]}  — both share the list!

La solution consiste à utiliser une compréhension de dict à la place :

good = {k: [] for k in ["a", "b"]}
good["a"].append(1)
print(good)  # Output: {'a': [1], 'b': []}

get()

get(key, default=None) retourne la valeur associée à key si elle existe, ou default sinon. Elle ne lève jamais KeyError.

Quand l'utiliser : préférez get() à dict[key] chaque fois que la clé peut être absente. Utilisez la forme à deux arguments pour fournir une valeur par défaut significative plutôt que d'intercepter KeyError dans un bloc try/except.

items()

items() retourne une vue dict_items — un itérable de tuples (key, value) qui reflète l'état actuel du dict.

L'utilisation la plus courante est de décompacter la clé et la valeur dans une boucle for :

scores = {"math": 90, "english": 85, "science": 92}
for subject, grade in scores.items():
    print(f"{subject}: {grade}")
# Output:
# math: 90
# english: 85
# science: 92

Les vues sont dynamiques — elles reflètent les modifications apportées au dict sans avoir besoin d'être régénérées.

Pour plus de modèles de boucles, consultez Itérer les dictionnaires.

keys()

keys() retourne une vue dict_keys de toutes les clés dans l'ordre d'insertion.

Comme il s'agit d'une vue, vous pouvez l'utiliser dans des opérations d'ensemble pour comparer deux dicts :

a = {"x": 1, "y": 2}
b = {"y": 3, "z": 4}

print(a.keys() & b.keys())  # Output: {'y'}    — keys in both
print(a.keys() | b.keys())  # Output: {'x', 'y', 'z'}  — all keys
print(a.keys() - b.keys())  # Output: {'x'}    — keys only in a

values()

values() retourne une vue dict_values de toutes les valeurs.

Cas d'utilisation courants :

prices = {"apple": 0.99, "banana": 0.59, "cherry": 2.49}

total = sum(prices.values())
print(f"Total: {total:.2f}")   # Output: Total: 4.07

most_expensive = max(prices.values())
print(most_expensive)          # Output: 2.49

Contrairement à keys(), values() ne prend pas en charge les opérations d'ensemble car les valeurs ne sont pas garanties d'être uniques.

pop()

pop(key, default) supprime l'élément avec la clé donnée et retourne sa valeur. Si la clé est absente et qu'aucune valeur par défaut n'est fournie, elle lève KeyError.

Quand l'utiliser : pop() est l'outil approprié lorsque vous devez à la fois supprimer un élément et utiliser sa valeur dans la même opération, comme lors du traitement d'éléments d'un dict fonctionnant comme une file d'attente.

popitem()

popitem() supprime et retourne la dernière paire clé-valeur insérée sous forme de tuple (key, value). L'appeler sur un dict vide lève KeyError.

data = {"a": 1, "b": 2, "c": 3}

last = data.popitem()
print(last)   # Output: ('c', 3)
print(data)   # Output: {'a': 1, 'b': 2}

Un modèle pratique consiste à traiter un dict de manière destructive jusqu'à ce qu'il soit vide :

tasks = {"write tests": True, "review PR": False, "deploy": True}
while tasks:
    name, done = tasks.popitem()
    status = "done" if done else "pending"
    print(f"{name}: {status}")

setdefault()

setdefault(key, default=None) retourne la valeur associée à key si elle existe. Si key est absente, elle l'insère avec default et retourne default.

options = {"color": "blue"}

# Key exists — returns existing value, does NOT overwrite
print(options.setdefault("color", "red"))   # Output: blue

# Key absent — inserts and returns default
print(options.setdefault("size", "medium")) # Output: medium

print(options)
# Output: {'color': 'blue', 'size': 'medium'}

Cas d'utilisation principal : construire des dictionnaires de listes (regroupement) :

words = ["apple", "avocado", "banana", "blueberry", "cherry"]
grouped = {}
for word in words:
    grouped.setdefault(word[0], []).append(word)

print(grouped)
# Output: {'a': ['apple', 'avocado'], 'b': ['banana', 'blueberry'], 'c': ['cherry']}

C'est plus propre qu'une vérification if key not in d: d[key] = [] à chaque itération.

update()

update(other) fusionne other dans le dictionnaire en écrasant les clés existantes. other peut être un autre dict, un itérable de paires (key, value), ou des arguments nommés.

Alternative Python 3.9+ : l'opérateur de fusion en place |= fait la même chose de manière plus concise :

profile = {"name": "Alice", "age": 28}
profile |= {"age": 29, "city": "Berlin"}
print(profile)
# Output: {'name': 'Alice', 'age': 29, 'city': 'Berlin'}

L'opérateur | (sans =) retourne un nouveau dict au lieu de modifier en place.

Accéder aux éléments et les modifier

Au-delà des méthodes ci-dessus, Python fournit une syntaxe directe pour lire, ajouter et supprimer des entrées de dictionnaire.

Lire une valeur par clé :

Accéder à une clé qui n'existe pas lève KeyError. Utilisez get() pour éviter cela.

Ajouter ou écraser une valeur :

person = {"name": "Alice", "age": 28}
person["occupation"] = "Engineer"  # new key
person["age"] = 29                 # overwrite existing key
print(person)
# Output: {'name': 'Alice', 'age': 29, 'occupation': 'Engineer'}

Itérer sur les clés et les valeurs :

Choisir la bonne méthode

Chapitres associés

• Dictionnaires Python — fondamentaux : création, accès et test d'appartenance
• Dictionnaires imbriqués — dicts de dicts pour les données hiérarchiques
• Itérer les dictionnaires — tous les modèles de boucles avec keys(), values() et items()
• Copier les dictionnaires — copie superficielle vs. profonde en détail
• Méthodes des listes — la référence équivalente pour les listes Python

Pratique