Problème : Étant donné un dictionnaire en Python ; comment changer les clés et les valeurs ?
- Méthode 1 :Utilisation d'un
forboucle - Méthode 2 :Utilisation du
zipfonction - Méthode 3 :Utilisation du
mapetreversefonctions - Méthode 4 :Utiliser une compréhension de dictionnaire
Résumé : Utilisez l'une des méthodes suivantes pour basculer entre les clés et les valeurs dans un dictionnaire avec des valeurs uniques.
Imaginez-vous le matin, sur votre bureau, avec votre café et votre ordinateur portable devant vous. Vous vous sentez détendu, à l'aise, sûr de vous et prêt pour une autre journée incroyable en faisant ce que vous aimez le plus. Pour résoudre des problèmes avec votre cerveau et vos doigts en utilisant le potentiel que Python vous offre !
Ensuite, votre patron arrive et vous regarde dans les yeux, il dit :« Écoutez, nous avons un problème et j'ai besoin que vous le régliez. Vous avez 1 heure pour me donner une solution que nous pouvons répliquer pour tous les dossiers que nous avons dans l'entreprise ou nous sommes tous licenciés"
Votre patron est une personne sympathique. Il vous donne cet exemple pour commencer :
# Input ? {'a': 1, 'b': 2, 'c': 3, 'd': 4} # Output ? {1: 'a', 2: 'b', 3: 'c', 4: 'd'} Dans cet article, nous allons vous montrer quatre méthodes pour y parvenir. La plus Pythonique est la Méthode 4 — donc, si vous manquez de temps, passez à la Méthode 4 tout de suite !
Contexte
Si vous êtes un développeur Python expérimenté, vous avez probablement une base solide de toutes sortes de structures de données. Si c'est le cas, passez à la Méthode 1 . En revanche, si vous êtes nouveau sur ce sujet ou que vous souhaitez rafraîchir ce type de données, je vous invite à lire ces lignes ci-dessous. En tant que développeur Python, il est important d'acquérir des connaissances et de construire une base solide dans les structures de données.
Dans cet article, nous allons parler de la façon de rétablir l'une des structures les plus utiles que tout développeur Python doit maîtriser, c'est le dictionnaire .
Mais c'est quoi un dictionnaire ?
Un dictionnaire est une structure de données formée par un ensemble de clé :valeur paires.
La syntaxe est :
{'key1': 'value1', 'key2': 'value2', 'key3': 'value3',} Il peut également être représenté comme ceci pour faciliter la lecture :
{
'key1': 'value1',
'key2': 'value2',
'key3': 'value3',
}
Remarque :La dernière virgule après value3 ce n'est pas nécessaire, en effet. Mais je vous recommande de prendre cette habitude et de toujours l'écrire. Cela vous fera gagner du temps en évitant les bugs indésirables dans votre futur code propre 🙂 .
La clé peut être de n'importe quel type, mais ce qu'il est important de souligner ici, c'est que :
- La clé doit être Unique dans tout le dictionnaire. Sinon, la dernière clé dupliquée remplacera la précédente définie
Exemple de dictionnaire avec un entier comme clé :
{1: 100, 2: 200} Exemple de dictionnaire avec un flottant comme clé :
{1.0: 100, 2.3: 200} Exemple de dictionnaire avec string comme clé :
{'a': 100, 'b': 200} Exemple de dictionnaire avec un tuple comme clé :
{(0, 0): 100, (1, 1): 200}
#or
{('Harry','Potter') : 100, ('Hermione','Granger') : 200}
Remarque :Bien que vous puissiez utiliser un flottant comme clé, ce n'est pas très recommandé car si vous définissez 1.0 et 1, la dernière clé remplacera la première clé.
Voici un exemple :
{ 1.0: 100, 1: 200} ? {1.0: 200} - Il doit être immuable . Cela signifie que la clé peut être un entier, un flottant, un booléen, une chaîne ou même un tuple parmi d'autres, mais jamais une liste ou un autre dictionnaire car ces structures de données sont modifiables (si vous avez besoin d'approfondir ce concept, je suggère vous avez lu cet article sur les objets mutables ou immuables).
Méthode 1 :Utilisation d'une approche de boucle for
La solution la plus simple et la plus typique que tout développeur peut découvrir au début serait d'utiliser la structure "for loop" pour effectuer une itération définie pour accomplir la tâche.
La boucle python for est représentée par une variable, un itérable et quelques instructions.
La syntaxe est :
for <var> in <iterable>:
<statement(s)>
Connaissant cette structure, nous pourrions avoir une première approche valable de la solution :
my_dict = {'a': 1, 'c': 3, 'b': 2, 'd': 4}
new_dict = {}
for k, v in my_dict.items():
new_dict[v] = k
Sortie :
{1: 'a', 2: 'b', 3: 'c', 4: 'd'} Explication :
- Dans le code ci-dessus, nous devons créer une nouvelle instance d'un dictionnaire en utilisant l'expression
{}et l'a assigné à une nouvelle variable appeléenew_dict.
new_dict = {} - Ensuite, nous utilisons la "boucle for" pour itérer les clés et les valeurs du dictionnaire.
k,vsont les variables. La clé et les valeursmy_dictest la structure de données itérable qui peut être un dictionnaire, une liste ou un tuple. Dans ce cas, nous devons ajouter la méthode .items() qui renvoie une liste de paires de tuples (clé, valeur).my_dict.itemsrenvoie :
dict_items([('a', 1), ('b', 2), ('c', 3)]) new_dict[v] = kest la déclaration où nous changeons les valeurs du dictionnaire.
Méthode 2 :Utilisation de la fonction zip
Une autre solution possible serait d'utiliser le zip fonction.
La syntaxe est :
zip(*iterables)
Mais comment ça marche ?
Eh bien, le zip La fonction renvoie un objet créé à partir de certains itérateurs donnés en paramètres. Ces itérateurs peuvent être des listes, mais ils doivent avoir le même nombre d'éléments chacun. Cela permet d'assurer la bonne jonction entre les éléments. Ici vous pouvez voir un exemple :
#iterable 1 = ['one', 'two', 'three']
#iterable = [1, 2, 3]
zip(['one', 'two', 'three'], [1, 2, 3])
#result: [('one', 1), ('two', 2), ('three', 3)]
Donc, à ce stade, la solution pour la seconde méthode serait :
my_dict = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
dict(zip(my_map.values(), my_map.keys()))
Sortie :
{1: 'a', 2: 'b', 3: 'c', 4: 'd'} Explication :
L'idée derrière cette solution est de fournir à la fonction zip 2 itérables, en fait 2 listes, dans ce cas, pour créer une liste unique de tuples. L'astuce ici est d'utiliser les clés comme valeurs et vice versa en utilisant la forme my_dict.values() pour obtenir les valeurs et my_dict.keys() pour obtenir les clés dans deux listes séparées.
my_dict = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
my_dict.values()
# [1, 2, 3, 4]
my_dict.keys()
# ['a', 'c', 'c', 'd'] - Une fois cette opération accomplie, si nous utilisons la fonction zip, nous aurons :
zip(my_map.values(), my_map.keys()) # [(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]
- À ce stade, il nous suffit de créer un dictionnaire en utilisant le constructeur de type
dict()et obtenir le résultat que nous recherchions :
dict(zip(my_map.values(), my_map.keys()))
Méthode 3 :Utilisation des fonctions carte et inverse
La troisième solution à laquelle vous pouvez penser est d'utiliser le map et reverse fonction avec le constructeur dict() .
Mais comment ça marche et comment utilise-t-on exactement ces deux fonctions ? Examinons-les tous les deux pour le comprendre.
Fonction inversée :
La fonction reverse a la propriété de retourner un itérateur dans l'ordre inverse d'une séquence donnée. Il est important de marquer que reversed() accepte simplement les séquences et aucun autre type d'itérateur. Donc, au cas où vous voudriez inverser un itérateur, vous devriez envisager de le transformer auparavant en liste.
La syntaxe est :
reversed(seq)
Exemples :
séquence de chaînes :
seq = 'retxnif' reversed(seq) # <reversed object at 0x0000000002A41AC8> list(reversed(seq)) # ['f', 'i', 'n', 'x', 't', 'e', 'r']
séquence de liste :
seq = ['r', 'e', 't', 'x', 'n', 'i', 'f'] reversed(seq) # <listreverseiterator object at 0x0000000002A41AC8> list(reversed(seq)) # ['f', 'i', 'n', 'x', 't', 'e', 'r']
séquence de tuple :
seq = ('r', 'e', 't', 'x', 'n', 'i', 'f')
reversed(seq)
# <reversed object at 0x0000000002AB2C48>
list(reversed(seq))
# ['f', 'i', 'n', 'x', 't', 'e', 'r'] séquence de plage
seq = range(5) # [0, 1, 2, 3, 4] reversed(seq) # <listreverseiterator object at 0x0000000002A41AC8> list(reversed(seq)) # [4, 3, 2, 1, 0]
Probablement si vous avez lu le Coffee Break Python Slicing de Chris, vous remarquerez que le dernier cas pourrait être atteint par range(5)[::-1] . Cependant, il semble d'après la documentation que reversed(seq) est plus rapide et utilise moins de mémoire. Alors gardez-le à l'esprit.
Fonction de carte
Pour comprendre la fonction de la carte, nous devons d'abord comprendre ce que signifie la cartographie. Lorsque nous utilisons la carte, nous cherchons à produire un nouvel itérable à partir de l'original en appliquant une fonction de transformation à chaque élément de celui-ci.
En d'autres termes, est un moyen de traiter les itérables sans avoir besoin d'une boucle.
La syntaxe est :
map(function, iterable, ...)
function:est la fonction qui sera appliquée à chaque élément de l'itérableiterable:est le paramètre qui va être mappé. Il peut s'agir d'une liste, d'un tuple, etc.
Exemple :
#transform all the items of a string to a integer iterable_str = ['1','2','3','4','5'] map(int,iterable_str) # [1, 2, 3, 4, 5]
#transform all the items of a string to a float iterable_str = ['1.0','2.0','3.0','4.0','5.0'] map(float,iterable_str) # [1.0, 2.0, 3.0, 4.0, 5.0]
#transform all the items of a string by applying strings methods like capitalize iterable_str =['finxter','is','an','endless','source','of','knowledge'] list(map(str.capitalize, iterable_str)) # ['Finxter', 'Is', 'An', 'Endless', 'Source', 'Of', 'Knowledge']
Alors maintenant que nous connaissons la théorie derrière ces deux fonctions, nous pourrions conclure qu'une solution acceptable en les joignant serait celle-ci :
my_dict = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
dict(map(reversed, my_dict.items())
# {1: 'a', 2: 'b', 3: 'c', 4: 'd'}
À ce stade, vous pourriez raisonnablement penser que finalement, vous avez la bonne solution et la plus pythonique, n'est-ce pas ? Eh bien, non… alors voici le 4 ème méthode pour vous fournir plus de connaissances. Alors, continuez à lire !
Méthode 4 :Utiliser une compréhension de dictionnaire
Bien que des outils de programmation fonctionnels comme map() ont été très utiles dans le passé en tant que composants fondamentaux de python depuis plus de 20 ans, il existe aujourd'hui d'autres formes qui deviennent de plus en plus populaires parmi les développeurs Python comme la compréhension de liste ou la compréhension de dictionnaire.
Comment fonctionnent-ils ?
Eh bien, une compréhension de dictionnaire est un moyen rapide et concis de créer un dictionnaire en un nouveau en appliquant une opération de transformation pour chacun de ses membres si nécessaire. Comme vous l'avez peut-être remarqué ici, nous nous concentrons sur la compréhension du dictionnaire, cependant, si vous êtes intéressé par la compréhension de la liste, je vous suggère de lire cet excellent article également dans Finxter.
La syntaxe est :
Compréhension du dictionnaire
{ expression + context } Exemple :
my_dict = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
pow3_my_dict = {k:v**3 for (k,v) in my_dict.items()}
# {'a': 1, 'c': 27, 'b': 8, 'd': 64}
Explication :
- Expression :
k:v**3? il indique à python quoi faire avec les valeurs du dictionnaire. Dans ce cas, nous appliquons la troisième puissance. C'est 1 ^3 , 2 ^3 , 3 ^3 , 4 ^3
- Contexte :
for (k,v) in my_dict.items()? il indique quels éléments du dictionnaire vont être transformés. Dans ce cas, tous. Le contexte est un nombre arbitraire de for et if.
Exemple avec une instruction IF :
pow3_my_dict = {k:v**3 for (k,v) in my_dict.items() if v < 3}
# {'a': 1, 'b': 8} Comme vous pouvez le voir, il crée un nouveau dictionnaire avec les valeurs où l'instruction IF est vraie.
Cela dit, vous pourriez vous demander :"Puis-je créer un dictionnaire en utilisant la compréhension du dictionnaire sans avoir de dictionnaire précédent ?" Bien que cela soit un peu éloigné du sujet sur lequel nous nous concentrons, la réponse est oui . Nous pourrions créer un nouveau dictionnaire où le contexte est un itérable mais pas nécessairement un dictionnaire. Nous pourrions utiliser la fonction range pour générer les itérables ou même utiliser une liste donnée. Voyons quelques exemples :
Fonction de plage :
{num: num*num for num in range(1, 4)}
# {1: 1, 2: 4, 3: 9} Liste :
Imaginez que vous ayez une liste de clients dont certains ont été introduits dans le système avec des majuscules, des minuscules ou des majuscules. Et votre travail consiste à les transformer en un dictionnaire en minuscules et à transmettre à nouveau les résultats au système. Cela pourrait être une solution valable :
customer_list = ['[email protected]', '[email protected]', '[email protected]']
print({x.lower() : 1 for x in customer_list})
# {'[email protected]': 1, '[email protected]': 1, '[email protected]': 1}
Donc, en revenant de cette parenthèse, la solution pour inverser un dictionnaire en utilisant la compréhension du dictionnaire serait :
my_dict = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
{v: k for k,v in my_dict.items()}
# {1: 'a', 2: 'b', 3: 'c', 4: 'd'}
Explication :
La transformation ici consiste à changer l'ordre du key:value paires pour avoir un value:key paires. Donc, ce que nous disons à Python est :"Appliquez cette transformation v,k (modifier l'ordre) pour chaque article (k,v) dans le dictionnaire donné".
- Expression :
v:k - Contexte :
for k,v in my_dict.items()
Conclusion
Dans cet article, nous avons appris à inverser le key:value paires d'un dictionnaire utilisant :
- La structure
forboucle - Le
zipfonction - Le
map()etreversed()fonction, comment les combiner et qu'est-ce qu'un itérable. - La compréhension du dictionnaire et les parties qui y sont représentées par l'expression et le contexte
Pour expliquer cela, nous avons exploré ce qu'est un dictionnaire. Quelles sont leurs propriétés telles que l'immuabilité et l'unicité de la clé. Nous avons également couvert ce qui se passe si nous répétons une clé avec une valeur différente ou au contraire nous utilisons un nombre deux fois comme clé bien que l'un soit de type flottant et l'autre de type entier.
Enfin, nous avons découvert que la compréhension du dictionnaire devient plus populaire que des fonctions comme map() car, si vous n'en abusez pas, cela vous aide à raccourcir le nombre de lignes de votre code en le rendant plus propre, facile à comprendre, élégant et plus Pythonique. Si vous souhaitez approfondir cette question, veuillez lire cet excellent article sur la compréhension du dictionnaire.
