Dans votre cas, ce que vous pouvez faire est:

z = dict(x.items() + y.items())

cela mettra, comme vous le voulez , le dict final dans z , et fera la valeur pour la touche b être correctement dépassé par la seconde ( y ) valeur de dict:

>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> z = dict(x.items() + y.items())
>>> z
{'a': 1, 'c': 11, 'b': 10}

si vous utilisez Python 3, c'est seulement un peu plus compliqué. Pour créer z :

>>> z = dict(list(x.items()) + list(y.items()))
>>> z
{'a': 1, 'c': 11, 'b': 10}

une alternative:

z = x.copy()
z.update(y)

une autre option, plus concise:

z = dict(x, **y)

Note : ceci est devenu une réponse populaire, mais il est important de souligner que si y a des clés non-string, le fait que cela fonctionne du tout est un abus d'un détail d'implémentation de CPython, et cela ne fonctionne pas en Python 3, ou en PyPy, IronPython, ou Jython. Aussi, Guido N'est pas un ventilateur . Je ne peux donc pas recommander cette technique pour cross-implementation portable code, ce qui signifie vraiment qu'il doit être évité entièrement.

ce ne sera probablement pas une réponse populaire, mais vous ne voulez presque certainement pas faire cela. Si vous voulez une copie qui est une fusion, puis utiliser la copie (ou deepcopy , selon ce que vous voulez) et puis mettre à jour. Les deux lignes de code sont beaucoup plus lisibles - plus Pythoniques - que la création d'une seule ligne .article. + )(article.)( Explicite est mieux qu'implicites.

En outre, lorsque vous utilisez .items () (pré Python 3.0), vous créez un nouveau liste qui contient les éléments du dict. Si vos dictionnaires sont grands, c'est beaucoup de frais généraux (deux grandes listes qui seront jetées dès que le dict fusionné sera créé). update () peut fonctionner de manière plus efficace, car il peut être exécuté à travers le second élément de dict-by-item.

En termes de temps :

>>> timeit.Timer("dict(x, **y)", "x = dict(zip(range(1000), range(1000)))\ny=dict(zip(range(1000,2000), range(1000,2000)))").timeit(100000)
15.52571702003479
>>> timeit.Timer("temp = x.copy()\ntemp.update(y)", "x = dict(zip(range(1000), range(1000)))\ny=dict(zip(range(1000,2000), range(1000,2000)))").timeit(100000)
15.694622993469238
>>> timeit.Timer("dict(x.items() + y.items())", "x = dict(zip(range(1000), range(1000)))\ny=dict(zip(range(1000,2000), range(1000,2000)))").timeit(100000)
41.484580039978027

IMO le léger ralentissement entre les deux premiers vaut la peine pour la lisibilité. Outre, les arguments de mots-clés pour la création de dictionnaires n'ont été ajoutés que dans Python 2.3, alors que copy() et update() fonctionneront dans les versions plus anciennes.

dans une réponse de suivi, vous avez posé des questions sur la performance relative de ces deux alternatives:

z1 = dict(x.items() + y.items())
z2 = dict(x, **y)

sur ma machine, au moins (un x86_64 assez ordinaire en Python 2.5.2), l'alternative z2 est non seulement plus courte et plus simple, mais aussi beaucoup plus rapide. Vous pouvez le vérifier vous-même en utilisant le module timeit fourni avec Python.

exemple 1: dictionnaires identiques cartographiant 20 entiers consécutifs pour eux-mêmes:

% python -m timeit -s 'x=y=dict((i,i) for i in range(20))' 'z1=dict(x.items() + y.items())'
100000 loops, best of 3: 5.67 usec per loop
% python -m timeit -s 'x=y=dict((i,i) for i in range(20))' 'z2=dict(x, **y)' 
100000 loops, best of 3: 1.53 usec per loop

z2 gagne par un facteur de 3,5 ou. Des dictionnaires différents semblent donner des résultats tout à fait différents, mais z2 semble toujours arriver en tête. (Si vous obtenez des résultats incohérents pour le même test, essayer de passer dans -r avec un nombre plus grand que la valeur par défaut 3.)

exemple 2: dictionnaires ne se chevauchant pas mapping 252 short strings to integer et vice versa:

