Kako kombinirati dva rječnika u jednom izrazu?

Imam dva Python rječnika i želim napisati jedan izraz koji vraća ta dva rječnika, spajanje. Metoda update() bit će ono što trebam ako vraća rezultat i ne mijenja diktat na mjestu.

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

Kako mogu dobiti ovaj konačni kombinirani dict u z , a ne x ?

(Da bi bilo iznimno jasno, rukovanje sukobljava s najnovijim jednokratnim dict.update() je ono što tražim.)

3587
02 сент. postavio Carl Meyer 02 ruj. 2008-09-02 10:44 '08 u 10:44 2008-09-02 10:44
@ 52 odgovora
  • 1
  • 2

Kako mogu kombinirati dva Python rječnika u jednom izrazu?

Za rječnike x i y z postaje fino kombinirani rječnik s vrijednostima iz y zamjenjuju vrijednosti iz x .

  • U Pythonu 3.5 ili novijem:

     z = {**x, **y} 
  • U Pythonu 2 (ili 3,4 ili niže) napišite funkciju:

     def merge_two_dicts(x, y): z = x.copy() # start with x keys and values z.update(y) # modifies z with y keys and values  returns None return z 

    i sada:

     z = merge_two_dicts(x, y) 

objašnjenje

Recimo da imate dva diktata i želite ih spojiti u novi, bez mijenjanja izvornih:

 x = {'a': 1, 'b': 2} y = {'b': 3, 'c': 4} 

Željeni rezultat je dobivanje novog rječnika ( z ) s spojenim vrijednostima, a vrijednosti drugog dikta prebrisati vrijednosti iz prvog.

 >>> z {'a': 1, 'b': 3, 'c': 4} 

Nova sintaksa za ovo, predložena u PEP 448 i dostupna s Python 3.5 ,

 z = {**x, **y} 

I to je doista jedini izraz.

Imajte na umu da možemo kombinirati s notom pisma:

 z = {**x, 'foo': 1, 'bar': 2, **y} 

i sada:

 >>> z {'a': 1, 'b': 3, 'foo': 1, 'bar': 2, 'c': 4} 

Sada pokazuje kako je implementiran u rasporedu izdanja 3.5, PEP 478 , a sada se pojavljuje u dokumentu Što je novo u Pythonu 3.5 .

Međutim, budući da mnoge organizacije još uvijek koriste Python 2, možete ga učiniti kompatibilnom unatrag. Klasična Pythonic metoda, dostupna u Python 2 i Python 3.0-3.4, je da to učinite kao proces od dva koraka:

 z = x.copy() z.update(y) # which returns None since it mutates z 

U oba pristupa, y će biti drugi, a njegove vrijednosti će zamijeniti vrijednosti x , tako da će 'b' označiti 3 u našem konačnom rezultatu.

Ne još u Pythonu 3.5, ali želim jedan izraz

Ako još ne koristite Python 3.5, ili trebate pisati unatrag kompatibilni kod, a želite da bude u jednom izrazu, najučinkovitiji i najprikladniji pristup je staviti ga u funkciju:

 def merge_two_dicts(x, y): """Given two dicts, merge them into a new dict as a shallow copy.""" z = x.copy() z.update(y) return z 

i onda imate jedan izraz:

 z = merge_two_dicts(x, y) 

Također možete stvoriti funkciju za spajanje neodređenog broja diktata od nule do vrlo velikog broja:

 def merge_dicts(*dict_args): """ Given any number of dicts, shallow copy and merge into a new dict, precedence goes to key value pairs in latter dicts. """ result = {} for dictionary in dict_args: result.update(dictionary) return result 

Ova funkcija će raditi u Pythonu 2 i 3 za sve diktate. na primjer, podaci diktiraju od a do g :

 z = merge_dicts(a, b, c, d, e, f, g) 

i parovi ključ-vrijednost u g će imati prednost nad parametrima od a do f i tako dalje.

Kritika drugih odgovora

Nemojte koristiti ono što vidite u prethodno prihvaćenom odgovoru:

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

U Pythonu 2 možete stvoriti dva popisa u memoriji za svaki dikt, stvoriti treći popis u memoriji s duljinom jednakom duljini prvih dviju kombinacija, a zatim odbaciti sva tri popisa kako biste kreirali diktat. U Pythonu 3 to neće uspjeti jer zajedno dodajete dva dict_items , a ne dva popisa -

 >>> c = dict(a.items() + b.items()) Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: unsupported operand type(s) for +: 'dict_items' and 'dict_items' 

