💡 Ce tutoriel est traduit par l'IA à partir de la version anglaise. Pour voir la version originale, vous pouvez cliquer ici
Le defaultdict de Python est une structure de données polyvalente qui simplifie le processus de gestion des clés manquantes. Dans ce tutoriel, nous allons explorer comment ajouter efficacement des valeurs à un defaultdict, vous offrant ainsi une compétence précieuse pour votre boîte à outils de programmation Python. À la fin de ce guide, vous aurez une bonne compréhension du defaultdict et de ses applications pratiques.
Le defaultdict est une sous-classe de la classe dict intégrée en Python. Il offre un moyen de gérer les clés manquantes dans un dictionnaire sans lever une erreur KeyError. Au lieu de cela, il crée automatiquement une nouvelle entrée avec une valeur par défaut lorsqu'une clé manquante est accédée.
Le defaultdict est un type de dictionnaire qui prend un objet appelable (callable) en argument, utilisé pour fournir la valeur par défaut d'une clé manquante. Cet objet appelable peut être une fonction, une classe ou tout autre objet qui peut être appelé sans arguments et qui renvoie la valeur par défaut souhaitée.
Le defaultdict est particulièrement utile lorsque vous devez effectuer des opérations sur un dictionnaire dont les clés peuvent ne pas exister initialement. C'est le cas lorsque vous essayez d'accumuler des valeurs, de compter des occurrences ou d'effectuer d'autres opérations qui nécessitent la capacité de gérer gracieusement les clés manquantes.
Pour créer un defaultdict, vous devez importer la classe defaultdict du module collections. Voici un exemple :
from collections import defaultdict
## Create a defaultdict with a default value of 0
d = defaultdict(int)
## Add some values to the dictionary
d['apple'] += 1
d['banana'] += 2
d['cherry'] += 3
print(d)
## Output: defaultdict(<class 'int'>, {'apple': 1, 'banana': 2, 'cherry': 3})Dans cet exemple, nous créons un defaultdict avec la valeur par défaut de 0 (fournie par la fonction int). Lorsque nous essayons d'accéder à une clé manquante, le defaultdict crée automatiquement une nouvelle entrée avec la valeur par défaut de 0.
Lorsque vous travaillez avec un defaultdict, vous aurez souvent besoin d'ajouter des valeurs aux valeurs par défaut. Cela peut être particulièrement utile lorsque vous essayez d'accumuler des données ou de compter les occurrences d'éléments.
Pour ajouter des valeurs à la valeur par défaut dans un defaultdict, vous pouvez simplement utiliser la syntaxe standard des dictionnaires pour accéder à la clé et effectuer l'opération souhaitée. Voici un exemple :
from collections import defaultdict
## Create a defaultdict with a default value of an empty list
d = defaultdict(list)
## Append values to the default list
d['apple'].append(1)
d['apple'].append(2)
d['banana'].append(3)
d['banana'].append(4)
print(d)
## Output: defaultdict(<class 'list'>, {'apple': [1, 2], 'banana': [3, 4]})Dans cet exemple, nous créons un defaultdict avec une valeur par défaut d'une liste vide ([]). Lorsque nous essayons d'accéder à une clé manquante, le defaultdict crée automatiquement une nouvelle entrée avec la valeur par défaut d'une liste vide. Nous pouvons ensuite ajouter des valeurs à ces listes selon les besoins.
Vous pouvez également utiliser une boucle pour ajouter des valeurs à un defaultdict. Cela peut être utile lorsque vous avez un ensemble de données plus important ou que vous devez effectuer des opérations plus complexes. Voici un exemple :
from collections import defaultdict
## Create a defaultdict with a default value of an empty list
d = defaultdict(list)
## Append values to the default list using a loop
data = [('apple', 1), ('apple', 2), ('banana', 3), ('banana', 4), ('cherry', 5)]
for key, value in data:
d[key].append(value)
print(d)
## Output: defaultdict(<class 'list'>, {'apple': [1, 2], 'banana': [3, 4], 'cherry': [5]})Dans cet exemple, nous avons une liste de tuples contenant les paires clé-valeur. Nous parcourons les données et ajoutons les valeurs aux listes correspondantes dans le defaultdict.
En utilisant le defaultdict avec l'ajout de valeurs, vous pouvez facilement gérer les clés manquantes et construire des structures de données complexes sans avoir à vous soucier de créer de nouvelles entrées ou de gérer les exceptions KeyError.
Le defaultdict est une structure de données polyvalente qui peut être utilisée dans une variété de scénarios pratiques. Voici quelques cas d'utilisation courants :
L'un des cas d'utilisation les plus courants du defaultdict est le comptage des occurrences d'éléments dans un ensemble de données. Cela est particulièrement utile lorsque vous devez effectuer une analyse de fréquence ou créer des histogrammes. Voici un exemple :
from collections import defaultdict
## Count the occurrences of words in a sentence
sentence = "the quick brown fox jumps over the lazy dog"
word_count = defaultdict(int)
for word in sentence.split():
word_count[word] += 1
print(word_count)
## Output: defaultdict(<class 'int'>, {'the': 2, 'quick': 1, 'brown': 1, 'fox': 1, 'jumps': 1, 'over': 1, 'lazy': 1, 'dog': 1})Un autre cas d'utilisation courant du defaultdict est le groupement de données en fonction d'une clé. Cela peut être utile lorsque vous devez organiser des données en catégories ou effectuer des opérations sur des sous-ensembles de données. Voici un exemple :
from collections import defaultdict
## Group people by their age
people = [
{'name': 'Alice', 'age': 25},
{'name': 'Bob', 'age': 30},
{'name': 'Charlie', 'age': 25},
{'name': 'David', 'age': 35},
]
age_groups = defaultdict(list)
for person in people:
age_groups[person['age']].append(person['name'])
print(age_groups)
## Output: defaultdict(<class 'list'>, {25: ['Alice', 'Charlie'], 30: ['Bob'], 35: ['David']})Le defaultdict peut également être utilisé pour créer des structures de données imbriquées, telles que des dictionnaires de dictionnaires. Cela peut être utile lorsque vous devez représenter des données hiérarchiques complexes. Voici un exemple :
from collections import defaultdict
## Create a nested dictionary to store product information
products = defaultdict(lambda: defaultdict(dict))
products['Electronics']['Laptop']['price'] = 999.99
products['Electronics']['Laptop']['brand'] = 'LabEx'
products['Electronics']['Smartphone']['price'] = 499.99
products['Electronics']['Smartphone']['brand'] = 'LabEx'
products['Furniture']['Chair']['price'] = 79.99
products['Furniture']['Chair']['brand'] = 'LabEx'
print(products)
## Output: defaultdict(<function <lambda> at 0x7f6a8c1c8d60>, {'Electronics': {'Laptop': {'price': 999.99, 'brand': 'LabEx'}, 'Smartphone': {'price': 499.99, 'brand': 'LabEx'}}, 'Furniture': {'Chair': {'price': 79.99, 'brand': 'LabEx'}}})En utilisant le defaultdict, vous pouvez facilement créer et gérer des structures de données complexes sans avoir à vous soucier des clés manquantes ou de l'initialisation des dictionnaires imbriqués.
Dans ce tutoriel Python complet, vous avez appris à ajouter efficacement des valeurs à un defaultdict, une puissante structure de données qui simplifie la gestion des clés manquantes. En maîtrisant cette technique, vous pouvez rationaliser vos flux de travail de programmation Python et découvrir de nouvelles possibilités pour la gestion et la manipulation des données. Que vous soyez un débutant ou un développeur Python expérimenté, les connaissances acquises à partir de ce guide se révèleront inestimables dans vos futurs projets.
