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

z = dict(list(x.items()) + list(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(list(x.items()) + list(y.items()))
>>> z
{'a': 1, 'c': 11, 'b': 10}

Jeśli używasz Pythona 2, możesz nawet usunąć wywołania list(). Aby utworzyć z:

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

Jeśli używasz Pythona w wersji 3.9. 0A4 lub nowszej, możesz użyć bezpośrednio:

x = {'a':1, 'b': 2}
y = {'b':10, 'c': 11}
z = x | y
print(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.

W Pythonie 3.0 i nowszych można użyć collections.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 = dict(ChainMap({}, y, x))
>>> for k, v in z.items():
        print(k, '-->', v)
    
a --> 1
b --> 10
c --> 11

Aktualizacja dla Pythona 3.5 i nowszych: możesz użyć PEP 448 rozszerzonego słownika do pakowania i rozpakowywania. To jest szybkie i proste:

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

Aktualizacja dla Pythona 3.9 i nowszych: możesz użyć Pep 584 union operator:

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

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

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}

W Pythonie 3.9 używasz również | i / = z poniższym przykładem z PEP 584

d = {'spam': 1, 'eggs': 2, 'cheese': 3}
e = {'cheese': 'cheddar', 'aardvark': 'Ethel'}
d | e
# {'spam': 1, 'eggs': 2, 'cheese': 'cheddar', 'aardvark': 'Ethel'}

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

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/

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

# py2
from itertools import chain, imap
merge = lambda *args: dict(chain.from_iterable(imap(dict.iteritems, args)))

# py3
from itertools import chain
merge = lambda *args: dict(chain.from_iterable(map(dict.items, 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}

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}

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.

Jeśli nie masz nic przeciwko mutacji x,

x.update(y) or x

Proste, czytelne, wydajne. You know update() zawsze zwraca None, która jest wartością false. Tak więc powyższe wyrażenie będzie zawsze oceniać Do x, Po zaktualizowaniu go.

Większość metod mutujących w bibliotece standardowej (jak .update()) zwraca None zgodnie z konwencją, więc ten rodzaj wzorca będzie działał również na tych. Jeśli jednak używasz podklasy dict lub innej metody, która nie jest zgodna z tą konwencją, or może zwróć lewy operand, który może nie być tym, czego chcesz. Zamiast tego możesz użyć wyświetlacza krotki i indeksu, który działa niezależnie od tego, do czego pierwszy element jest oceniany (chociaż nie jest tak ładny): {]}

(x.update(y), x)[-1]

Jeśli nie masz jeszcze x W Zmiennej, możesz użyć lambda, aby utworzyć lokalny bez użycia instrukcji assignment. Oznacza to użycie lambda jako let expression, co jest powszechną techniką w językach funkcyjnych, ale może unpythonic.

(lambda x: x.update(y) or x)({'a': 1, 'b': 2})

Chociaż nie różni się to tak bardzo od następującego zastosowania nowego operatora morsa (tylko Python 3.8+):

(x := {'a': 1, 'b': 2}).update(y) or x

Jeśli chcesz kopię, PEP 584 styl x | y jest najbardziej Pythoniczny na 3.9+. Jeśli musisz obsługiwać starsze wersje, PEP 448 styl {**x, **y} jest najłatwiejszy dla 3.5+. Ale jeśli nie jest to dostępne w Twojej (nawet starszej) wersji Pythona, wzór let również działa tutaj.

(lambda z: z.update(y) or z)(x.copy())

(jest to oczywiście niemal równoznaczne z (z := x.copy()).update(y) or z, Ale jeśli Twoja wersja Pythona jest wystarczająco Nowa, wtedy styl PEP 448 będzie dostępny.)

(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.)

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

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}

To takie głupie, że nic nie zwraca.
Po prostu używam prostej funkcji pomocnika do rozwiązania problemu:

def merge(dict1,*dicts):
    for dict2 in dicts:
        dict1.update(dict2)
    return dict1

Przykłady:

merge(dict1,dict2)
merge(dict1,dict2,dict3)
merge(dict1,dict2,dict3,dict4)
merge({},dict1,dict2)  # this one returns a new copy

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

Pojawi się nowa opcja, gdy Python 3.8 wyda (zaplanowane na 20 października 2019 r. ), Dzięki Pep 572: Assignment Expressions . Nowy operator wyrażenia przyporządkowania := pozwala przypisać wynik copy i nadal używać go do wywoływania update, pozostawiając połączony kod pojedynczym wyrażeniem, a nie dwoma instrukcjami, zmieniając:

newdict = dict1.copy()
newdict.update(dict2)

Do:

(newdict := dict1.copy()).update(dict2)

(newdict := dict1.copy()).update(dict2) or newdict

Ważne zastrzeżenie: ogólnie odradzam takie podejście na rzecz:

newdict = {**dict1, **dict2}

Metoda rozpakowywania jest bardziej przejrzyste (dla wszystkich, którzy wiedzą o uogólnionym rozpakowywaniu, , które powinieneś ), w ogóle nie wymaga nazwy dla wyniku (więc jest o wiele bardziej zwięzłe przy konstruowaniu tymczasowości, która jest natychmiast przekazywana do funkcji lub zawarta w list/tuple W przeciwieństwie do CP, CPython jest bardzo podobny do CP.]}

