Résumé :Pour fusionner deux dictionnaires dict1 et dict2 dans une seule expression, utilisez la fonctionnalité de décompression du dictionnaire z = {**dict1, **dict2} . Cela crée un nouveau dictionnaire et décompresse toutes les paires (clé-valeur) dans le nouveau dictionnaire. Les clés en double sont automatiquement résolues par cette méthode.
dict1 = {'value1': 100, 'value': 200}
dict2 = {'value': 300, 'value2': 400}
print("dict1: ", dict1)
print("dict2: ", dict2)
z = {**dict1, **dict2}
print("MERGED DICTIONARY: ", z) Exercice :Laquelle des entrées dupliquées se retrouve dans le dictionnaire ?
D'autres méthodes pour fusionner des dictionnaires incluent :
- Déballage du dictionnaire avec
** - Utiliser un lambda fonction.
- Utiliser une compréhension du dictionnaire .
- Utiliser
ChainMapconteneur. - Utiliser | opérateur.
- Convertir en listes et concaténer sur une seule ligne.
- Utiliser
itertools.chain() - Utiliser une fonction personnalisée .
La maîtrise des dictionnaires est l'une des choses qui différencie les codeurs experts des codeurs intermédiaires. Pourquoi? Parce que les dictionnaires en Python ont de nombreuses excellentes propriétés en termes d'exécution et qu'ils sont très faciles à utiliser et à comprendre. Vous ne pouvez pas écrire de code efficace en Python sans tirer parti de cette puissante structure de données. Alors, plongeons-nous dans la question essentielle :
Problème : Étant donné deux dictionnaires ; comment fusionner les deux dictionnaires en utilisant une seule expression ?
Considérez l'extrait suivant comme référence :
dict1 = {'value1': 100, 'value': 200}
dict2 = {'value': 300, 'value2': 400}
dict1.update(dict2)
print(dict1) Sortie :
dict1: {'value1': 100, 'value': 200 , 'value': 400}
Ici, la sortie est la solution souhaitée que nous voulons, cependant, l'instruction de mise à jour modifie le contenu de dict1 ce qui n'est pas ce que nous voulons. Le but du code est de trouver une solution qui trouvera l'union des deux dictionnaires sans modifier le contenu des dictionnaires originaux. De plus, le dictionnaire résultant doit avoir des valeurs telles que les valeurs communes de dict2 remplacer le contenu de dict1 comme le montre l'exemple ci-dessus.
Maintenant que nous avons une vue d'ensemble de notre problème, plongeons-nous dans les solutions probables pour notre énoncé de problème.
Méthode 1 :Utilisation de **kwargs
Dans Python 3.5 et versions ultérieures, nous pouvons utiliser la syntaxe d'argument de mot-clé (**kwargs) pour obtenir notre sortie en une seule expression. Utilisation du double astérisque ** nous pouvons passer tous les éléments des deux dictionnaires et les stocker dans un troisième dictionnaire sans altérer les éléments des dictionnaires d'origine (dict1 et dict2 dans notre cas).
Le code ci-dessous explique le concept ci-dessus (veuillez suivre les commentaires pour une meilleure prise en main du code) :
dict1 = {'value1': 100, 'value': 200}
dict2 = {'value': 300, 'value2': 400}
print("dict1: ", dict1)
print("dict2: ", dict2)
z = {**dict1, **dict2} # using ** syntax to pass and store contents of dict1 and dict2 in z
print("MERGED DICTIONARY: ", z) Sortie :
dict1: {'value1': 100, 'value': 200}
dict2: {'value': 300, 'value2': 400}
MERGED DICTIONARY: {'value1': 100, 'value': 300, 'value2': 400}
Ici, nous pouvons également utiliser z=dict(dict2, **dict1) au lieu d'utiliser z = {**dict1, **dict2} qui donnera le même résultat. Essayez-le vous-même pour vous en emparer !
Méthode 2 :Utilisation d'une fonction Lambda
Puisqu'une fonction lambda ne peut avoir qu'une seule expression, l'utilisation d'une fonction lambda peut donc être une très bonne solution de contournement pour notre problème.
Regardons le code suivant qui utilise une fonction lambda pour fusionner deux tableaux (Veuillez suivre les commentaires pour une meilleure prise en main du code) :
dict1 = {'value1': 100, 'value': 200}
dict2 = {'value': 300, 'value2': 400}
print("dict1: ", dict1)
print("dict2: ", dict2)
"""lambda function that accepts and copies dict1 in l,
then updates l by merging it with dict1 and
finally returning the value of l """
merge = (lambda l=dict1.copy(): (l.update(dict2), l)[1])()
print("MERGED DICTIONARY: ", merge) Sortie :
dict1: {'value1': 100, 'value': 200}
dict2: {'value': 300, 'value2': 400}
MERGED DICTIONARY: {'value1': 100, 'value': 300, 'value2': 400} Méthode 3 :Utilisation de ChainMap conteneur
Python 3 a une ChainMap conteneur utilisé pour encapsuler deux ou plusieurs dictionnaires dans un seul dictionnaire. Ainsi, nous pouvons utiliser ChainMap pour fusionner nos dictionnaires comme indiqué dans le code suivant :
from collections import ChainMap
dict1 = {'value1': 100, 'value': 200}
dict2 = {'value': 300, 'value2': 400}
merge = dict(ChainMap({}, dict2, dict1))
print("dict1: ", dict1)
print("dict2: ", dict2)
print("MERGED DICTIONARY: ", merge) Sortie :
dict1: {'value1': 100, 'value': 200}
dict2: {'value': 300, 'value2': 400}
MERGED DICTIONARY: {'value1': 100, 'value': 300, 'value2': 400} Méthode 4 :Définir une fonction pour renvoyer le dictionnaire fusionné
**kwargs a été défini dans la documentation Python 3.5 et n'a pas été implémenté dans les versions précédentes. Cependant, de nombreuses organisations exécutent toujours leur code sur des versions plus anciennes de Python. Par conséquent, la solution de contournement dans de telles situations consiste à créer une fonction et à utiliser le update() et copy() méthodes, puis retournez la sortie.
Examinons le code ci-dessous pour comprendre le concept ci-dessus.
(Merci de suivre les commentaires pour une meilleure prise en main du code) :
dict1 = {'value1': 100, 'value': 200}
dict2 = {'value': 300, 'value2': 400}
print("dict1: ", dict1)
print("dict2: ", dict2)
def combine_dicts(a, b):
merge = a.copy() # Returning a shallow copy of the list dict1, that is copying contents of dict1 in merge
merge.update(b) # merging contents dictionary merge and dict2
return merge # returning the merged dictionary
z = combine_dicts(dict1, dict2) # calling function using a single expression
print("MERGED DICTIONARY: ", z) Sortie :
dict1: {'value1': 100, 'value': 200}
dict2: {'value': 300, 'value2': 400}
MERGED DICTIONARY: {'value1': 100, 'value': 300, 'value2': 400} Méthode 5 :Utiliser une compréhension du dictionnaire
Les compréhensions de dictionnaire peuvent être extrêmement utiles lorsqu'il s'agit de Python one-liners bien qu'elles puissent devenir un peu complexes à comprendre lorsque l'expression devient longue comme dans ce cas. Néanmoins, cette méthode doit absolument être mentionnée dans la liste de notre solution proposée car elle fonctionne parfaitement dans notre cas.
Examinons le code suivant pour comprendre comment nous pouvons utiliser une compréhension de dictionnaire pour fusionner deux dictionnaires en une seule ligne :
dict1 = {'value1': 100, 'value': 200}
dict2 = {'value': 300, 'value2': 400}
result = {key:value for d in [dict1,dict2] for key,value in d.items()}
print(result) Sortie :
{'value1': 100, 'value': 300, 'value2': 400} Méthode 6 :Convertir en liste et concaténer
Une autre approche qui fonctionne réellement et nous aide à fusionner deux dictionnaires en une seule expression consiste à obtenir une liste d'éléments de chaque dictionnaire, puis à les concaténer.
Jetons un coup d'œil au programme suivant qui explique le concept ci-dessus. (Avis de non-responsabilité :cela fonctionne pour Python 3 et versions ultérieures.)
dict1 = {'value1': 100, 'value': 200}
dict2 = {'value': 300, 'value2': 400}
result = dict(list(dict1.items()) + list(dict2.items()))
print(result) Sortie :
{'value1': 100, 'value': 300, 'value2': 400} Méthode 7 :Utilisation de itertools.chain
chain() est une méthode dans le itertools module qui accepte une série d'itérables, puis renvoie un seul itérable. La sortie générée qui est un itérable unique ne peut pas être utilisée directement et doit être explicitement convertie. Cette méthode nous permet d'éviter de créer des listes supplémentaires comme dans la méthode 6; c'est donc plus efficace.
Voyons le code suivant qui nous simplifie les choses :
from itertools import chain
dict1 = {'value1': 100, 'value': 200}
dict2 = {'value': 300, 'value2': 400}
result = dict(chain(dict1.items(),dict2.items()))
print(result) Sortie :
{'value1': 100, 'value': 300, 'value2': 400} Méthode 8 :Utilisation de | opérateur
Dans la prochaine version de Python, qui est Python 3.9, la fusion de dictionnaires en Python peut être effectuée à l'aide d'un simple opérateur d'union de dictionnaire. Jetons un coup d'œil au prochain opérateur Python qui fusionnera deux dictionnaires dans le code suivant :
Avis de non-responsabilité :le code ne fonctionnera que dans Python3.9 ou versions ultérieures .
dict1 = {'value1': 100, 'value': 200}
dict2 = {'value': 300, 'value2': 400}
merge = dict1 | dict2
print("dict1: ", dict1)
print("dict2: ", dict2)
print("MERGED DICTIONARY: ", merge) Sortie :
dict1: {'value1': 100, 'value': 200}
dict2: {'value': 300, 'value2': 400}
MERGED DICTIONARY: {'value1': 100, 'value': 300, 'value2': 400} Avant de conclure, voici une petite pratique de codage pour vous. Pouvez-vous deviner la sortie du code suivant ?
import collections
dict1 = {'value1': 100, 'value': 200}
dict2 = {'value': 300, 'value2': 400}
merge = collections.ChainMap(dict1, dict2).maps
print("MERGED DICTIONARY: ", merge) Conclusion
Dans cet article, nous avons appris les méthodes suivantes pour fusionner deux dictionnaires en une seule expression :
- Déballage du dictionnaire avec
** - Utilisation de la fonction Lambda.
- Utiliser
ChainMapconteneur. - Utiliser une fonction personnalisée.
- Utiliser la compréhension du dictionnaire.
- Convertir en éléments de liste et concaténer.
- Utiliser
itertools.chain() - Utiliser
|opérateur.
J'espère que vous avez trouvé cet article utile et qu'il vous aide à fusionner facilement deux dictionnaires ! Veuillez vous abonner et rester à l'écoute pour des articles plus intéressants à l'avenir.