% python -m timeit -s 'from htmlentitydefs import codepoint2name as x, name2codepoint as y' 'z1=dict(x.items() + y.items())'
1000 loops, best of 3: 260 usec per loop
% python -m timeit -s 'from htmlentitydefs import codepoint2name as x, name2codepoint as y' 'z2=dict(x, **y)'               
10000 loops, best of 3: 26.9 usec per loop

z2 gagne par un facteur d'environ 10. C'est une assez grande victoire, dans mon livre!

après avoir comparé ces deux-là, je me suis demandé si la mauvaise performance de z1 pourrait être attribuée à la surcharge de construire les deux listes d'Articles, ce qui à son tour m'a conduit à me demander si cette variation pourrait mieux fonctionner:

from itertools import chain
z3 = dict(chain(x.iteritems(), y.iteritems()))

quelques essais rapides, p.ex.

% python -m timeit -s 'from itertools import chain; from htmlentitydefs import codepoint2name as x, name2codepoint as y' 'z3=dict(chain(x.iteritems(), y.iteritems()))'
10000 loops, best of 3: 66 usec per loop

conduisez-moi à conclure que z3 est un peu plus rapide que z1 , mais pas aussi rapide que z2 . Certainement pas la peine tout le taper.

cette discussion manque toujours quelque chose d'important, qui est une comparaison de performance de ces alternatives avec la manière" évidente "de fusionner deux listes: en utilisant la méthode update . Pour essayer de garder les choses sur un pied d'égalité avec les expressions, aucune de modifier x ou y, je vais faire une copie de x au lieu de le modifier en place, comme suit:

z0 = dict(x)
z0.update(y)

un résultat typique:

% python -m timeit -s 'from htmlentitydefs import codepoint2name as x, name2codepoint as y' 'z0=dict(x); z0.update(y)'
10000 loops, best of 3: 26.9 usec per loop

en d'autres termes, z0 et z2 semblent avoir des performances essentiellement identiques. Pensez-vous que cela pourrait être une coïncidence? Je n'ai pas....

En fait, j'irais même jusqu'à prétendre qu'il est impossible pour un pur code Python pour faire mieux que cela. Et si vous pouvez faire beaucoup mieux dans une extension C module, j'imagine que les gens de Python pourraient bien être intéressés à incorporer votre code (ou une variation sur votre approche) dans le noyau Python. Python utilise dict dans beaucoup d'endroits; optimiser ses opérations est important.

vous pouvez aussi écrire ceci comme

z0 = x.copy()
z0.update(y)

que Tony n', mais (sans surprise) la différence de notation s'avère n'avoir aucun effet mesurable sur la performance. Utilisation selon la regarde droit pour vous. De bien sûr, il a tout à fait raison de souligner que la version à deux énoncés est beaucoup plus facile à comprendre.

je voulais quelque chose de similaire, mais avec la possibilité de spécifier comment les valeurs sur les clés dupliquées ont été fusionnées, donc je l'ai hacké (mais je ne l'ai pas testé lourdement). Évidemment, ce n'est pas une simple expression, mais c'est un seul appel de fonction.

def merge(d1, d2, merge_fn=lambda x,y:y):
    """
    Merges two dictionaries, non-destructively, combining 
    values on duplicate keys as defined by the optional merge
    function.  The default behavior replaces the values in d1
    with corresponding values in d2.  (There is no other generally
    applicable merge strategy, but often you'll have homogeneous 
    types in your dicts, so specifying a merge technique can be 
    valuable.)

    Examples:

    >>> d1
    {'a': 1, 'c': 3, 'b': 2}
    >>> merge(d1, d1)
    {'a': 1, 'c': 3, 'b': 2}
    >>> merge(d1, d1, lambda x,y: x+y)
    {'a': 2, 'c': 6, 'b': 4}

    """
    result = dict(d1)
    for k,v in d2.iteritems():
        if k in result:
            result[k] = merge_fn(result[k], v)
        else:
            result[k] = v
    return result

en Python 3, vous pouvez utiliser collections.ChainMap qui regroupe plusieurs dicts ou d'autres mappages pour créer une vue unique, pouvant être mise à jour:

>>> from collections import ChainMap
>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> z = ChainMap({}, y, x)
>>> for k, v in z.items():
        print(k, '-->', v)

a --> 1
b --> 10
c --> 11