i morat ćete ih izričito stvoriti kao popise, primjerice z = dict(list(x.items()) + list(y.items())) . To je rasipanje resursa i računalne snage.

Slično tome, kombiniranje items() u Pythonu 3 ( viewitems() u Pythonu 2.7) također neće uspjeti ako su vrijednosti objekti koji se ne mogu mijenjati (na primjer, popisi). Čak i ako su vaše vrijednosti hashable, jer su skupovi semantički neuređeni, ponašanje nije definirano s obzirom na prioritet. Zato nemojte to raditi:

 >>> c = dict(a.items() | b.items()) 

Ovaj primjer pokazuje što se događa kada se vrijednosti ne razlikuju:

 >>> x = {'a': []} >>> y = {'b': []} >>> dict(x.items() | y.items()) Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: unhashable type: 'list' 

Ovdje je primjer gdje y treba imati prednost, ali umjesto toga vrijednost iz x je sačuvana zbog proizvoljnog redoslijeda skupova:

 >>> x = {'a': 2} >>> y = {'a': 1} >>> dict(x.items() | y.items()) {'a': 2} 

Još jedan hack ne smijete koristiti:

 z = dict(x, **y) 

Koristi konstruktor dict i vrlo je brz i učinkovit u korištenju memorije (čak i malo više od našeg procesa u dva koraka), ali ako ne znate točno što se ovdje događa (to jest, drugi dict se prosljeđuje kao argument konstrukcijskim ključnim riječima dicta) , teško je pročitati, nije namjena, pa stoga nije Pythonic.

Evo primjera korištenja popravka u django-u .

Diktati su dizajnirani za dobivanje hash tipki (na primjer, frozensets ili tuples), ali ova metoda ne radi u Pythonu 3 kada tipke nisu žice.

 >>> c = dict(a, **b) Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: keyword arguments must be strings 

S popisa adresa, tvorac jezika, Guido van Rossum, napisao je:

Slažem se s proglašenjem dikta ({}, ** {1: 3}) nezakonitim, jer na kraju je to zloupotreba ** mehanizma.

i također

Očigledno, dict (x, ** y) se koristi kao "cool hack" za "pozivanje x.update (y) i vraćanje x". Osobno, smatram ga prezrivim nego kul.

Moje je razumijevanje (kao i razumijevanje tvorca jezika ) da je namjena dict(**y) namijenjena stvaranju dikta za svrhe čitljivosti, na primjer:

 dict(a=1, b=10, c=11) 

umjesto

 {'a': 1, 'b': 10, 'c': 11} 

Odgovorite na komentare

Unatoč tome što Guido kaže, dict(x, **y) odgovara specifikaciji dikta, koja je, usput rečeno. radi za Python 2 i 3. Činjenica da to radi samo za tipke s nizom je izravna posljedica načina rada ključnih riječi, a ne kratkog korištenja dicta. Isto tako, korištenje operatora ** na ovom mjestu nije zlouporaba mehanizma, u stvari ** razvijena je posebno za prijenos riječi kao ključnih riječi.

Opet, ovo ne radi za 3 kada tipke nisu žice. Implicitni pozivni ugovor je u tome što regularni diktati uzimaju prostor imena, dok korisnici moraju samo proslijediti ključne argumente, koji su nizovi. Sve ostale vojne snage prisilile su ga. dict razbio taj slijed u Pythonu 2:

 >>> foo(**{('a', 'b'): None}) Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: foo() keywords must be strings >>> dict(**{('a', 'b'): None}) {('a', 'b'): None} 

Ova nedosljednost bila je loša s obzirom na druge Pythonove implementacije (Pypy, Jython, IronPython). Dakle, ovo je popravljeno u Pythonu 3, jer ova uporaba može biti velika promjena.

Tvrdim da je to zlonamjerna nekompetentnost - namjerno pisanje koda koji radi samo u jednoj verziji jezika ili radi samo pod određenim proizvoljnim ograničenjima.

Više komentara:

dict(x.items() + y.items()) je i dalje dict(x.items() + y.items()) rješenje za Python 2. Čitljivost je bitna.

Moj odgovor: merge_two_dicts(x, y) zapravo mi se čini mnogo jasnijim ako smo doista zabrinuti zbog čitljivosti. A to nije kompatibilno s naprijed, jer Python 2 postaje sve više i više zastario.

