Accéder au contenu principal

Appendice du dictionnaire Python : Comment ajouter des paires clé-valeur

Apprenez à ajouter des paires clé-valeur dans un dictionnaire Python à l'aide de méthodes telles que la notation par crochets, .update() pour les ajouts en masse et .setdefault() pour les insertions conditionnelles.
Actualisé 16 janv. 2025  · 8 min de lecture

Dans la programmation Python, les dictionnaires sont incroyablement polyvalents, vous permettant de stocker des données dans des paires clé-valeur pour une gestion et un accès efficaces. Si vous débutez avec Python, il est important de comprendre comment manipuler ces dictionnaires, car cela améliorera grandement la façon dont vous manipulez les données dans diverses applications. Que vous configuriez des paramètres, gériez des ensembles de données complexes ou stockiez simplement des données pour les consulter rapidement, les dictionnaires sont votre solution.

L'une des principales opérations que vous devrez souvent effectuer consiste à ajouter des éléments à un dictionnaire. Cet article vous guidera à travers différentes méthodes pour ajouter des éléments à un dictionnaire en Python, de la notation de base entre crochets à des techniques plus avancées comme l'utilisation de la méthode update() et de l'opérateur de fusion. 

Si vous ne connaissez pas encore le concept des dictionnaires en Python, pensez à lire également notre tutoriel sur les dictionnaires en Python, ou notre tutoriel sur la compréhension des dictionnaires en Python, qui sont d'excellentes ressources pour se familiariser avec les paires clé-valeur et d'autres idées fondamentales pour les dictionnaires. Par ailleurs, notre aide-mémoire sur les débuts avec Python peut vous servir de référence rapide si vous avez besoin de rafraîchir vos connaissances sur la syntaxe et les fonctions de Python.

Réponse rapide : Comment ajouter à un dictionnaire en Python

Si vous cherchez une solution rapide pour ajouter des éléments à un dictionnaire Python, la méthode update() est l'une des plus courantes et des plus conviviales :

# Initial dictionary with information for one person
people_info = {
    'person_1': {
        'name': 'Alice',
        'city': 'New York'
    }
}

# Updating Alice's information and adding another person
people_info.update({
    'person_1': {
        'name': 'Alice',
        'city': 'Los Angeles',  # Updated city
        'age': 30               # Added new detail
    },
    'person_2': {
        'name': 'Bob',
        'city': 'San Francisco'
    }
})

print(people_info)
{
    'person_1': {'name': 'Alice', 'city': 'Los Angeles', 'age': 30},
    'person_2': {'name': 'Bob', 'city': 'San Francisco'}
}

Dans cet exemple, la méthode update() met à jour les informations d'Alice sous la clé 'person_1', en remplaçant city par 'Los Angeles' et en ajoutant un nouveau détail age: 30. Il ajoute également une nouvelle personne, Bob, sous la clé 'person_2'.

Comprendre les dictionnaires Python

Pour commencer, nous pouvons discuter des dictionnaires Python et de la raison pour laquelle ils sont si importants en programmation.

Qu'est-ce qu'un dictionnaire Python ?