Récursivement/deep mise à jour d'un dict

def deepupdate(original, update):
    """
    Recursively update a dict.
    Subdict's won't be overwritten but also updated.
    """
    for key, value in original.iteritems(): 
        if key not in update:
            update[key] = value
        elif isinstance(value, dict):
            deepupdate(value, update[key]) 
    return update

démonstration:

pluto_original = {
    'name': 'Pluto',
    'details': {
        'tail': True,
        'color': 'orange'
    }
}

pluto_update = {
    'name': 'Pluutoo',
    'details': {
        'color': 'blue'
    }
}

print deepupdate(pluto_original, pluto_update)

sorties:

{
    'name': 'Pluutoo',
    'details': {
        'color': 'blue',
        'tail': True
    }
}

Merci rednaw pour les modifications.

la meilleure version que je pourrais penser tout en n'utilisant pas la copie serait:

from itertools import chain
x = {'a':1, 'b': 2}
y = {'b':10, 'c': 11}
dict(chain(x.iteritems(), y.iteritems()))

c'est plus rapide que dict(x.items() + y.items()) mais pas aussi rapide que n = copy(a); n.update(b) , du moins sur CPython. Cette version fonctionne aussi en Python 3 Si vous changez iteritems() en items() , ce qui est fait automatiquement par l'outil 2to3.

personnellement, je préfère cette version parce qu'elle décrit assez bien ce que je veux dans une seule syntaxe fonctionnelle. Le seul problème mineur est qu'il ne soit pas tout à fait évident que les valeurs de y l'emportent sur les valeurs de x, mais je ne crois pas qu'il soit difficile de le comprendre.

Python 3.5 (PEP 448) permet une option de syntaxe plus agréable:

x = {'a': 1, 'b': 1}
y = {'a': 2, 'c': 2}
final = {**x, **y} 
final
# {'a': 2, 'b': 1, 'c': 2}

Ou même

final = {'a': 1, 'b': 1, **x, **y}

x = {'a':1, 'b': 2}
y = {'b':10, 'c': 11}
z = dict(x.items() + y.items())
print z

pour les éléments avec des clés dans les deux dictionnaires ('b'), vous pouvez contrôler lequel se retrouve dans la sortie en mettant celui dernier.

alors que la question a déjà reçu plusieurs réponses, cette solution simple au problème n'a pas encore été répertoriée.

x = {'a':1, 'b': 2}
y = {'b':10, 'c': 11}
z4 = {}
z4.update(x)
z4.update(y)

c'est aussi rapide que z0 et le mal z2 mentionné ci-dessus, mais facile à comprendre et à changer.

def dict_merge(a, b):
  c = a.copy()
  c.update(b)
  return c

new = dict_merge(old, extras)

parmi ces réponses obscures et douteuses, ce brillant exemple est le seul et unique bon moyen de fusionner les dicts en Python, approuvé par dictateur pour la vie Guido van Rossum lui-même! Quelqu'un d'autre a suggéré la moitié de ceci, mais ne l'a pas mis dans une fonction.

print dict_merge(
      {'color':'red', 'model':'Mini'},
      {'model':'Ferrari', 'owner':'Carl'})

donne:

{'color': 'red', 'owner': 'Carl', 'model': 'Ferrari'}

si vous pensez que les lambdas sont mauvais alors ne lisez plus. Comme demandé, Vous pouvez écrire la solution rapide et efficace en mémoire avec une expression:

x = {'a':1, 'b':2}
y = {'b':10, 'c':11}
z = (lambda a, b: (lambda a_copy: a_copy.update(b) or a_copy)(a.copy()))(x, y)
print z
{'a': 1, 'c': 11, 'b': 10}
print x
{'a': 1, 'b': 2}

comme suggéré ci-dessus, utiliser deux lignes ou écrire une fonction est probablement une meilleure façon de procéder.

soit pythonique. Utiliser un compréhension :

z={i:d[i] for d in [x,y] for i in d}

>>> print z
{'a': 1, 'c': 11, 'b': 10}

en python3, la" méthode 151930920 " ne renvoie plus une liste , mais plutôt une view , qui agit comme un ensemble. Dans ce cas, vous devrez prendre le set union depuis concaténation avec + ne fonctionnera pas:

