W Twoim przypadku, to co możesz zrobić to:

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

To, jak chcesz, umieści końcowy dict w z i sprawi, że wartość klucza b będzie odpowiednio przesłonięta przez drugą (y) wartość dict:

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

Jeśli używasz Pythona 3, jest to tylko trochę bardziej skomplikowane. Aby utworzyć z:

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

Alternatywa:

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

Inna, bardziej zwięzła opcja:

z = dict(x, **y)

Uwaga: ta odpowiedź stała się popularną odpowiedzią, ale ważne jest, aby zwrócić uwagę, że jeśli y ma jakieś klucze nietekstowe, fakt, że to działa, jest nadużyciem szczegółów implementacji CPython i nie działa w Pythonie 3, ani w PyPy, IronPython lub Jython. Ponadto, Guido nie jest fanem . Więc nie mogę polecić tej techniki dla kompatybilnego lub cross-implementacji przenośnego kodu, co naprawdę oznacza, że powinno być unikał całkowicie.

Prawdopodobnie nie będzie to popularna odpowiedź, ale prawie na pewno nie chcesz tego robić. Jeśli chcesz mieć kopię scaloną, użyj copy (lub deepcopy , w zależności od tego, co chcesz), a następnie zaktualizuj. Dwie linie kodu są znacznie bardziej czytelne - bardziej Pythoniczne-niż tworzenie pojedynczej linii .items() + .pozycji(). Explicit jest lepszy niż implicit.

Dodatkowo, gdy używasz .items () (pre Python 3.0), tworzysz nową listę zawierającą elementy z dict. Jeśli Twoje słowniki są duże, to jest to sporo narzutu (dwie duże listy, które zostaną wyrzucone zaraz po utworzeniu scalonego dict). update() może działać wydajniej, ponieważ może działać przez drugi dict pozycja po pozycji.

W kategoriach czasu :

>>> 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

W odpowiedzi uzupełniającej zapytałeś o względną wydajność tych dwóch alternatyw:

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

Na moim komputerze, przynajmniej (dość zwykły x86_64 z Pythonem 2.5.2), alternatywa z2 jest nie tylko krótsza i prostsza, ale także znacznie szybsza. Możesz to sprawdzić samodzielnie za pomocą modułu timeit dostarczanego z Pythonem.

Przykład 1: identyczne słowniki odwzorowujące 20 kolejnych liczb całkowitych do siebie:

% 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 wygrane przez współczynnik 3,5 mniej więcej. Różne słowniki wydają się dawać zupełnie inne wyniki, ale z2 zawsze wydają się wychodzić na wierzch. (Jeśli uzyskasz niespójne wyniki dla tego samego testu, spróbuj przejść -r z liczbą większą niż domyślna 3.)

Przykład 2: nie nakładające się słowniki odwzorowują 252 krótkie ciągi na liczby całkowite i odwrotnie:

% 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 wygrywa o współczynnik 10. To całkiem duża wygrana w mojej książce!

Po porównaniu tych dwóch, zastanawiałem się, czy Słaba wydajność może być przypisana do kosztów budowy dwóch list przedmiotów, co z kolei skłoniło mnie do zastanowienia się, czy ta odmiana może działać lepiej:]}

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

Kilka szybkich testów, np.

% 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

Doprowadzaj mnie do wniosku, że z3 jest nieco szybszy niż z1, ale nie prawie tak szybki jak z2. Zdecydowanie nie warto wszystkich dodatkowych wpisów.

W tej dyskusji wciąż brakuje czegoś ważnego, czyli porównania wydajności tych alternatyw z "oczywisty" sposób łączenia dwóch list: za pomocą metody update. Aby spróbować utrzymać rzeczy na równi z wyrażeniami, z których żadne nie modyfikuje x lub y, zrobię kopię x zamiast modyfikować go na miejscu, w następujący sposób: {]}

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

Typowy wynik:

% 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

Innymi słowy, z0 i z2 wydają się mieć zasadniczo identyczne wyniki. Myślisz, że to może być zbieg okoliczności? Ja nie....

W rzeczywistości posunąłbym się nawet do twierdzenia, że to niemożliwe aby czysty kod Pythona był lepszy niż ten. A jeśli możesz zrobić znacznie lepiej w module rozszerzeń C, wyobrażam sobie, że ludzie Pythona mogą być zainteresowani włączeniem Twojego kodu (lub wariacji na temat Twojego podejścia) do rdzenia Pythona. Python używa dict w wielu miejscach; optymalizacja jego operacji to wielka sprawa.

Możesz też napisać to jako

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

Tak jak Tony, ale (nic dziwnego) różnica w notacji okazuje się nie mieć żadnego mierzalnego efektu na wydajność. Użyj tego, co Ci odpowiada. Oczywiście ma absolutną rację zaznaczając, że wersja dwuznakowa jest znacznie łatwiejsza do zrozumienia.

Chciałem coś podobnego, ale z możliwością określenia, jak wartości na zduplikowanych kluczach zostały połączone, więc hacked to out (ale nie mocno testować). Oczywiście nie jest to pojedyncze wyrażenie, ale jedno wywołanie funkcji.

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

W Pythonie 3 możesz użyć Kolekcje.ChainMap który grupuje wiele dictów lub innych mapowań razem, aby utworzyć jeden, aktualizowalny Widok:

>>> 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

Recursively / deep update a 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

Demonstracja:

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

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

print deepupdate(pluto_original, pluto_update)

Wyjścia:

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

Najlepsza wersja, jaką mogłem sobie wyobrazić, gdy nie używałem copy to:

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