Čini se da {**x, **y} ne rukuje ugniježđenim rječnicima. sadržaj ugniježđenih ključeva jednostavno se prepisuje, ne spaja [...]. Na kraju sam bio izgorio od tih odgovora, koji se ne sjedinjuju rekurzivno, i bio sam iznenađen što ga nitko nije spominjao. U mojoj interpretaciji riječi "stopiti", ovi odgovori opisuju "ažuriranje jednog diktata drugom", a ne spajanje.

Da. Moram vas vratiti natrag na pitanje koje zahtijeva površno spajanje dvaju rječnika, pri čemu prva vrijednost prepisuje drugi - u jednom izrazu.

Pretpostavljajući dva rječnika, može ih se rekurzivno kombinirati u jednu funkciju, ali morate biti oprezni da ne mijenjate upute iz bilo kojeg izvora, a najsigurniji način da se to izbjegne je da napravite kopiju pri dodjeljivanju vrijednosti. Budući da ključevi moraju biti raspršeni i, stoga, obično nepromjenjivi, nema smisla kopirati ih:

 from copy import deepcopy def dict_of_dicts_merge(x, y): z = {} overlapping_keys = x.keys()  y.keys() for key in overlapping_keys: z[key] = dict_of_dicts_merge(x[key], y[key]) for key in x.keys() - overlapping_keys: z[key] = deepcopy(x[key]) for key in y.keys() - overlapping_keys: z[key] = deepcopy(y[key]) return z 

Upotreba:

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

Rješenje za ostale vrste vrijednosti daleko nadilazi okvire ovog pitanja, pa ću vam ukazati na moj odgovor na kanonsko pitanje "Rječnici spajanja rječnika".

Manje produktivni, ali ispravni Ad-hocs

Ti su pristupi manje učinkoviti, ali će pružiti ispravno ponašanje. Oni će biti mnogo manje produktivni od copy i update ili novog raspakiranja, jer ponavljaju svaki par ključ / vrijednost na višoj razini apstrakcije, ali poštuju redoslijed prioriteta (posljednji diktati imaju prednost)

Možete i ručno povezati riječi u njihovu razumijevanju:

 {k: v for d in dicts for k, v in d.items()} # iteritems in Python 2.7 

ili u Pythonu 2.6 (i, možda, već u 2.4, kada su izrazi generatora uneseni):

 dict((k, v) for d in dicts for k, v in d.items()) 

itertools.chain iteratori u parovima ključ / vrijednost u ispravnom redoslijedu:

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

Analiza izvedbe

Analizirat ću izvedbu samo onih slučajeva u kojima je poznato da se ponašaju ispravno.

 import timeit 

U Ubuntu 14.04

U Pythonu 2.7 (Python sustav):

 >>> min(timeit.repeat(lambda: merge_two_dicts(x, y))) 0.5726828575134277 >>> min(timeit.repeat(lambda: {k: v for d in (x, y) for k, v in d.items()} )) 1.163769006729126 >>> min(timeit.repeat(lambda: dict(itertools.chain(x.iteritems(), y.iteritems())))) 1.1614501476287842 >>> min(timeit.repeat(lambda: dict((k, v) for d in (x, y) for k, v in d.items()))) 2.2345519065856934 

U Pythonu 3.5 (deadsnakes PPA):

 >>> min(timeit.repeat(lambda: {**x, **y})) 0.4094954460160807 >>> min(timeit.repeat(lambda: merge_two_dicts(x, y))) 0.7881555100320838 >>> min(timeit.repeat(lambda: {k: v for d in (x, y) for k, v in d.items()} )) 1.4525277839857154 >>> min(timeit.repeat(lambda: dict(itertools.chain(x.items(), y.items())))) 2.3143140770262107 >>> min(timeit.repeat(lambda: dict((k, v) for d in (x, y) for k, v in d.items()))) 3.2069112799945287 

Rječnik resursa

3869
11 нояб. Odgovor je dao Aaron Hall 11. studenog. 2014-11-11 01:11 '14 u 1:11 2014-11-11 01:11

U vašem slučaju, ono što možete učiniti je:

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

Ovo, kao što želite, stavite konačni dikt u z i izvršite ispravno redefiniranje vrijednosti b ključa s drugom vrijednošću ( y ):

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