En Python, un dictionnaire est une collection de paires clé-valeur. Chaque clé d'un dictionnaire est unique et correspond à une valeur, qui peut être de n'importe quel type (chaînes de caractères, nombres entiers, listes ou même d'autres dictionnaires). Cette structure permet d'extraire, d'ajouter et de modifier des données. Voici un exemple simple de dictionnaire Python :

# Example of a dictionary
person = {
    'name': 'Alice',
    'age': 25,
    'city': 'New York'
}

# Accessing a value
print(person['name'])  # Output: Alice

Dans cet exemple, 'name', 'age', et 'city' sont des clés, et 'Alice', 25, et 'New York' sont les valeurs correspondantes.

Structure d'un dictionnaire Python

Les dictionnaires sont des collections non ordonnées, ce qui signifie que les éléments n'ont pas d'ordre défini. Cependant, à partir de Python 3.7, les dictionnaires conservent l'ordre d'insertion, ce qui peut être utile dans diverses applications. Voici un exemple plus détaillé pour illustrer la structure :

# A more complex dictionary
employee = {
    'id': 101,
    'name': 'John Doe',
    'age': 30,
    'department': 'Engineering',
    'skills': ['Python', 'Machine Learning', 'Data Analysis'],
    'address': {
        'street': '123 Main St',
        'city': 'San Francisco',
        'state': 'CA',
        'zip': '94105'
    }
}

# Accessing nested data
print(employee['skills'][1])  # Output: Machine Learning
print(employee['address']['city'])  # Output: San Francisco

Dans cet exemple, le dictionnaire desemployés contient différents types de données, dont une liste ('skills' ) et un autre dictionnaire ('address'). Cela montre comment les dictionnaires peuvent être utilisés pour stocker et organiser des structures de données complexes.

Maintenant que nous avons couvert les bases, explorons plus en détail les différentes méthodes permettant d'ajouter des éléments à un dictionnaire.

Méthodes pour ajouter des éléments à un dictionnaire en Python

L'ajout d'éléments à un dictionnaire est une tâche courante en Python, et il existe plusieurs méthodes pour y parvenir, chacune ayant ses propres cas d'utilisation et avantages. Passons-les en revue un par un.

Utilisation de la notation entre crochets

La façon la plus simple d'ajouter une paire clé-valeur à un dictionnaire est d'utiliser la notation entre crochets. Cette méthode est simple et efficace pour ajouter des éléments individuels. Voici la s yntaxe :

dictionary[key] = value

Voici un exemple utilisant la notation entre crochets :

# Initialize a dictionary
my_dict = {'name': 'Alice', 'age': 25}

# Add a new key-value pair
my_dict['city'] = 'New York'

# Print the updated dictionary
print(my_dict)
# Output: {'name': 'Alice', 'age': 25, 'city': 'New York'}

Cette méthode ajoute ou met à jour directement la paire clé-valeur dans le dictionnaire. Si la clé existe déjà, sa valeur sera mise à jour.

Lorsque vous utilisez la notation entre crochets pour ajouter une clé qui existe déjà dans le dictionnaire, la valeur associée à cette clé est mise à jour. Cela peut être à la fois un avantage et un inconvénient, en fonction de vos besoins. Voici un exemple qui montre comment traiter les clés existantes :

# Update an existing key-value pair
my_dict['age'] = 30

# Print the updated dictionary
print(my_dict)
# Output: {'name': 'Alice', 'age': 30, 'city': 'New York'}

Dans cet exemple, la valeur de la clé 'age' est mise à jour de 25 à 30.

Utilisation de la méthode .update()

La méthode.update() vous permet d'ajouter plusieurs paires clé-valeur à un dictionnaire en une seule fois. Il peut accepter un autre dictionnaire ou un itérable de paires clé-valeur. Voici la syntaxe :

dictionary.update(other)

Voici un exemple utilisant la méthode .update() méthode :

# Initialize a dictionary
my_dict = {'name': 'Alice', 'age': 25}

# Add new key-value pairs using update()
my_dict.update({'city': 'New York', 'email': 'alice@example.com'})

# Print the updated dictionary
print(my_dict)
# Output: {'name': 'Alice', 'age': 25, 'city': 'New York', 'email': 'alice@example.com'}

La méthode.update() peut également être utilisée avec un itérable de paires clé-valeur. En voici un exemple :

# Initialize a dictionary
my_dict = {'name': 'Alice', 'age': 25}

# Add new key-value pairs using update() with an iterable
my_dict.update([('city', 'New York'), ('email', 'alice@example.com')])

# Print the updated dictionary
print(my_dict)
# Output: {'name': 'Alice', 'age': 25, 'city': 'New York', 'email': 'alice@example.com'}

La méthode.update() est particulièrement utile lorsque vous devez mettre à jour le dictionnaire avec plusieurs nouvelles entrées simultanément. Si une clé existe déjà, sa valeur sera mise à jour.

Utilisation de la méthode .setdefault()

La méthode.setdefault() est utilisée pour ajouter une paire clé-valeur à un dictionnaire uniquement si la clé n'existe pas déjà. Si la clé existe, elle renvoie la valeur existante. Voici la syntaxe :

dictionary.setdefault(key, default_value)

Voici un exemple utilisant la méthode .setdefault() méthode :

# Initialize a dictionary
my_dict = {'name': 'Alice', 'age': 25}

# Use setdefault to add a new key-value pair
my_dict.setdefault('city', 'New York')

# Attempt to add an existing key
my_dict.setdefault('age', 30)

# Print the updated dictionary
print(my_dict)
# Output: {'name': 'Alice', 'age': 25, 'city': 'New York'}

Dans cet exemple, la méthode .setdefault() ajoute la clé 'city' avec la valeur 'New York' parce qu'elle n'existait pas encore dans le dictionnaire. Lorsque vous essayez d'ajouter la clé 'age', la valeur existante 25 n'est pas modifiée car la clé existe déjà.

Cette approche convient lorsque vous devez vous assurer qu'une clé a une valeur par défaut si elle n'existe pas. Elle peut également être utilisée lorsque vous souhaitez ajouter de nouvelles paires clé-valeur sans écraser les paires existantes.

Utiliser le constructeur dict()

Vous pouvez également créer un nouveau dictionnaire avec des paires clé-valeur supplémentaires à l'aide du constructeurdict(). Cette approche est utile lorsque vous souhaitez créer un nouveau dictionnaire sur la base d'un dictionnaire existant. Voici la syntaxe :

new_dict = dict(existing_dict, key1=value1, key2=value2)

Voici un exemple utilisant le dict() constructeur :

# Initialize a dictionary
my_dict = {'name': 'Alice', 'age': 25}

# Create a new dictionary with additional key-value pairs
new_dict = dict(my_dict, city='New York', email='alice@example.com')

# Print the new dictionary
print(new_dict)
# Output: {'name': 'Alice', 'age': 25, 'city': 'New York', 'email': 'alice@example.com'}

Dans cet exemple, le constructeur dict() est utilisé pour créer un nouveau dictionnaire new_dict qui comprend les paires clé-valeur originales de my_dict et les paires clé-valeur supplémentaires 'city': 'New York' et 'email': 'alice@example.com'.

Cette approche est intéressante lorsque vous souhaitez créer un nouveau dictionnaire en combinant des dictionnaires existants et des paires clé-valeur supplémentaires. Il peut également être utilisé lorsque vous devez créer un nouveau dictionnaire avec quelques modifications tout en gardant le dictionnaire original inchangé.

Tableau de comparaison

Voici un tableau de référence rapide pour les méthodes que nous avons abordées dans notre tutoriel :

Méthode Cas d'utilisation Exemple
Support carré Paire clé-valeur unique dict[key] = value
.update() Plusieurs paires clé-valeur dict.update({key1 : valeur1, key2 : valeur2})
.setdefault() Ajouter une paire clé-valeur uniquement si la clé n'existe pas dict.setdefault(key, default_value)
Constructeur dict() Créez un nouveau dictionnaire ou mettez à jour un dictionnaire existant avec des paires clé-valeur supplémentaires. new_dict = dict(existing_dict, key1=valeur1, key2=valeur2)

Techniques avancées d'ajout aux dictionnaires en Python

Comprendre les bases de la manipulation des dictionnaires est essentiel, mais pour vraiment maîtriser les dictionnaires en Python, il est important d'explorer certaines techniques avancées. Ces méthodes vous permettront d'améliorer votre capacité à gérer et à manipuler efficacement les dictionnaires dans des scénarios plus complexes.

Ajouter à des listes dans un dictionnaire

Les dictionnaires sont souvent utilisés pour stocker des listes en tant que valeurs. L'ajout d'éléments à ces listes nécessite une approche légèrement différente. Voici comment vous pouvez le faire en utilisant .append():

# Initialize a dictionary with a list as a value
dictionary_w_list = {'fruits': ['apple', 'banana']}

# Append an element to the list within the dictionary
dictionary_w_list['fruits'].append('cherry')

# Print the updated dictionary
print(dictionary_w_list)
# Output: {'fruits': ['apple', 'banana', 'cherry']}

Dans cet exemple, nous commençons par dictionary_w_list où la clé 'fruits' renvoie à une liste ['apple', 'banana']. En utilisant la méthode .append(), nous ajoutons 'cherry' à la liste. Cette technique est particulièrement utile pour gérer des collections d'éléments au sein d'un même dictionnaire.

Combiner des dictionnaires avec l'opérateur de fusion

Python 3.9 a introduit l'opérateur de fusion (|) pour combiner les dictionnaires. Cet opérateur vous permet de fusionner deux dictionnaires en un nouveau sans effort :

# Initialize two dictionaries
first_dictionary = {'name': 'Alice', 'age': 25}
second_dictionary = {'city': 'New York', 'email': 'alice@example.com'}

# Merge the dictionaries using the merge operator
merged_dictionary = first_dictionary | second_dictionary

# Print the merged dictionary
print(merged_dictionary)
# Output: {'name': 'Alice', 'age': 25, 'city': 'New York', 'email': 'alice@example.com'}

Dans cet exemple, first_dictionary et second_dictionary sont fusionnés dans un nouveau dictionnaire merged_dictionary. L'opérateur de fusion (| ) combine les paires clé-valeur des deux dictionnaires, ce qui en fait une méthode rapide et pratique pour fusionner des dictionnaires.

Utilisation de l'opérateur de mise à jour

Pour les mises à jour sur place, Python 3.9 a également introduit l'opérateur update |=. Cet opérateur vous permet de mettre à jour le dictionnaire d'origine avec les paires clé-valeur d'un autre dictionnaire.

# Initialize two dictionaries
first_dictionary = {'name': 'Alice', 'age': 25}
second_dictionary = {'city': 'New York', 'email': 'alice@example.com'}

# Update dict1 in-place using the update |= operator
first_dictionary |= second_dictionary

# Print the updated dictionary
print(first_dictionary)
# Output: {'name': 'Alice', 'age': 25, 'city': 'New York', 'email': 'alice@example.com'}

Ici, l' opérateurupdate |= met à jour first_dictionary avec le contenu de second_dictionary en place. Cela signifie que first_dictionary est directement modifié. Cette méthode est particulièrement utile lorsque vous devez mettre à jour un dictionnaire existant sans en créer un nouveau.

Conclusion

Dans cet article, nous avons découvert les dictionnaires Python et les méthodes permettant d'apposer des paires clé-valeur. Nous avons commencé par des techniques fondamentales telles que l'utilisation de la notation entre crochets et la méthode .update(), qui est essentielle pour des mises à jour rapides et directes. Nous sommes ensuite passés à des techniques plus avancées, notamment l'ajout de listes dans les dictionnaires, la fusion de dictionnaires à l'aide de l'opérateur de fusion (| ) et l'exécution de mises à jour sur place à l'aide de l'opérateur update |=. Ces méthodes fournissent des outils puissants pour gérer des structures de données complexes et effectuer des opérations efficaces.

Vous pouvez consulter certaines de nos ressources pour approfondir votre connaissance de Python. Vous pouvez consulter le cours Introduction à Python qui est un excellent point de départ car il permet d'acquérir les bases solides de Python en mettant l'accent sur les applications de la science des données. Le cursus de compétences en programmation Python offre également un programme d'études complet qui vous permet de passer du statut de débutant à celui de programmeur compétent.

Notre cursus professionnel de développeur Python est également conçu pour ceux qui veulent se pencher sur la programmation Python. Il couvre largement les constructions et les techniques de programmation les plus complexes.


Samuel Shaibu's photo
Author
Samuel Shaibu
LinkedIn

Professionnel expérimenté des données et écrivain passionné par l'autonomisation des experts en herbe dans le domaine des données.

Questions fréquemment posées

Comment ajouter une nouvelle paire clé-valeur à un dictionnaire Python ?

Vous pouvez ajouter une nouvelle paire clé-valeur à un dictionnaire Python en utilisant la notation entre crochets, comme dictionary[key] = value. Cette méthode met à jour le dictionnaire en place.

Qu'est-ce que la méthode .update() dans les dictionnaires Python, et comment est-elle utilisée ?

La méthode .update() est utilisée pour ajouter plusieurs paires clé-valeur à un dictionnaire. Il peut accepter un autre dictionnaire ou un itérable de paires clé-valeur, mettant à jour le dictionnaire existant.

Quelle est la différence entre la méthode .update() et l'opérateur de fusion (|) pour combiner des dictionnaires en Python ?

La méthode .update() modifie le dictionnaire existant en ajoutant des paires clé-valeur provenant d'un autre dictionnaire, ce qui peut entraîner l'écrasement des clés existantes. L'opérateur de fusion crée un nouveau dictionnaire contenant des éléments des deux dictionnaires, en laissant les dictionnaires d'origine inchangés.

Sujets

Apprenez Python avec DataCamp

cours

Introduction to Python

4 hr
6M
Master the basics of data analysis with Python in just four hours. This online course will introduce the Python interface and explore popular packages.
Afficher les détailsRight Arrow
Commencer le cours
Voir plusRight Arrow
Apparenté

blog

2022-2023 Rapport annuel DataCamp Classrooms

À l'aube de la nouvelle année scolaire, DataCamp Classrooms est plus motivé que jamais pour démocratiser l'apprentissage des données, avec plus de 7 650 nouveaux Classrooms ajoutés au cours des 12 derniers mois.
Nathaniel Taylor-Leach's photo

Nathaniel Taylor-Leach

8 min

blog

Q2 2023 DataCamp Donates Digest

DataCamp Donates a offert plus de 20k bourses d'études à nos partenaires à but non lucratif au deuxième trimestre 2023. Découvrez comment des apprenants défavorisés et assidus ont transformé ces opportunités en réussites professionnelles qui ont changé leur vie.
Nathaniel Taylor-Leach's photo

Nathaniel Taylor-Leach

blog

Les 20 meilleures questions d'entretien pour les flocons de neige, à tous les niveaux

Vous êtes actuellement à la recherche d'un emploi qui utilise Snowflake ? Préparez-vous à répondre à ces 20 questions d'entretien sur le flocon de neige pour décrocher le poste !
Nisha Arya Ahmed's photo

Nisha Arya Ahmed

20 min

blog

Nous avons fait don de bourses DataCamp Premium à un million de personnes, et ce n'est pas fini.

Réparties entre nos deux programmes d'impact social, DataCamp Classrooms et #DCDonates, les bourses offrent un accès illimité à tout ce que DataCamp Premium a à offrir.
Nathaniel Taylor-Leach's photo

Nathaniel Taylor-Leach

blog

Les 32 meilleures questions d'entretien sur AWS et leurs réponses pour 2024

Un guide complet pour explorer les questions d'entretien AWS de base, intermédiaires et avancées, ainsi que des questions basées sur des situations réelles. Il couvre tous les domaines, garantissant ainsi une stratégie de préparation bien équilibrée.
Zoumana Keita 's photo

Zoumana Keita

30 min

blog

Célébration de Saghar Hazinyar : Une boursière de DataCamp Donates et une diplômée de Code to Inspire

Découvrez le parcours inspirant de Saghar Hazinyar, diplômée de Code to Inspire, qui a surmonté les défis en Afghanistan et s'est épanouie grâce à une bourse de DataCamp Donates.
Fereshteh Forough's photo

Fereshteh Forough

4 min

Voir plusVoir plus