dict(x.items() | y.items())

pour les comportements de type python3 dans la version 2.7, la méthode viewitems devrait fonctionner à la place de items :

dict(x.viewitems() | y.viewitems())

je préfère de toute façon cette notation puisqu'il semble plus naturel de penser à lui comme une opération de syndicat fixée plutôt que concaténation (comme le montre le titre).

Edit:

encore quelques points pour python 3. Tout d'abord, notez que le truc dict(x, **y) ne fonctionnera pas en python 3 à moins que les clés de y ne soient des cordes.

aussi, Chainmap de Raymond Hettinger answer est assez élégant, car il peut prendre un arbitraire nombre de dicts comme arguments, mais de la docs il semble qu'il regarde séquentiellement à travers une liste de tous les dicts pour chaque recherche:

recherches rechercher les correspondances sous-jacentes successivement jusqu'à ce qu'une clé soit trouvée.

Cela peut vous ralentir si vous avez beaucoup de recherches dans votre application:

In [1]: from collections import ChainMap
In [2]: from string import ascii_uppercase as up, ascii_lowercase as lo; x = dict(zip(lo, up)); y = dict(zip(up, lo))
In [3]: chainmap_dict = ChainMap(y, x)
In [4]: union_dict = dict(x.items() | y.items())
In [5]: timeit for k in union_dict: union_dict[k]
100000 loops, best of 3: 2.15 µs per loop
In [6]: timeit for k in chainmap_dict: chainmap_dict[k]
10000 loops, best of 3: 27.1 µs per loop

Donc environ un ordre de grandeur plus lent pour les recherches. Je suis un fan de Chainmap, mais semble moins pratique là où il peut y avoir de nombreuses recherches.

abus conduisant à une solution d'une expression pour la réponse de Matthieu :

>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> z = (lambda f=x.copy(): (f.update(y), f)[1])()
>>> z
{'a': 1, 'c': 11, 'b': 10}

vous avez dit que vous vouliez une expression, Donc j'ai abusé de lambda pour lier un nom, et tuples pour outrepasser la limite d'une expression de lambda. Hésitez pas à grincer des dents.

vous pouvez aussi le faire bien sûr si vous ne vous souciez pas de le copier:

>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> z = (x.update(y), x)[1]
>>> z
{'a': 1, 'b': 10, 'c': 11}

solution Simple à l'aide de itertools qui préserve l'ordre (ci dicts ont priorité)

import itertools as it
merge = lambda *args: dict(it.chain.from_iterable(it.imap(dict.iteritems, args)))

et son usage:

>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> merge(x, y)
{'a': 1, 'b': 10, 'c': 11}

>>> z = {'c': 3, 'd': 4}
>>> merge(x, y, z)
{'a': 1, 'b': 10, 'c': 3, 'd': 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))

sum a de mauvaises performances. Voir https://mathieularose.com/how-not-to-flatten-a-list-of-lists-in-python /

en python 3:

import collections
a = {1: 1, 2: 2}
b = {2: 3, 3: 4}
c = {3: 5}

r = dict(collections.ChainMap(a, b, c))
print(r)

:

{1: 1, 2: 2, 3: 4}

Docs: https://docs.python.org/3/library/collections.html#collections.ChainMap :

même si les réponses étaient bonnes pour ce dictionnaire shallow , aucune des méthodes définies ici ne fait réellement une fusion de dictionnaire profonde.

exemples:

a = { 'one': { 'depth_2': True }, 'two': True }
b = { 'one': { 'extra': False } }
print dict(a.items() + b.items())

on s'attendrait à un résultat de quelque chose comme ceci:

{ 'one': { 'extra': False', 'depth_2': True }, 'two': True }

au lieu de cela, nous obtenons ceci:

{'two': True, 'one': {'extra': False}}

l'entrée "one" aurait dû avoir "depth_2" et "extra" comme éléments à l'intérieur de son dictionnaire si c'était vraiment une fusion.

utilisant la chaîne aussi, ne fonctionne pas:

from itertools import chain
print dict(chain(a.iteritems(), b.iteritems()))

résultats dans:

{'two': True, 'one': {'extra': False}}

la fusion profonde que rcwesick a donné crée aussi le même résultat.

Oui, il va fonctionner pour fusionner les dictionnaires d'exemple, mais aucun d'eux ne sont un mécanisme générique pour fusionner. Je le mettrai à jour plus tard une fois que j'aurai écrit une méthode qui fait une vraie Fusion.

Pour Python 2:

x = {'a':1, 'b': 2}
y = {'b':10, 'c': 11}
z = dict(x.items()+y.items())
print(z)

Pour Python 3:

x = {'a':1, 'b': 2}
y = {'b':10, 'c': 11}
z = dict(x.items()|y.items())
print(z)

il donne la sortie: {'a': 1, 'c': 11, 'b': 10}

puisant dans les idées d'ici et d'ailleurs, j'ai compris une fonction:

def merge(*dicts, **kv): 
      return { k:v for d in list(dicts) + [kv] for k,v in d.items() }

utilisation (testé en python 3):

assert (merge({1:11,'a':'aaa'},{1:99, 'b':'bbb'},foo='bar')==\
    {1: 99, 'foo': 'bar', 'b': 'bbb', 'a': 'aaa'})

assert (merge(foo='bar')=={'foo': 'bar'})

assert (merge({1:11},{1:99},foo='bar',baz='quux')==\
    {1: 99, 'foo': 'bar', 'baz':'quux'})

assert (merge({1:11},{1:99})=={1: 99})

vous pourriez utiliser un lambda à la place.

>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> x, z = dict(x), x.update(y) or x
>>> x
{'a': 1, 'b': 2}
>>> y
{'c': 11, 'b': 10}
>>> z
{'a': 1, 'c': 11, 'b': 10}

le problème que j'ai avec les solutions énumérées à ce jour est que, dans le dictionnaire fusionné, la valeur de la touche" b " est 10 mais, à ma façon de penser, il devrait être 12. Dans cette perspective, je présente ce qui suit:

import timeit

n=100000
su = """
x = {'a':1, 'b': 2}
y = {'b':10, 'c': 11}
"""

def timeMerge(f,su,niter):
    print "{:4f} sec for: {:30s}".format(timeit.Timer(f,setup=su).timeit(n),f)

timeMerge("dict(x, **y)",su,n)
timeMerge("x.update(y)",su,n)
timeMerge("dict(x.items() + y.items())",su,n)
timeMerge("for k in y.keys(): x[k] = k in x and x[k]+y[k] or y[k] ",su,n)

#confirm for loop adds b entries together
x = {'a':1, 'b': 2}
y = {'b':10, 'c': 11}
for k in y.keys(): x[k] = k in x and x[k]+y[k] or y[k]
print "confirm b elements are added:",x

Résultats:

0.049465 sec for: dict(x, **y)
0.033729 sec for: x.update(y)                   
0.150380 sec for: dict(x.items() + y.items())   
0.083120 sec for: for k in y.keys(): x[k] = k in x and x[k]+y[k] or y[k]

confirm b elements are added: {'a': 1, 'c': 11, 'b': 12}

cela peut être fait avec une seule compréhension dict:

>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> { key: y[key] if key in y else x[key]
      for key in set(x) + set(y)
    }

à mon avis la meilleure réponse pour la partie 'single expression' car aucune fonction supplémentaire n'est nécessaire, et il est court.

from collections import Counter
dict1 = {'a':1, 'b': 2}
dict2 = {'b':10, 'c': 11}
result = dict(Counter(dict1) + Counter(dict2))

cela devrait résoudre votre problème.

(Pour Python2.7* seulement; il existe des solutions plus simples pour Python3*.)

si vous n'êtes pas opposé à l'importation d'un module de bibliothèque standard, vous pouvez le faire

from functools import reduce

def merge_dicts(*dicts):
    return reduce(lambda a, d: a.update(d) or a, dicts, {})

(le bit or a dans le lambda est nécessaire parce que dict.update retourne toujours None sur le succès.)

en Python 3.5 vous pouvez utiliser unpack ** afin de créer un nouveau dictionnaire. Cette méthode n'a pas été montrée dans les réponses précédentes. De plus, il est préférable d'utiliser {} au lieu de dict() . Parce que {} est un python littéral et dict() implique un appel de fonction.

dict1 = {'a':1}
dict2 = {'b':2}
new_dict = {**dict1, **dict2}
>>>new_dict
{'a':1, 'a':2}