Si une liste est une rangée de cases numérotées, un dictionnaire Python est un ensemble de cases étiquetées. Vous demandez ce que vous voulez par nom plutôt que par position, c’est pourquoi les dictionnaires se trouvent derrière les données JSON, la configuration, les caches et une grande partie de Python lui-même.

Ce didacticiel commence par les bases et passe aux modèles que les développeurs expérimentés utilisent quotidiennement. Nous avons exécuté tous les exemples sur Python 3.13 et le résultat affiché provient de cette exécution.

Qu’est-ce qu’un dictionnaire ?

Un dictionnaire, ou dict, mappe clés à valeurs. Chaque clé n’apparaît qu’une seule fois et les valeurs peuvent être n’importe quoi, y compris des listes ou d’autres dictionnaires.

Depuis Python 3.7, les dictionnaires conservent officiellement l’ordre d’insertion. De nombreux tutoriels plus anciens les qualifient encore de non ordonnés, ce qui n’est plus vrai. Pour une comparaison plus large des autres types, voir Liste Python vs tuple vs set.

Les recherches sont rapides car les dictionnaires utilisent une table de hachage. La vérification d’une clé prend à peu près le même temps, que le dictionnaire contienne dix éléments ou un million, tandis que la recherche dans une liste devient plus lente à mesure qu’elle s’allonge.

Créer un dictionnaire

user = {"name": "Asha", "age": 31, "city": "Pune"}

empty = {}
from_keywords = dict(name="Asha", age=31)
from_pairs = dict([("a", 1), ("b", 2)])

Les accolades sont la forme la plus courante. Un piège : {} crée un dictionnaire vide, pas un ensemble vide. Pour un ensemble vide, vous avez besoin de set().

Lire les valeurs en toute sécurité

Il existe deux manières de lire une valeur, et la différence est importante lorsqu’une clé n’existe pas :

user["name"]                  # 'Asha'
user["email"]                 # KeyError: 'email'

user.get("email")             # None
user.get("email", "not set")  # 'not set'

Utilisez des crochets lorsque la clé doit exister, afin qu’une clé manquante échoue bruyamment. Utilisez get() lorsque l’absence est normale, comme un champ facultatif dans une réponse API. Pour rechercher une clé, utilisez l’opérateur in, qui examine les clés plutôt que les valeurs :

"city" in user    # True
"Pune" in user    # False

Ajouter, mettre à jour et supprimer

L’attribution à une clé la met à jour si elle existe, ou l’ajoute si elle n’existe pas :

user["age"] = 32
user["email"] = "asha@example.com"
print(user)

# {'name': 'Asha', 'age': 32, 'city': 'Pune', 'email': 'asha@example.com'}

Python propose plusieurs façons de supprimer des éléments :

user.pop("city")          # returns 'Pune' and removes it
user.pop("phone", None)   # no error if it is missing
del user["email"]         # removes it, and raises KeyError if missing
user.clear()              # empties the dictionary

Utilisez pop() lorsque vous souhaitez récupérer la valeur. Passer une valeur par défaut comme deuxième argument évite une erreur lorsque la clé n’est pas là. popitem() supprime et renvoie la paire la plus récemment ajoutée.

Boucler sur un dictionnaire

Le bouclage vous donne directement les clés. Pour obtenir à la fois les clés et les valeurs, utilisez items() :

user = {"name": "Asha", "age": 32}

for key, value in user.items():
    print(key, "=", value)

# name = Asha
# age = 32

keys(), values() et items() renvoient des vues en direct plutôt que des copies, elles reflètent donc les modifications ultérieures. N’ajoutez ou ne supprimez pas de clés lors d’une boucle sur un dictionnaire, car Python génère un RuntimeError. Faites une boucle sur list(user) si vous avez besoin de le faire.

Aide-mémoire sur les méthodes de dictionnaire

Fusionner les dictionnaires

Un besoin courant consiste à appliquer les paramètres utilisateur en plus des valeurs par défaut. Lorsque les touches s’entrechoquent, le côté droit gagne :

defaults = {"theme": "light", "lang": "en"}
saved = {"theme": "dark"}

defaults | saved
{**defaults, **saved}

# Both give: {'theme': 'dark', 'lang': 'en'}

L’opérateur | nécessite Python 3.9 ou version ultérieure, tandis que la version ** fonctionne également sur les anciennes versions. Les deux créent un nouveau dictionnaire. En revanche, defaults.update(saved) et defaults |= saved modifient defaults en place.

Compréhensions et tri

