Course
Tutoriel de compréhension du dictionnaire Python
Les dictionnaires (ou dict
en Python) sont un moyen de stocker des éléments comme vous le feriez dans une liste Python. Mais au lieu d'accéder aux éléments en utilisant leur index, vous leur attribuez une clé fixe et vous accédez à l'élément en utilisant cette clé. Vous avez maintenant affaire à une paire "clé-valeur", qui est parfois une structure de données plus appropriée pour de nombreux problèmes qu'une simple liste. Vous aurez souvent affaire à des dictionnaires lorsque vous ferez de la science des données, ce qui fait de la compréhension des dictionnaires une compétence que vous voudrez maîtriser.
Dans ce tutoriel :
- Tout d'abord, vous verrez ce qu'est réellement un dictionnaire Python et comment vous pouvez l'utiliser efficacement.
- Ensuite, vous apprendrez à comprendre les dictionnaires Python : vous verrez ce que c'est, pourquoi c'est important, et comment cela peut servir d'alternative aux boucles for et aux fonctions lambda.
- Vous apprendrez à ajouter des conditionnelles dans les compréhensions de dictionnaires : vous travaillerez avec des conditions "si", des conditions "si" multiples et des instructions "si" et "si".
- Enfin, vous verrez ce qu'est la compréhension des dictionnaires imbriqués, comment vous pouvez l'utiliser et comment vous pouvez éventuellement la réécrire avec des boucles for.
Pour exécuter facilement vous-même tous les exemples de code de ce tutoriel, vous pouvez créer gratuitement un classeur DataLab dans lequel Python est préinstallé et qui contient tous les exemples de code. Pour vous entraîner davantage à la compréhension des dictionnaires, consultez cet exercice pratique de DataCamp.
Apprenez Python à partir de zéro
Dictionnaire Python
En Python, un dictionnaire est une collection d'éléments auxquels on accède par une clé spécifique plutôt que par un index. Qu'est-ce que cela signifie ?
Imaginez un dictionnaire dans le monde réel... lorsque vous devez chercher la signification d'un mot, vous essayez de trouver la signification en utilisant le mot lui-même et non l'index possible du mot. Les dictionnaires Python fonctionnent selon le même concept : le mot dont vous recherchez la signification est la clé, et la signification du mot est la valeur ; vous n'avez pas besoin de connaître l'index du mot dans un dictionnaire pour trouver sa signification.
Initialiser un dictionnaire en Python
Vous pouvez initialiser un dictionnaire en Python de cette manière :
a = {'apple': 'fruit', 'beetroot': 'vegetable', 'cake': 'dessert'}
a['doughnut'] = 'snack'
print(a['apple'])
fruit
print(a[0])
--------------------------------------------------------------------------- KeyError Traceback (most recent call last) <ipython-input-9-00d4a978143a> in <module>() ----> 1 print(a[0]) KeyError: 0
Tout d'abord, nous créons un dictionnaire nommé a
qui contient trois paires clé-valeur : "pomme" : "fruit", "betterave" : "légume", et "gâteau" : "dessert". Les clés sont des chaînes de caractères qui représentent les noms des articles et les valeurs sont des chaînes de caractères qui représentent le type ou la catégorie de l'article.
Ensuite, nous ajoutons une nouvelle paire clé-valeur au dictionnaire a
en utilisant la syntaxe a['doughnut'] = 'snack'
. Cette opération ajoute la clé "doughnut" au dictionnaire avec la valeur correspondante "snack".
La troisième ligne du code imprime la valeur associée à la clé 'apple' dans le dictionnaire a
. Comme "pomme" est une clé du dictionnaire, le code imprime la valeur "fruit".
La quatrième ligne du code tente d'imprimer la valeur associée à la clé 0 dans le dictionnaire a
, qui n'est pas une clé valide dans le dictionnaire. Il en résulte une KeyError, qui se produit lorsque l'on tente d'accéder à une clé qui n'existe pas dans un dictionnaire.
Types de données du dictionnaire Python
Les éléments d'un dictionnaire peuvent avoir n'importe quel type de données. Vous trouverez ci-dessous d'autres exemples de dictionnaires pour vous familiariser avec le sujet :
Créez un dictionnaire a
avec quatre paires clé-valeur :
a = {'one': 1, 'two': 'to', 'three': 3.0, 'four': [4,4.0]}
print(a)
{'four': [4, 4.0], 'two': 'to', 'three': 3.0, 'one': 1}
Mettez à jour la valeur associée à la clé "un" dans le dictionnaire a à 1.0.
# Update a dictionary
a['one'] = 1.0
print(a)
{'four': [4, 4.0], 'two': 'to', 'three': 3.0, 'one': 1.0}
Supprimez du dictionnaire a la paire clé-valeur associée à la clé "one".
# Delete a single element
del a['one']
print(a)
{'four': [4, 4.0], 'two': 'to', 'three': 3.0}
Supprimez toutes les paires clé-valeur du dictionnaire a
à l'aide de la méthode clear().
# Delete all elements in the dictionary
a.clear()
print(a)
{}
Supprimez le dictionnaire a
à l'aide du mot-clé del.
# Delete the dictionary
del a
print(a)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-12-701c9d6596da> in <module>()
1 del a #Deletes the dictionary
----> 2 print(a)
NameError: name 'a' is not defined
Il est important de se rappeler qu'une clé doit être unique dans un dictionnaire ; les doublons ne sont pas autorisés. Toutefois, en cas de duplication des clés, plutôt que d'afficher une erreur, Python considérera que la dernière instance de la clé est valide et ignorera simplement la première paire clé-valeur. Voyez par vous-même :
sweet_dict = {'a1': 'cake', 'a2':'cookie', 'a1': 'icecream'}
print(sweet_dict['a1'])
icecream
Compréhension du dictionnaire Python
La compréhension des dictionnaires est une méthode permettant de transformer un dictionnaire en un autre dictionnaire. Au cours de cette transformation, les éléments du dictionnaire original peuvent être inclus de manière conditionnelle dans le nouveau dictionnaire, et chaque élément peut être transformé selon les besoins.
Une bonne compréhension des listes peut rendre votre code plus expressif et donc plus facile à lire. La clé de la création de compréhensions est de ne pas les laisser devenir si complexes que votre tête se met à tourner lorsque vous essayez de déchiffrer ce qu'elles font réellement. Maintenir l'idée de "facilité de lecture".
La façon de comprendre un dictionnaire en Python est de pouvoir accéder aux objets key
et value
d'un dictionnaire.
Comment procéder ?
Python vous couvre ! Vous pouvez simplement utiliser les méthodes intégrées :
dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
# Put all keys of `dict1` in a list and returns the list
dict1.keys()
dict_keys(['c', 'd', 'a', 'b'])
# Put all values saved in `dict1` in a list and returns the list
dict1.values()
dict_values([3, 4, 1, 2])
Le code ci-dessus crée un dictionnaire Python appelé dict1
avec quatre paires clé-valeur. La méthode keys() est appelée sur le dictionnaire, ce qui renvoie un objet de vue contenant toutes les clés du dictionnaire.
La méthode values() est également appelée sur le dictionnaire, ce qui renvoie un objet view contenant toutes les valeurs du dictionnaire.
Les deux objets de vue se comportent comme des ensembles et peuvent être utilisés pour effectuer des opérations d'ensemble sur les clés et les valeurs, respectivement.
Notez que l'ordre des clés et des valeurs dans les objets de la vue n'est pas garanti comme étant le même que l'ordre dans lequel ils ont été ajoutés au dictionnaire.
Utiliser la méthode items()
Maintenant que vous savez comment accéder à toutes les clés et à leurs valeurs dans un dictionnaire. Vous pouvez également accéder à chaque paire clé-valeur d'un dictionnaire à l'aide de la méthode items()
:
dict1.items()
dict_items([('c', 3), ('d', 4), ('a', 1), ('b', 2)])
Il s'agit du modèle général que vous pouvez suivre pour la compréhension du dictionnaire en Python :
dict_variable = {key:value for (key,value) in dictonary.items()}
Il peut servir de modèle de base et de modèle le plus simple. Cela peut devenir de plus en plus complexe au fur et à mesure que vous y ajoutez des conditionnalités.
Exemple de compréhension d'un dictionnaire Python de base
Commençons par une simple compréhension du dictionnaire :
dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
# Double each value in the dictionary
double_dict1 = {k:v*2 for (k,v) in dict1.items()}
print(double_dict1)
{'e': 10, 'a': 2, 'c': 6, 'b': 4, 'd': 8}
Dans le code de compréhension ci-dessus, nous créons un nouveau dictionnaire double_dict1
à partir d'un dictionnaire dict1
en doublant simplement chaque valeur qu'il contient.
Vous pouvez également modifier les valeurs clés. Par exemple, créons le même dictionnaire que ci-dessus mais changeons également les noms des clés.
dict1_keys = {k*2:v for (k,v) in dict1.items()}
print(dict1_keys)
{'dd': 4, 'ee': 5, 'aa': 1, 'bb': 2, 'cc': 3}
Pourquoi utiliser le dictionnaire de compréhension ?
La compréhension du dictionnaire est un concept puissant qui peut être utilisé pour remplacer les boucles for
et les fonctions lambda
. Cependant, toutes les boucles for ne peuvent pas être écrites comme une compréhension de dictionnaire, mais toutes les compréhensions de dictionnaire peuvent être écrites avec une boucle for.
Considérez le problème suivant : vous souhaitez créer un nouveau dictionnaire dont la clé est un nombre divisible par 2 dans une fourchette de 0 à 10, et dont la valeur est le carré du nombre.
Voyons comment vous pouvez résoudre le même problème en utilisant une boucle for et la compréhension du dictionnaire :
numbers = range(10)
new_dict_for = {}
# Add values to `new_dict` using for loop
for n in numbers:
if n%2==0:
new_dict_for[n] = n**2
print(new_dict_for)
{0: 0, 8: 64, 2: 4, 4: 16, 6: 36}
# Use dictionary comprehension
new_dict_comp = {n:n**2 for n in numbers if n%2 == 0}
print(new_dict_comp)
{0: 0, 8: 64, 2: 4, 4: 16, 6: 36}
Alternative à for
boucles
Les boucles For sont utilisées pour répéter une certaine opération ou un bloc d'instructions dans un programme pour un nombre donné de fois. Cependant, les boucles for imbriquées (boucle for à l'intérieur d'une autre boucle for) peuvent être source de confusion et de complexité. Les dictionnaires compréhensifs sont plus efficaces dans de telles situations et peuvent simplifier la lisibilité et la compréhension du code.
Conseil: consultez le tutoriel Loops in Python de DataCamp pour plus d'informations sur les boucles en Python.
Alternative à lambda
fonctions
Les fonctions lambda permettent de créer de petites fonctions anonymes. Ce sont des fonctions sans nom. Ces fonctions sont des fonctions jetables, qui ne sont nécessaires que là où elles ont été créées. Les fonctions lambda sont principalement utilisées en combinaison avec les fonctions filter()
, map()
et reduce()
.
Examinons la fonction lambda et la fonction map()
:
# Initialize `fahrenheit` dictionary
fahrenheit = {'t1':-30, 't2':-20, 't3':-10, 't4':0}
#Get the corresponding `celsius` values
celsius = list(map(lambda x: (float(5)/9)*(x-32), fahrenheit.values()))
#Create the `celsius` dictionary
celsius_dict = dict(zip(fahrenheit.keys(), celsius))
print(celsius_dict)
{'t2': -28.88888888888889, 't3': -23.333333333333336, 't1': -34.44444444444444, 't4': -17.77777777777778}
Exemple de compréhension du dictionnaire Python
Examinons une autre situation dans laquelle vous souhaitez convertir un dictionnaire de températures Fahrenheit en Celsius.
Décomposons le code : tout d'abord, vous devez définir une formule mathématique qui effectue la conversion de Fahrenheit en Celsius.
Dans le code, cela se fait à l'aide de la fonction lambda. Vous transmettez ensuite cette fonction comme argument à la fonction map()
, qui applique alors l'opération à chaque élément de la liste fahrenheit.values()
.
Vous vous souvenez de la fonction values()
? Elle renvoie une liste contenant les éléments stockés dans le dictionnaire.
Vous disposez maintenant d'une liste contenant la valeur de la température en degrés Celsius, mais la solution exige qu'il s'agisse d'un dictionnaire.
Python dispose d'une fonction intégrée appelée zip()
qui passe en revue les éléments des itérateurs et les agrège. Vous pouvez en savoir plus sur la fonction zip()
dans cet exemple Python.
Dans notre exemple ci-dessus, la fonction zip agrège l'élément de la liste fahrenheit.keys()
et de la liste celsius
, ce qui donne une paire clé-valeur que vous pouvez rassembler dans un dictionnaire à l'aide de la fonction dict
, ce qui est le résultat souhaité.
Essayons maintenant de résoudre le même problème en utilisant la compréhension du dictionnaire :
# Initialize the `fahrenheit` dictionary
fahrenheit = {'t1': -30,'t2': -20,'t3': -10,'t4': 0}
# Get the corresponding `celsius` values and create the new dictionary
celsius = {k:(float(5)/9)*(v-32) for (k,v) in fahrenheit.items()}
print(celsius_dict)
{'t2': -28.88888888888889, 't3': -23.333333333333336, 't1': -34.44444444444444, 't4': -17.77777777777778}
Voici un aperçu de ce que nous avons créé dans le code ci-dessus :
- Créez un dictionnaire nommé
fahrenheit
avec quatre paires clé-valeur représentant des relevés de température en Fahrenheit. - Définissez un nouveau dictionnaire appelé
celsius
. - Utilisez une compréhension du dictionnaire pour itérer sur le dictionnaire
fahrenheit
et convertissez les relevés de température Fahrenheit en Celsius à l'aide de la formule(5/9) * (F-32)
. - Pour chaque paire clé-valeur dans
fahrenheit
, la clé est assignée à la variablek
et la valeur est assignée à la variablev
. - La valeur de la température Celsius correspondant à chaque température Fahrenheit est calculée à l'aide de la formule ci-dessus et est ajoutée en tant que paire clé-valeur au dictionnaire
celsius
. - Le dictionnaire
celsius
qui en résulte est imprimé sur la console.
Comme vous pouvez le constater, le problème peut être résolu avec une seule ligne de code en utilisant la compréhension du dictionnaire par rapport au processus en deux étapes et à la compréhension du fonctionnement de trois fonctions (lambda
, map()
et zip()
) pour la première mise en œuvre.
De plus, la solution est intuitive et facile à comprendre grâce à la compréhension du dictionnaire. Par conséquent, la compréhension du dictionnaire peut constituer une bonne alternative aux fonctions lambda.
Ajouter des conditionnels à la compréhension du dictionnaire
Vous devez souvent ajouter des conditions à une solution lorsque vous vous attaquez à un problème. Voyons comment vous pouvez ajouter des conditions à la compréhension du dictionnaire pour la rendre plus puissante.
Si la condition est remplie
Supposons que vous deviez créer un nouveau dictionnaire à partir d'un dictionnaire donné, mais avec des éléments supérieurs à 2. Cela signifie que vous devez ajouter une condition au modèle original que vous avez vu ci-dessus...
dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
# Check for items greater than 2
dict1_cond = {k:v for (k,v) in dict1.items() if v>2}
print(dict1_cond)
{'e': 5, 'c': 3, 'd': 4}
Ce n'est pas si difficile ! Mais qu'en est-il si vous souffrez de plusieurs maladies ?
Plusieurs conditions "If" (si)
Dans le problème ci-dessus, que se passe-t-il si vous devez non seulement obtenir les éléments supérieurs à 2, mais aussi vérifier s'ils sont multiples de 2 en même temps ?
dict1_doubleCond = {k:v for (k,v) in dict1.items() if v>2 if v%2 == 0}
print(dict1_doubleCond)
{'d': 4}
La solution pour ajouter des conditions multiples est aussi simple que d'ajouter les conditions l'une après l'autre dans votre compréhension. Cependant, vous devez faire attention à ce que vous essayez de faire dans le problème. Rappelez-vous que les instructions if consécutives fonctionnent comme si elles étaient séparées par des clauses and
.
Voyons un autre exemple avec trois conditions :
dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f':6}
dict1_tripleCond = {k:v for (k,v) in dict1.items() if v>2 if v%2 == 0 if v%3 == 0}
print(dict1_tripleCond)
{'f': 6}
Dans une boucle for, cela correspondra à :
dict1_tripleCond = {}
for (k,v) in dict1.items():
if (v>=2 and v%2 == 0 and v%3 == 0):
dict1_tripleCond[k] = v
print(dict1_tripleCond)
{'f': 6}
Conditions If-Else
La compréhension du dictionnaire permet également de traiter facilement les conditions de type "if-else". Consultez l'exemple suivant pour vous en convaincre :
dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f':6}
# Identify odd and even entries
dict1_tripleCond = {k:('even' if v%2==0 else 'odd') for (k,v) in dict1.items()}
print(dict1_tripleCond)
{'f': 'even', 'c': 'odd', 'b': 'even', 'd': 'even', 'e': 'odd', 'a': 'odd'}
Compréhension des dictionnaires imbriqués
L'imbrication est un concept de programmation dans lequel les données sont organisées en couches, ou dans lequel les objets contiennent d'autres objets similaires. Vous avez sans doute souvent vu une structure "if" imbriquée, c'est-à-dire une condition "if" à l'intérieur d'une autre condition "if".
De même, les dictionnaires peuvent être imbriqués, et donc leurs compréhensions peuvent l'être également. Voyons ce que cela signifie :
nested_dict = {'first':{'a':1}, 'second':{'b':2}}
float_dict = {outer_k: {float(inner_v) for (inner_k, inner_v) in outer_v.items()} for (outer_k, outer_v) in nested_dict.items()}
print(float_dict)
{'first': {1.0}, 'second': {2.0}}
Voici un exemple de dictionnaire imbriqué. Le site nested_dict
est un dictionnaire dont les clés sont : first
et second
, qui contiennent des objets du dictionnaire dans leurs valeurs. Le code utilise les valeurs internes du dictionnaire et les convertit en valeurs flottantes, puis combine les clés externes avec les nouvelles valeurs internes flottantes dans un nouveau dictionnaire.
Le code comporte également une compréhension de dictionnaire imbriquée, c'est-à-dire une compréhension de dictionnaire à l'intérieur d'une autre. La compréhension du dictionnaire, lorsqu'elle est imbriquée, peut devenir assez difficile à lire et à comprendre, ce qui enlève tout son intérêt à l'utilisation des compréhensions.
Au fur et à mesure que la structure du dictionnaire avec lequel vous travaillez se complique, la compréhension du dictionnaire se complique également. Dans de telles situations, il est préférable de ne pas utiliser de compréhensions compliquées dans votre code.
Notez que vous pouvez réécrire le morceau de code ci-dessus avec une boucle for imbriquée :
nested_dict = {'first':{'a':1}, 'second':{'b':2}}
for (outer_k, outer_v) in nested_dict.items():
for (inner_k, inner_v) in outer_v.items():
outer_v.update({inner_k: float(inner_v)})
nested_dict.update({outer_k:outer_v})
print(nested_dict)
{'first': {'a': 1.0}, 'second': {'b': 2.0}}
Réflexions finales
Nous espérons que vous avez maintenant appris à connaître les dictionnaires en Python, le concept de compréhension, et pourquoi et où la compréhension des dictionnaires Python peut être utile.
C'est en s'exerçant que l'on améliore son python ! Consultez quelques-uns de nos meilleurs conseils et astuces Python pour améliorer votre code, ou suivez notre parcours de compétences Python pour maîtriser davantage les principes fondamentaux.
FAQ sur la compréhension du dictionnaire Python
Qu'est-ce que la compréhension du dictionnaire en Python ?
La compréhension de dictionnaire est un moyen concis et lisible de créer des dictionnaires en Python. Il permet de créer un nouveau dictionnaire à partir d'un objet itérable tel qu'une liste, un tuple ou un ensemble.
Quelle est la syntaxe pour la compréhension du dictionnaire en Python ?
La syntaxe pour la compréhension du dictionnaire en Python est la suivante : {key:value for (key,value) in iterable}
Comment créer un dictionnaire à partir d'une liste en utilisant la compréhension du dictionnaire en Python ?
Vous pouvez créer un dictionnaire à partir d'une liste en utilisant la compréhension de dictionnaire en Python en itérant sur la liste et en définissant les éléments de la liste comme clés et valeurs dans le nouveau dictionnaire.
Puis-je utiliser des instructions conditionnelles dans la compréhension du dictionnaire en Python ?
Oui, vous pouvez utiliser des instructions conditionnelles dans la compréhension du dictionnaire en Python pour filtrer certains éléments.
Quels sont les avantages de l'utilisation de la compréhension du dictionnaire en Python ?
L'utilisation de la compréhension des dictionnaires en Python présente l'avantage d'être concise, lisible et de réduire la quantité de code nécessaire à la création des dictionnaires. Il permet également de filtrer et de transformer les éléments du dictionnaire en une seule ligne de code.
J'ai travaillé dans différents secteurs d'activité et j'ai porté plusieurs casquettes : développeur de logiciels, chercheur en apprentissage automatique, scientifique des données, chef de produit. Mais au fond, je suis un programmeur qui aime apprendre et partager ses connaissances !
Cours Python
Course
Introduction à la science des données en Python
Course