Ako koristite Python 3, to je malo kompliciranije. Za izradu z :

 >>> z = dict(list(x.items()) + list(y.items())) >>> z {'a': 1, 'c': 11, 'b': 10} 
1490
02 сент. Odgovor na Thomas Vander Stichele 02 ruj 2008-09-02 10:50 '08 u 10:50 AM 2008-09-02 10:50

alternativa:

 z = x.copy() z.update(y) 
574
02 сент. odgovor dao Matthew Schinckel 02 2008-09-02 16:00 '08 u 4:00 2008-09-02 4:00

Druga, konciznija opcija:

 z = dict(x, **y) 

Napomena : Ovo je postao popularan odgovor, ali važno je naglasiti da ako y ima ne-stringove ključeve, činjenica da uopće radi je zloupotreba detalja CPython implementacije, a ne radi u Pythonu 3 ili PyPy, IronPython ili Jython. Osim toga, Guido nije obožavatelj . Stoga ne mogu preporučiti ovu metodu za prijenosni kod s naprednom kompatibilnošću ili unakrsnom implementacijom, što zapravo znači da bi trebalo biti potpuno isključeno.

288
02 сент. Odgovor daje Carl Meyer 02 rujna. 2008-09-02 18:52 '08 u 18:52 2008-09-02 18:52

To vjerojatno neće biti popularan odgovor, ali gotovo sigurno ne želite to učiniti. Ako vam je potrebna kopija spajanja, koristite kopiju (ili duboku kopiju , ovisno o tome što želite), a zatim ažurirajte. Dvije linije koda su mnogo čitljive - više Pythonic - nego stvaranje jednog retka pomoću .items () + .items (). Eksplicitno je bolje nego implicitno.

Osim toga, kada koristite .items () (prije Python 3.0), kreirate novi popis koji sadrži elemente iz dicta. Ako su vaši rječnici veliki, onda je dosta prevelikih troškova (dva velika popisa koji će biti odbačeni čim se stvori kombinirani zapis). update () može raditi učinkovitije jer može raditi kroz drugi element dict-by-item.

U pogledu vremena :

 >>> 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 je neznatno usporavanje između prva dva vrijedna čitanja. Osim toga, argumenti rječnika ključnih riječi dodani su samo u Python 2.3, dok će copy () i update () raditi u starijim verzijama.

178
08 сент. Odgovor daje Tony Meyer 08 rujna. 2008-09-08 14:16 '08 u 14:16 2008-09-08 14:16

U sljedećem odgovoru postavili ste pitanje o relativnoj izvedbi ove dvije alternative:

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

Na mom računalu, barem (prilično regularan x86_64, koji radi s Python 2.5.2), alternativa z2 nije samo kraća i jednostavnija, nego i mnogo brža. Možete ga sami testirati pomoću modula timeit koji dolazi s timeit .

Primjer 1: identični rječnici koji prikazuju 20 uzastopnih brojeva:

 % 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 pobjeđuje 3,5 puta ili tako. Čini se da različiti rječnici daju sasvim različite rezultate, ali čini se da z2 uvijek izlazi naprijed. (Ako dobijete nekonzistentne rezultate za isti test, pokušajte prebaciti na -r s brojem većim od zadanog.)

Primjer 2: rječnici koji se ne preklapaju i koji prikazuju 252 kratkih nizova za cijele brojeve i obrnuto:

 % 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 pobjeđuje oko 10 puta. Ovo je prilično velika pobjeda u mojoj knjizi!

Nakon usporedbe ova dva, pitao sam se može li z1 loša izvedba z1 odnositi na opterećenje stvaranjem dva popisa stavki, što me je potaknulo da se pitam može li ova promjena bolje funkcionirati:

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

Neki brzi testovi, na primjer

 % 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 

dovesti me do zaključka da je z3 nešto brži od z1 , ali ne tako brzo kao z2 . Definitivno ne vrijedi sve dodatne tipkanje.

U ovoj raspravi još uvijek nedostaje nešto važno što uspoređuje izvedbu ovih alternativa s "očitim" načinom spajanja dvaju popisa: korištenjem metode update . Da bi pokušali zadržati stvari na jednakim osnovama s izrazima, od kojih niti jedan ne mijenja x ili y, napravit ću kopiju x umjesto da je mijenjam na mjestu kako slijedi:

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

Tipičan rezultat:

 % 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 

