Dictionnaires Python

Un dictionnaire Python est une collection mutable et ordonnée de paires clé-valeur. Contrairement aux listes ou aux tuples (qui utilisent des positions entières), un dictionnaire vous permet d'associer une clé significative à chaque valeur — ce qui accélère les recherches et rend le code plus lisible. Les dictionnaires sont l'un des types intégrés les plus utilisés de Python et constituent l'épine dorsale du traitement JSON, de la gestion de configuration, du comptage de mots, et bien plus encore.

Ce chapitre couvre tout ce que vous devez savoir pour utiliser les dictionnaires avec assurance : création, accès, modification, suppression, itération, compréhensions et pièges courants.

Chapitres connexes : Méthodes de dictionnaire | Dictionnaires imbriqués | Boucles sur les dictionnaires | Copier les dictionnaires | Compréhensions Python

Qu'est-ce qu'un dictionnaire ?

Un dictionnaire associe des clés uniques et hachables à des valeurs de n'importe quel type. La règle fondamentale : les clés doivent être immuables — les chaînes de caractères, les nombres et les tuples d'immuables sont tous acceptés ; les listes et les autres dictionnaires ne le sont pas.

# string keys → integer values
inventory = {'apple': 10, 'banana': 5, 'orange': 8}

# mixed value types are fine
person = {'name': 'Alice', 'age': 30, 'active': True}

# tuple keys work because tuples are immutable
grid = {(0, 0): 'origin', (1, 0): 'east', (0, 1): 'north'}

Depuis Python 3.7, les dictionnaires conservent l'ordre d'insertion — itérer sur un dictionnaire retourne toujours les clés dans l'ordre où elles ont été ajoutées.

Créer un dictionnaire

Littéral avec accolades

La méthode la plus courante : séparez les paires clé-valeur par des virgules, utilisez un deux-points entre chaque clé et sa valeur, et entourez le tout de {}.

config = {'host': 'localhost', 'port': 5432, 'debug': True}
print(config)
# {'host': 'localhost', 'port': 5432, 'debug': True}

Un dictionnaire vide s'écrit simplement {}.

empty = {}
print(type(empty))  # <class 'dict'>

Constructeur dict()

Passez des arguments nommés à dict() lorsque vos clés sont des identifiants Python valides :

config = dict(host='localhost', port=5432, debug=True)
print(config)
# {'host': 'localhost', 'port': 5432, 'debug': True}

Vous pouvez également passer un itérable de séquences à deux éléments :

pairs = [('x', 10), ('y', 20)]
point = dict(pairs)
print(point)  # {'x': 10, 'y': 20}

dict.fromkeys()

Créez un dictionnaire à partir d'une liste de clés, toutes partageant la même valeur initiale :

defaults = dict.fromkeys(['timeout', 'retries', 'verbose'], 0)
print(defaults)
# {'timeout': 0, 'retries': 0, 'verbose': 0}

Piège : si la valeur par défaut est un objet mutable (comme une liste), toutes les clés partageront le même objet. Utilisez plutôt une compréhension de dictionnaire (présentée ci-dessous).

Compréhension de dictionnaire

Une manière concise de construire un dictionnaire à partir de n'importe quel itérable :

squares = {x: x ** 2 for x in range(1, 6)}
print(squares)
# {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

Consultez Compréhensions Python pour la syntaxe complète.

Accéder aux valeurs

Accès par crochets

inventory = {'apple': 10, 'banana': 5, 'orange': 8}
print(inventory['apple'])   # 10

Si la clé n'existe pas, Python lève une KeyError :

try:
    print(inventory['grape'])
except KeyError as e:
    print(f'KeyError: {e}')   # KeyError: 'grape'

get() — accès sécurisé avec valeur par défaut

dict.get(key, default) retourne la valeur si la clé existe, ou default (qui est None si omis) dans le cas contraire — sans lever d'exception.

print(inventory.get('grape'))       # None
print(inventory.get('grape', 0))    # 0
print(inventory.get('apple', 0))    # 10

Utilisez .get() chaque fois que vous n'êtes pas certain qu'une clé existe. Utilisez l'accès par crochets quand la clé doit être présente — une clé manquante sera alors un vrai bogue qui doit se manifester comme une erreur.

Vérifier l'existence d'une clé

print('apple' in inventory)    # True
print('grape' in inventory)    # False
print('grape' not in inventory) # True

in teste les clés, pas les valeurs. Il s'exécute en temps O(1) en moyenne — constant, quelle que soit la taille du dictionnaire.

Ajouter et mettre à jour des éléments

Ajouter une nouvelle paire clé-valeur

Assignez à une clé qui n'existe pas encore :

inventory['grape'] = 12
print(inventory)
# {'apple': 10, 'banana': 5, 'orange': 8, 'grape': 12}

Mettre à jour une valeur existante

Assignez à une clé qui existe déjà — l'ancienne valeur est remplacée :

inventory['apple'] = 15
print(inventory['apple'])  # 15

update() — ajout ou écrasement en masse

Passez un autre dictionnaire ou un itérable de paires clé-valeur :

inventory.update({'banana': 7, 'mango': 3})
print(inventory)
# {'apple': 15, 'banana': 7, 'orange': 8, 'grape': 12, 'mango': 3}

Fusionner avec | (Python 3.9+)

L'opérateur | crée un nouveau dictionnaire fusionné. Si une clé apparaît dans les deux, c'est la valeur du côté droit qui l'emporte :

a = {'x': 1, 'y': 2}
b = {'y': 99, 'z': 3}
merged = a | b
print(merged)   # {'x': 1, 'y': 99, 'z': 3}

