Union d'objets dict en Python

Question

Comment calculez-vous l'union de deux dict en Python, où un (key, value) est présent dans le résultat si key es in l'une ou l'autre dictée (à moins qu'il n'y ait des doublons) ?

Par exemple, l'union de {'a' : 0, 'b' : 1} y {'c' : 2} es {'a' : 0, 'b' : 1, 'c' : 2} .

De préférence, vous pouvez le faire sans modifier l'une ou l'autre des entrées. dict . Exemple de cas où cela est utile : Obtenez un dictum de toutes les variables actuellement dans le champ d'application et leurs valeurs.

Answer 1

Cette question fournit un idiome. Vous utilisez l'une des dicts comme argument de mot-clé à la fonction dict() constructeur :

dict(y, **x)

Les doublons sont résolus en faveur de la valeur en x ; par exemple

dict({'a' : 'y[a]'}, **{'a', 'x[a]'}) == {'a' : 'x[a]'}

Answer 2

Vous pouvez également utiliser update méthode de dictée comme

a = {'a' : 0, 'b' : 1}
b = {'c' : 2}

a.update(b)
print a

Answer 3

Pour un dictionnaire statique, combinaison d'instantanés d'autres dicts :

À partir de Python 3.9, l'opérateur binaire "ou". | a été défini pour concaténer les dictionnaires. (Un nouveau dictionnaire concret est créé avec empressement) :

>>> a = {"a":1}
>>> b = {"b":2}
>>> a|b
{'a': 1, 'b': 2}

À l'inverse, le |= L'affectation augmentée a été implémentée pour signifier la même chose que l'appel de la fonction update méthode :

>>> a = {"a":1}
>>> a |= {"b": 2}
>>> a
{'a': 1, 'b': 2}

Pour plus de détails, consultez PEP-584

Avant Python 3.9, la manière la plus simple de créer un nouveau dictionnaire est de créer un nouveau dictionnaire en utilisant "l'expansion en étoile" pour ajouter le contenu de chaque sous-annexe à la place :

c = {**a, **b}

Pour la combinaison dynamique de dictionnaires, en travaillant comme "vue" à des dicts combinés et vivants :

Si vous avez besoin que les deux dictionnaires restent indépendants et qu'ils puissent être mis à jour, vous pouvez créer un objet unique qui interroge les deux dictionnaires dans sa fonction de recherche. __getitem__ (et mettre en œuvre la méthode get , __contains__ et d'autres méthodes de cartographie selon vos besoins).

Un exemple minimaliste pourrait être le suivant :

class UDict(object):
   def __init__(self, d1, d2):
       self.d1, self.d2 = d1, d2
   def __getitem__(self, item):
       if item in self.d1:
           return self.d1[item]
       return self.d2[item]

Et ça marche :

>>> a = UDict({1:1}, {2:2})
>>> a[2]
2
>>> a[1]
1
>>> a[3]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 7, in __getitem__
KeyError: 3
>>> 

NB : Si l'on veut maintenir paresseusement une "vue" de l'Union de deux ou plusieurs dictionnaires, vérifiez collections.ChainMap dans la bibliothèque standard - car elle possède toutes les méthodes du dictionnaire et couvre les cas particuliers qui ne sont pas couverts par la bibliothèque. pas envisagés dans l'exemple ci-dessus.

Answer 4

Deux dictionnaires

def union2(dict1, dict2):
    return dict(list(dict1.items()) + list(dict2.items()))

n dictionnaires

def union(*dicts):
    return dict(itertools.chain.from_iterable(dct.items() for dct in dicts))