Drugim riječima, z0 i z2 izgledaju gotovo isto. Mislite li da je ovo slučajnost? Ja ne ...

Zapravo, išao bih tako daleko da tvrdim da je nemoguće da čisti Python kod učini nešto bolje od ovoga. A ako možete napraviti puno bolje u C proširenje modula, mislim da Python ljudi svibanj dobro biti zainteresirani za uključivanje vašeg koda (ili varijacije vašeg pristupa) u Python jezgri. Python koristi dict na mnogim mjestima; optimizacija poslovanja je velika stvar.

Možete i ovo napisati kao

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

kao što Tony radi, ali (što nije iznenađujuće) razlika u notaciji nema vidljivog učinka na performanse. Koristite ono što vam odgovara. Dakako, apsolutno je u pravu što može reći da je lakše razumjeti verziju s dvije izjave.

123
23 окт. odgovor dat zaphod 23. listopada. 2008-10-23 05:38 '08 u 5:38 2008-10-23 05:38

Htjela sam nešto slično, ali s mogućnošću da odredim kako su kombinirane vrijednosti duplikata ključa, pa sam ga hakirao (ali nisam mnogo testirao). Očito, ovo nije jedan izraz, ali je jedan poziv funkcije.

 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 
91
04 сент. odgovor je dao rcreswick rujan 04 2008-09-04 22:08 '08 u 22:08 2008-09-04 22:08

U Pythonu 3 možete koristiti collections.ChainMap , koji kombinira nekoliko diktata ili drugih mapiranja za stvaranje jednog ažuriranog prikaza:

 >>> 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 
82
28 апр. Odgovor koji je dao Raymond Hettinger 28. travnja 2013-04-28 06:15 '13 u 6:15 2013-04-28 06:15

Rekurzivno / duboko ažuriranje dict

 def deepupdate(original, update): """ Recursively update a dict. Subdict 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 

demonstracija:

 pluto_original = { 'name': 'Pluto', 'details': { 'tail': True, 'color': 'orange' } } pluto_update = { 'name': 'Pluutoo', 'details': { 'color': 'blue' } } print deepupdate(pluto_original, pluto_update) 

izlazi:

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

Hvala vam rednaw za promjene.

66
29 нояб. odgovor je dan Stan 29 Nov. 2011-11-29 14:52 '11 u 14:52 2011-11-29 14:52

Najbolja verzija koju sam mogla zamisliti bez kopiranja bila bi:

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

Ovo je brže od dict(x.items() + y.items()) , ali ne tako brzo kao n = copy(a); n.update(b) n = copy(a); n.update(b) , barem na CPython. Ova verzija također radi u Pythonu 3 ako promijenite iteritems() na items() , što se automatski obavlja pomoću alata 2to3.

Osobno mi se ova verzija najviše sviđa, jer opisuje prilično dobru koja želim u jednoj funkcionalnoj sintaksi. Jedini manji problem je što uopće nije očito da vrijednosti iz y imaju prednost nad vrijednostima iz x, ali ne mislim da je teško razumjeti.

58
14 окт. odgovor je dao driax 14 oct. 2010-10-14 21:55 '10 u 21:55 2010-10-14 21:55
 x = {'a':1, 'b': 2} y = {'b':10, 'c': 11} z = dict(x.items() + y.items()) print z 

Za stavke s ključevima u oba rječnika ('b'), možete kontrolirati koji od njih pada u izlaz stavljanjem drugog.

46
02 сент. odgovor dao Greg Hewgill 02 ruj 2008-09-02 10:49 '08 u 10:49 2008-09-02 10:49

Python 3.5 (PEP 448) omogućuje vam odabir prikladnije sintakse:

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

Ili čak

 final = {'a': 1, 'b': 1, **x, **y} 
46
27 февр. odgovor je dao Bilal Syed Hussain 27. veljače 2015-02-27 00:27 '15 u 0:27 2015-02-27 00:27

Iako je na ovo pitanje već nekoliko puta odgovoreno, ovo jednostavno rješenje problema još nije naznačeno.

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

Ovo je brzo kao z0 i zlo z2, spomenuto gore, ali lako razumljivo i promjenjivo.

39
14 окт. odgovor je dat phobie 14 oct. 2011-10-14 19:12 '11 u 19:12 2011-10-14 19:12
 def dict_merge(a, b): c = a.copy() c.update(b) return c new = dict_merge(old, extras)