Ajouter des éléments à un dictionnaire Python

Les dictionnaires Python sont des collections mutables et ordonnées (depuis Python 3.7) de paires clé-valeur. Étant mutables, vous pouvez y ajouter de nouvelles entrées à tout moment après leur création. Ce chapitre couvre toutes les techniques standard pour ajouter des éléments à un dictionnaire, y compris les opérateurs de fusion de Python 3.9+, avec des conseils pratiques sur le moment opportun d'utiliser chaque approche.

Qu'est-ce qu'un dictionnaire Python ?

Un dictionnaire stocke des données sous forme de paires clé-valeur entre accolades {}. Les clés doivent être uniques et immuables (chaînes de caractères, nombres ou tuples) ; les valeurs peuvent être n'importe quel objet Python.

# A simple dictionary
person = {'name': 'Alice', 'age': 30, 'city': 'New York'}

Les clés sont uniques — si vous assignez une valeur à une clé qui existe déjà, l'ancienne valeur est écrasée, pas dupliquée. Gardez ce comportement à l'esprit lorsque vous parcourez les méthodes ci-dessous.

Façons d'ajouter des éléments à un dictionnaire

Utiliser la notation par crochets

La façon la plus simple d'ajouter une nouvelle paire clé-valeur est l'assignation directe avec des crochets :

Résultat :

{'name': 'John', 'age': 25, 'city': 'New York', 'gender': 'Male'}

Si la clé existe déjà, la valeur est remplacée plutôt qu'ajoutée :

my_dict = {'name': 'John', 'age': 25}

my_dict['age'] = 30  # overwrites 25

print(my_dict)
# {'name': 'John', 'age': 30}

Utilisez l'assignation par crochets lorsque vous ajoutez ou mettez à jour une seule clé dont vous connaissez le nom au moment de l'écriture.

Utiliser la méthode update()

dict.update() fusionne une ou plusieurs paires clé-valeur dans le dictionnaire en un seul appel. Vous pouvez passer un autre dictionnaire, un itérable de paires (key, value), ou des arguments nommés.

Fusionner un second dictionnaire :

Résultat :

{'name': 'John', 'age': 25, 'city': 'New York', 'gender': 'Male', 'occupation': 'Software Engineer'}

Utiliser des arguments nommés pour ajouter plusieurs clés à la fois :

my_dict = {'name': 'John', 'age': 25}

my_dict.update(city='New York', gender='Male')

print(my_dict)
# {'name': 'John', 'age': 25, 'city': 'New York', 'gender': 'Male'}

Comme l'assignation par crochets, update() écrase les clés existantes. Utilisez-la lorsque vous devez ajouter ou actualiser plusieurs entrées à la fois.

Utiliser la méthode setdefault()

dict.setdefault(key, default) ajoute une clé uniquement si elle n'est pas déjà présente. Si la clé existe, elle retourne la valeur existante sans rien modifier.

Résultat :

{'name': 'John', 'age': 25, 'city': 'New York', 'gender': 'Male'}

Lorsque la clé existe déjà, setdefault() la laisse intacte et retourne la valeur actuelle :

my_dict = {'name': 'John', 'age': 25}

result = my_dict.setdefault('name', 'Alice')

print(result)   # John  — not overwritten
print(my_dict)  # {'name': 'John', 'age': 25}

setdefault() est l'outil idéal lorsque vous souhaitez initialiser une clé avec une valeur par défaut sans écraser accidentellement des données déjà présentes. Un schéma courant consiste à initialiser une clé manquante avec une liste vide avant d'y ajouter des éléments :

groups = {}

for item in ['apple', 'banana', 'avocado']:
    letter = item[0]
    groups.setdefault(letter, []).append(item)

print(groups)
# {'a': ['apple', 'avocado'], 'b': ['banana']}

Utiliser les opérateurs de fusion (Python 3.9+)

Python 3.9 a introduit deux opérateurs offrant une syntaxe concise pour combiner des dictionnaires.

| — créer un nouveau dictionnaire fusionné (non destructif) :

d1 = {'a': 1, 'b': 2}
d2 = {'c': 3, 'd': 4}

d3 = d1 | d2  # d1 and d2 are unchanged

print(d3)
# {'a': 1, 'b': 2, 'c': 3, 'd': 4}

|= — mettre à jour en place (équivalent à update() mais plus court) :

d1 = {'a': 1, 'b': 2}
d2 = {'c': 3, 'd': 4}

d1 |= d2  # d1 is modified

print(d1)
# {'a': 1, 'b': 2, 'c': 3, 'd': 4}

En cas de chevauchement de clés, l'opérande de droite l'emporte — même priorité que update(). Ces opérateurs nécessitent Python 3.9 ou une version ultérieure ; utilisez update() pour une compatibilité plus large.

Utiliser dict.fromkeys() pour pré-remplir un dictionnaire

dict.fromkeys(keys, default) est une méthode de classe qui crée un tout nouveau dictionnaire à partir d'un itérable de clés et d'une valeur par défaut optionnelle. Elle n'ajoute pas d'éléments à un dictionnaire existant.

# Create a dictionary with a shared default value
template = dict.fromkeys(['name', 'age', 'city'], 'Unknown')

print(template)
# {'name': 'Unknown', 'age': 'Unknown', 'city': 'Unknown'}

# You can then populate it with real values
template['name'] = 'Alice'
template['age'] = 28

print(template)
# {'name': 'Alice', 'age': 28, 'city': 'Unknown'}

fromkeys() est utile pour créer l'ossature d'un dictionnaire lorsque vous connaissez les clés à l'avance mais que vous remplirez les valeurs plus tard.

Choisir la bonne méthode

Chapitres associés

• Dictionnaires Python — aperçu de la création et de la syntaxe des dictionnaires
• Accéder aux éléments — lecture des valeurs par clé, get() et itération
• Modifier des éléments — mise à jour sécurisée des valeurs existantes
• Supprimer des éléments — pop(), popitem(), del et clear()
• Méthodes de dictionnaire — référence complète de toutes les méthodes dict intégrées
• Parcourir les dictionnaires — itération sur les clés, les valeurs et les éléments

Pratique