Utilisez |= pour fusionner b dans a sur place — équivalent à a.update(b) mais plus lisible.

setdefault() — insertion uniquement si absent

dict.setdefault(key, default) insère la clé avec la valeur par défaut si elle est absente, puis retourne toujours la valeur associée à cette clé. C'est plus efficace que le pattern if key not in d: d[key] = default.

scores = {'Alice': 95}
scores.setdefault('Bob', 0)     # Bob absent → inserts 0, returns 0
scores.setdefault('Alice', 0)   # Alice present → does nothing, returns 95
print(scores)   # {'Alice': 95, 'Bob': 0}

Un cas d'utilisation classique est le regroupement d'éléments :

words = ['cat', 'car', 'bus', 'can', 'bat']
groups = {}
for word in words:
    groups.setdefault(word[0], []).append(word)
print(groups)
# {'c': ['cat', 'car', 'can'], 'b': ['bus', 'bat']}

Supprimer des éléments

del — suppression par clé

inventory = {'apple': 15, 'banana': 7, 'orange': 8, 'grape': 12}
del inventory['orange']
print(inventory)
# {'apple': 15, 'banana': 7, 'grape': 12}

del lève une KeyError si la clé est absente. Pour éviter cela, vérifiez d'abord avec in, ou utilisez pop() avec une valeur par défaut.

pop() — supprimer et retourner la valeur

removed = inventory.pop('grape')
print(removed)      # 12
print(inventory)    # {'apple': 15, 'banana': 7}

Fournissez un second argument pour éviter une KeyError si la clé peut être absente :

val = inventory.pop('pear', 'not found')
print(val)   # not found

popitem() — supprimer le dernier élément inséré (Python 3.7+)

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

clear() — tout supprimer

d = {'a': 1, 'b': 2}
d.clear()
print(d)   # {}

Itérer sur un dictionnaire

Trois vues permettent d'itérer sur différentes parties d'un dictionnaire. Les trois sont des vues dynamiques — elles reflètent les modifications apportées au dictionnaire sans avoir besoin d'être recréées.

Clés (itération par défaut)

Itérer directement sur un dictionnaire retourne ses clés :

person = {'name': 'Alice', 'age': 30, 'city': 'Paris'}

for key in person:
    print(key)
# name
# age
# city

person.keys() retourne les mêmes clés sous la forme d'un objet vue dict_keys explicite.

Valeurs

for val in person.values():
    print(val)
# Alice
# 30
# Paris

Paires clé-valeur

for key, val in person.items():
    print(f'{key}: {val}')
# name: Alice
# age: 30
# city: Paris

.items() est le choix le plus courant lorsque vous avez besoin à la fois de la clé et de la valeur dans la boucle. Consultez Boucles sur les dictionnaires pour des schémas avancés.

Les vues sont dynamiques

d = {'a': 1}
keys_view = d.keys()
d['b'] = 2
print(keys_view)   # dict_keys(['a', 'b'])  ← reflects the new key

Compréhensions de dictionnaire

Les compréhensions de dictionnaire vous permettent de construire ou de transformer des dictionnaires en une seule expression lisible.

Filtrer par valeur

inventory = {'apple': 15, 'banana': 7, 'orange': 8, 'grape': 12, 'mango': 3}
popular = {k: v for k, v in inventory.items() if v >= 8}
print(popular)
# {'apple': 15, 'orange': 8, 'grape': 12}

Inverser un dictionnaire (échanger clés et valeurs)

original = {'a': 1, 'b': 2, 'c': 3}
swapped = {v: k for k, v in original.items()}
print(swapped)   # {1: 'a', 2: 'b', 3: 'c'}

Ceci ne fonctionne correctement que lorsque toutes les valeurs sont uniques.

Compteur de fréquence de mots

sentence = 'the quick brown fox jumps over the lazy dog'
freq = {}
for word in sentence.split():
    freq[word] = freq.get(word, 0) + 1
print(freq)
# {'the': 2, 'quick': 1, 'brown': 1, 'fox': 1, ...}

Fonctions intégrées utiles

Pour une référence complète de chaque méthode de dictionnaire (copy, fromkeys, update, setdefault, popitem, et plus encore), consultez Méthodes de dictionnaire Python.

Pièges courants

1. KeyError sur une clé manquante — utilisez toujours .get() ou in quand une clé peut ne pas exister.

2. Types de clés non hachables — les listes ne peuvent pas être des clés de dictionnaire car elles sont mutables. Utilisez un tuple à la place :

# This raises TypeError: unhashable type: 'list'
# bad = {[1, 2]: 'value'}

# Use a tuple:
coords = {(1, 2): 'A', (3, 4): 'B'}
print(coords[(1, 2)])  # A

3. Mutation pendant l'itération — ajouter ou supprimer des clés pendant l'itération sur un dictionnaire lève une RuntimeError. Faites d'abord une copie instantanée :

d = {'a': 1, 'b': 2, 'c': 3}
for key in list(d):          # list() copies the keys
    if d[key] < 2:
        del d[key]
print(d)   # {'b': 2, 'c': 3}

4. Copie superficielle vs. copie profonde — dict.copy() et {**d} effectuent tous deux une copie superficielle. Les valeurs mutables imbriquées (listes, dicts) sont toujours partagées. Utilisez copy.deepcopy() lorsque vous avez besoin de copies totalement indépendantes. Consultez Copier les dictionnaires.

Dictionnaires vs. autres types de collections

Lorsque vous devez rechercher quelque chose par un libellé significatif plutôt que par une position, un dictionnaire est presque toujours le bon choix. Pour des valeurs uniques ordonnées, envisagez un set. Pour une séquence ordonnée simple, utilisez une list.

Pratique