La structure de données du dictionnaire de Python est l'une des structures de données les plus puissantes et les plus sous-utilisées de Python. Pourquoi? Parce que vérifier l'appartenance est plus efficace pour les dictionnaires que pour les listes, tandis que l'accès aux éléments est plus facile pour les dictionnaires que pour les ensembles.
Dans ce didacticiel, vous apprendrez à effectuer quatre opérations de dictionnaire courantes dans une ligne de code Python. En étudiant ces problèmes, vous apprendrez non seulement à utiliser des dictionnaires en Python, mais vous deviendrez un meilleur codeur dans l'ensemble. Alors, plongeons dans le premier problème :créer un dictionnaire à partir d'une liste sur une seule ligne.
Python créer un dictionnaire à partir d'une liste sur une seule ligne
Défi :Créez un dictionnaire à partir d'une liste dans une ligne de Python.
Exemple :Supposons que vous souhaitiez que les indices de la liste soient des clés et les éléments de la liste des valeurs.
# Given a list:
a = ['Alice', 'Liz', 'Bob']
# One-Line Statement Creating a Dict:
d = one-line-statement
print(d)
# {0: 'Alice', 1: 'Liz', 2: 'Bob'}
Solution :Il existe plusieurs façons d'accomplir cette tâche. Apprenons ensuite le plus Pythonique :
# Given a list:
a = ['Alice', 'Liz', 'Bob']
# One-Line Statement Creating a Dict:
d = dict(enumerate(a))
print(d)
# {0: 'Alice', 1: 'Liz', 2: 'Bob'}
Le one-liner dict(enumerate(a)) crée d'abord un itérable de (index, element) tuples de la liste a en utilisant le enumerate fonction. Le dict() constructeur qui transforme cet itérable de tuples en (key, value) mappages. Le index la valeur du tuple devient le nouveau key . Le element la valeur du tuple devient le nouveau value .
Exercice :Explorez les enumerate() fonction plus loin en imprimant sa sortie !
Python One Line For Loop pour créer un dictionnaire
Défi :Comment créer un dictionnaire à partir de tous les éléments d'une liste à l'aide d'une boucle for sur une seule ligne ?
Exemple :Supposons que vous souhaitiez remplacer l'extrait de code à quatre lignes suivant par un extrait de code Python à une ligne.
a = ['Alice', 'Liz', 'Bob']
data = {}
for item in a:
data[item] = item Comment y parvenir ?
Solution :Utilisez la compréhension du dictionnaire pour remplacer le for construction de boucle avec une seule ligne de Python.
a = ['Alice', 'Liz', 'Bob']
# One-Liner Dictionary For Loop
data = {item:item for item in a}
print(data)
# {'Alice': 'Alice', 'Liz': 'Liz', 'Bob': 'Bob'} Compréhension du dictionnaire est un moyen concis et économe en mémoire pour créer et initialiser des dictionnaires dans une ligne de code Python. Il se compose de deux parties :l'expression et le contexte. L'expression définit comment mapper les clés aux valeurs. Le contexte boucle sur un itérable à l'aide d'une boucle for sur une seule ligne et définit les paires (clé, valeur) à inclure dans le nouveau dictionnaire.
Vous pouvez en apprendre davantage sur la compréhension du dictionnaire dans mon didacticiel vidéo complet :
Article connexe :Compréhension du dictionnaire — Guide complet
Python Print Dictionary One Line
Défi :Comment pouvez-vous imprimer un dictionnaire de manière bien structurée en utilisant une seule ligne de code Python (sans utiliser plusieurs lignes pour créer la sortie) ?
Solution :Utilisez la jolie fonction d'impression !
Le module intégré pprint contient la fonction pprint . Cela "imprimera joliment" votre dictionnaire. Il trie les clés par ordre alphabétique et imprime chaque paire clé-valeur sur une nouvelle ligne.
from pprint import pprint
messy_dict = dict(z='Here is a really long key that spans a lot of text', a='here is another long key that is really too long', j='this is the final key in this dictionary')
pprint(messy_dict)
'''
{'a': 'here is another long key that is really too long',
'j': 'this is the final key in this dictionary',
'z': 'Here is a really long key that spans a lot of text'}
'''
L'impression du dictionnaire de cette façon ne change en rien le dictionnaire mais le rend plus lisible sur le shell Python !
Itérer sur une ligne du dictionnaire Python
Défi :Comment itérer sur un dictionnaire en Python en une seule ligne ?
Exemple :Supposons que vous souhaitiez parcourir chaque (key, value) paire d'un dictionnaire comme celui-ci :
age = {'Alice': 19, 'Bob': 23, 'Frank': 53}
# Iterate over dictionary (key, value) pairs
for name in age:
key, value = name, age[name]
print(key, value)
'''
OUTPUT:
Alice 19
Bob 23
Frank 53
''' Mais vous voulez le faire en une seule ligne de code Python ! Comment ?
Solution :Utilisez le dict.items() méthode pour obtenir l'itérable. Ensuite, utilisez une boucle for sur une seule ligne pour la parcourir.
age = {'Alice': 19, 'Bob': 23, 'Frank': 53}
# Iterate over dictionary (key, value) pairs
for k,v in age.items(): print(k,v)
'''
OUTPUT:
Alice 19
Bob 23
Frank 53
'''
La sortie est la même tandis que le code est beaucoup plus concis. Le items() la méthode d'un objet dictionnaire crée un itérable de (key, value) paires de tuples du dictionnaire.
Dictionnaire de mise à jour Python en une seule ligne
Défi :Soit un dictionnaire et un (key, value) paire. Le key peut ou non déjà exister dans le dictionnaire. Comment mettre à jour le dictionnaire en une ligne de Python ?
Solution :Utilisez la notation entre crochets dict[key] = value pour créer un nouveau mapping à partir de key à value dans le dictionnaire. Il y a deux cas :
- Le
keyexistait déjà avant et était associé à l'ancienvalue_old. Dans ce cas, le nouveauvalueécrase l'ancienvalue_oldaprès la mise à jour du dictionnaire. - Le
keyn'existait pas auparavant dans le dictionnaire. Dans ce cas, il est créé pour la première fois et associé àvalue.
Voici le code :
age = {'Alice': 19, 'Bob': 23, 'Frank': 53}
print(f"Alice is {age['Alice']} years old")
# Alice is 19 years old
# Alice's Birthday
age['Alice'] = 20
print(f"Alice is {age['Alice']} years old")
# Alice is 20 years old Défi 2 :Mais que se passe-t-il si vous voulez mettre à jour uniquement si la clé n'existait pas auparavant. En d'autres termes, vous ne souhaitez pas écraser un mappage existant ?
Solution :Dans ce cas, vous pouvez utiliser le check if key dans dict pour différencier les deux cas :
age = {'Alice': 19, 'Bob': 23, 'Frank': 53}
print(f"Alice is {age['Alice']} years old")
# Alice is 19 years old
# Alice's Birthday
if 'Alice' not in age:
age['Alice'] = 20
print(f"Alice is {age['Alice']} years old")
# Alice is 19 years old Maintenant, vous voudrez peut-être écrire ceci dans une seule ligne de code. Vous pouvez le faire de manière naïve :
if 'Alice' not in age: age['Alice'] = 20
Une meilleure alternative est la méthode dictionary.setdefault() :
setdefault(key[, default]) — Si key est dans le dictionnaire, renvoie sa valeur. Sinon, insérez key avec une valeur de default et renvoie default . default par défaut à None .
Vous pouvez simplement ignorer la valeur de retour pour mettre à jour une clé dans un dictionnaire si elle n'est pas déjà présente.
age = {'Alice': 19, 'Bob': 23, 'Frank': 53}
print(f"Alice is {age['Alice']} years old")
# Alice is 19 years old
# Alice's Birthday
age.setdefault('Alice', 20)
print(f"Alice is {age['Alice']} years old")
# Alice is 19 years old
Le age.setdefault('Alice', 20) insère uniquement la clé 'Alice' s'il n'est pas déjà présent (auquel cas il lui associerait la valeur 20). Mais comme elle existe déjà, la commande n'a aucun effet secondaire et la nouvelle valeur n'écrase pas l'ancienne.