newdict = {}
newdict.update(dict1)
newdict.update(dict2)

Ale robione na warstwie C, przy użyciu betonowego dict API, więc nie ma dynamicznego wyszukiwania/wiązania metod lub wywołanie funkcji (gdzie (newdict := dict1.copy()).update(dict2) jest nieuniknione identyczne z oryginalnym dwuliniowym w zachowaniu, wykonując pracę w dyskretnych krokach, z dynamicznym wyszukiwaniem/wiązaniem / wywoływaniem metod.

 newdict = {**dict1, **dict2, **dict3}

Gdzie użycie wyrażeń przypisania nie będzie skalowane w ten sposób; najbliższe, jakie można uzyskać, to:

 (newdict := dict1.copy()).update(dict2), newdict.update(dict3)

Lub bez tymczasowej krotki None s, ale z testem prawdziwości z każdego wyniku None:

 (newdict := dict1.copy()).update(dict2) or newdict.update(dict3)

Jedyną rzeczywistą zaletą podejścia assignment expression jest to, że:

1. masz ogólny kod, który wymaga obsługi zarówno set s jak i dict s (oba obsługują copy i update, więc kod działa mniej więcej tak, jak można się tego spodziewać)
2. oczekujesz, że otrzymasz dowolne obiekty podobne do dict , a nie tylko dict, i musisz zachować typ i semantykę lewej strony (zamiast kończyć się zwykłym dict). Chociaż myspecialdict({**speciala, **specialb}) może działać, wymagałoby to dodatkowego tymczasowego dict, a jeśli myspecialdict ma cechy zwykły dictnie może zachować (np. w oparciu o ostatni wygląd klucza; możesz chcieć takiego, który zachowuje porządek w oparciu o ostatni wygląd klucza, więc aktualizacja wartości również przenosi ją na koniec), wtedy semantyka byłaby błędna. Ponieważ wersja wyrażenia przyporządkowania używa nazwanych metod (które prawdopodobnie są przeciążone, aby zachowywać się odpowiednio), nigdy nie tworzy dict W OGÓLE (CHYBA że dict1 było już dict), zachowując oryginalny typ (i semantykę oryginalnego typu), a wszystko to unikając jakichkolwiek tymczasowo.

Nowy w Pythonie 3.9: użyj operatora union (|), aby połączyć dict S podobne do set s:

>>> d = {'a': 1, 'b': 2}
>>> e = {'a': 9, 'c': 3}
>>> d | e
{'a': 9, 'b': 2, 'c': 3}

Dla dopasowanych kluczy, prawo dict ma pierwszeństwo.

To również działa dla |=, aby zmodyfikować dict w miejscu:

>>> e |= d    # e = e | d
>>> e
{'a': 1, 'c': 3, 'b': 2}

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.