Osobiście najbardziej podoba mi się ta wersja, ponieważ opisuje dość dobre to, co chcę w jednej składni funkcjonalnej. Jedynym drobnym problemem jest to, że nie jest całkowicie oczywiste, że wartości z y ma pierwszeństwo ponad wartościami z x, ale nie wydaje mi się, że trudno to rozgryźć.

Python 3.5 (PEP 448) pozwala na ładniejszą opcję składni:

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

Lub nawet

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

Dla elementów z kluczami w obu słownikach ('b'), możesz kontrolować, który z nich kończy się na wyjściu, umieszczając go na końcu.

Podczas gdy na pytanie już kilka razy udzielono odpowiedzi, to proste rozwiązanie problemu nie zostało jeszcze wymienione.

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

Jest tak szybki jak Z0 i zło Z2 wymienione powyżej, ale łatwy do zrozumienia i zmiany.

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

new = dict_merge(old, extras)

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

Daje:

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

Jeśli uważasz, że lambda są złe, nie czytaj dalej. Zgodnie z życzeniem, możesz napisać szybkie i efektywne w pamięci rozwiązanie za pomocą jednego wyrażenia:

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}

Jak sugerowano powyżej, używanie dwóch linii lub pisanie funkcji jest prawdopodobnie lepszym rozwiązaniem.

Bądź pythoniczny. Użyj :

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

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

W python3, metoda items nie zwraca już listy, ale raczej widok, który działa jak zbiór. W tym przypadku musisz wziąć zestaw Unia ponieważ konkatenacja z + nie będzie działać:

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

Dla zachowania przypominającego python3 w wersji 2.7, metoda viewitems powinna działać zamiast items:

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

I tak wolę tę notację, ponieważ bardziej naturalne wydaje się myślenie o niej jako o operacji zespolonej, a nie konkatenacji (jak w tytule pokazy).

Edit:

Jeszcze kilka punktów dla Pythona 3. Po pierwsze, zauważ, że sztuczka dict(x, **y) nie będzie działać w Pythonie 3, chyba że klucze y są ciągami znaków.

Również odpowiedź Raymonda Hettingera Chainmap jest dość elegancka, ponieważ może przyjmować dowolną liczbę dictów jako argumentów, ale z dokumentów wygląda tak, jakby kolejno przeglądała listę wszystkich dictów dla każdego wyszukiwania:

Szukaj Szukaj mapuje kolejno, aż do znalezienia klucza.

Może to spowolnić, jeśli masz dużo wyszukiwania w aplikacji:

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

Więc o rząd wielkości wolniej dla wyszukiwania. Jestem fanem Chainmap, ale wygląda mniej praktycznie tam, gdzie może być wiele wyszukiwań.

Nadużycie prowadzące do rozwiązania jednego wyrażenia dla odpowiedź Mateusza :

>>> 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}

Powiedziałeś, że chcesz jedno wyrażenie, więc wykorzystałem lambda, aby powiązać nazwę, i krotki, aby zastąpić limit jednego wyrażenia lambda. Nie krępuj się.

Możesz to oczywiście zrobić, jeśli nie zależy ci na kopiowaniu:

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

Proste rozwiązanie przy użyciu itertools, które zachowuje porządek (Ostatnie dicty mają pierwszeństwo)

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

I jego użycie:

>>> 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}

Dwa słowniki

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

N słowniki

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

sum ma złe wyniki. Zobacz https://mathieularose.com/how-not-to-flatten-a-list-of-lists-in-python/

W Pythonie 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)

Out:

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

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

Mimo że odpowiedzi były dobre dla tego słownikashallow , żadna z metod zdefiniowanych tutaj nie łączy głębokiego słownika.

Przykłady:

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

Można by się spodziewać wyniku czegoś takiego:

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

Zamiast tego otrzymujemy:

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

Wpis 'one' powinien mieć 'depth_2' i 'extra' jako elementy w słowniku, jeśli rzeczywiście było to połączenie.

Używanie łańcucha również nie działa:

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

Wyniki in:

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

Głębokie scalenie, które dało rcwesick, również tworzy ten sam wynik.

Tak, będzie działać scalanie przykładowych słowników, ale żaden z nich nie jest ogólnym mechanizmem scalania. Zaktualizuję to później, gdy napiszę metodę, która wykonuje prawdziwe scalanie.

Dla Pythona 2:

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

Dla Pythona 3:

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

Daje wyjście: {'a': 1, 'c': 11, 'b': 10}

Czerpiąc z pomysłów tu i gdzie indziej pojąłem funkcję:

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

Użycie (testowane w Pythonie 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})

>>> 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}

Problem, który mam z rozwiązaniami wymienionymi do tej pory, polega na tym, że w połączonym słowniku wartość klucza " b " wynosi 10, ale moim zdaniem powinno być to 12. W tym świetle przedstawiam następujące:

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

Wyniki:

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}

Można to zrobić za pomocą jednego słownika:

>>> 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)
    }

Moim zdaniem najlepsza odpowiedź dla części 'single expression', ponieważ nie są potrzebne żadne dodatkowe funkcje i jest krótka.

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

(Tylko dla Python2. 7*; istnieją prostsze rozwiązania dla Python3*.)

Jeśli nie jesteś przeciwny importowaniu standardowego modułu bibliotecznego, możesz to zrobić

from functools import reduce

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

(bit or a w lambda jest konieczny, ponieważ dict.update zawsze zwraca None Po sukcesie.)

W Pythonie 3.5 możesz użyć unpack ** w celu utworzenia nowego słownika. Metoda ta nie została wykazana w poprzednich odpowiedziach. Ponadto, lepiej jest użyć {} zamiast dict(). Ponieważ {} jest literałem Pythona, a dict() zawiera wywołanie funkcji.

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