Les compréhensions de dictionnaire construisent un nouveau dictionnaire sur une seule ligne lisible, tout comme les compréhensions de liste le font pour les listes :

prices = {"pen": 10, "book": 250, "bag": 900}

{k: v for k, v in prices.items() if v > 100}
# {'book': 250, 'bag': 900}

Pour trier par valeur, passez une fonction key à sorted(). Pour trouver la clé avec la plus grande valeur, utilisez max() :

sorted(prices.items(), key=lambda item: item[1], reverse=True)
# [('bag', 900), ('book', 250), ('pen', 10)]

max(prices, key=prices.get)
# 'bag'

Un dictionnaire n’a pas de méthode sort() et sorted() renvoie une liste de paires. Enveloppez le résultat dans dict() si vous voulez un dictionnaire dans cet ordre.

Modèles de comptage et de regroupement

Deux tâches reviennent constamment. La première consiste à compter, ce que vous pouvez faire en utilisant get() avec une valeur par défaut de zéro :

words = "to be or not to be".split()

counts = {}
for word in words:
    counts[word] = counts.get(word, 0) + 1

print(counts)
# {'to': 2, 'be': 2, 'or': 1, 'not': 1}

La bibliothèque standard rend cela encore plus court avec Counter :

from collections import Counter

Counter(words).most_common(2)
# [('to', 2), ('be', 2)]

La seconde est le regroupement, et defaultdict est idéal ici car il crée la valeur manquante pour vous :

from collections import defaultdict

orders = [("Asha", 1200), ("Ben", 300), ("Asha", 800)]

by_customer = defaultdict(list)
for name, total in orders:
    by_customer[name].append(total)

print(dict(by_customer))
# {'Asha': [1200, 800], 'Ben': [300]}

Sans cela, vous devrez vérifier si chaque clé existe avant de l’ajouter. Ces mêmes modèles fonctionnent bien pour agréger des données API ou des lignes de journal. Lorsqu’un dictionnaire est vide ou qu’une clé est manquante, notre guide sur la gestion des exceptions Python montre comment gérer le KeyError résultant.

Données imbriquées et piège à copie

JSON correspond directement aux dictionnaires et aux listes imbriqués, vous enchaînerez donc souvent les clés. Le chaînage get() assure cette sécurité lorsqu’un niveau peut manquer :

response = {"user": {"profile": {"city": "Pune"}}}

response["user"]["profile"]["city"]               # 'Pune'
response.get("user", {}).get("settings", {}).get("theme")   # None

Soyez prudent lorsque vous copiez des données imbriquées. copy() duplique uniquement le niveau supérieur, donc les dictionnaires internes restent partagés avec l’original :

settings = {"db": {"host": "localhost"}}

shallow = settings.copy()
shallow["db"]["host"] = "prod"

print(settings["db"]["host"])
# prod

Changer la copie a modifié l’original, ce qui peut être un vilain bug. Utilisez copy.deepcopy(settings) pour obtenir une copie totalement indépendante.

Que peut être une clé de dictionnaire ?

Les clés doivent être hachables, ce qui signifie généralement immuables. Les chaînes, les nombres et les tuples de valeurs immuables fonctionnent tous. Les listes et les dictionnaires ne :

{["a"]: 1}

# TypeError: unhashable type: 'list'

La raison en est que le hachage d’une clé décide où sa valeur est stockée. Si une clé pouvait changer, Python ne pourrait plus la trouver. Si vous avez besoin d’une clé composée, utilisez un tuple, tel que {("Pune", 2026): 120}.

Erreurs courantes

• Utilisation de crochets sur les clés facultatives. Recherchez get() lorsqu’une clé peut être absente.
• En supposant que get() signifie que la clé existe. None pourrait signifier manquante ou stockée None. Utilisez in lorsque la différence compte.
• Utilisation d’une valeur par défaut mutable. dict.fromkeys(names, []) donne à chaque clé la même liste. Utilisez plutôt une compréhension.
• Changement de taille pendant l’itération. Boucle sur une copie des clés.
• Utilisation d’un dict pour les champs fixes et connus. Un dataclass peut être plus clair et détecte les fautes de frappe dans les noms de champs.

Pour conclure

Les dictionnaires récompensent un peu de pratique. N’oubliez pas get() pour les touches facultatives, items() pour les boucles et Counter et defaultdict pour les deux tâches les plus courantes. Pour vous entraîner, prenez un petit fichier JSON et écrivez du code pour compter et regrouper ses enregistrements. Si vous êtes nouveau dans le langage, commencez par notre Tutoriel Python pour débutants.

Questions fréquentes

Continuez à apprendre