How do I merge two dictionaries in a single expression in Python

Python

Python, famed for its elegant syntax and extended libraries, provides a multitude of methods to manipulate information constructions, particularly dictionaries. Merging dictionaries, a communal project successful information manipulation and aggregation, tin beryllium achieved concisely and effectively utilizing Python’s constructed-successful options. This article delves into the about effectual strategies for merging dictionaries successful a azygous look, exploring the nuances of all attack and demonstrating their applicable functions. Knowing these strategies volition undoubtedly streamline your coding procedure and heighten your proficiency successful Python.

Knowing Dictionary Merging

Earlier diving into the specifics, fto’s make clear what merging dictionaries entails. This procedure entails combining the cardinal-worth pairs of 2 oregon much dictionaries into a azygous, unified dictionary. Conflicts, which happen once 2 dictionaries stock the aforesaid cardinal, are dealt with otherwise relying connected the merging methodology employed. Selecting the due methodology is important for preserving information integrity and attaining the desired result.

A elemental analogy is combining component lists from antithetic recipes. You mightiness person 1 dictionary for a bar and different for frosting. Merging them creates a blanket database of components wanted for the full dessert. However you grip duplicate entries (similar sweetener, which mightiness beryllium successful some) is wherever the antithetic merge strategies travel into drama.

Utilizing the Function (Python three.5+)

The treble asterisk () function, launched successful Python three.5, gives the about concise and arguably about Pythonic manner to merge dictionaries. This technique unpacks the dictionaries into a fresh dictionary, efficaciously merging their contents. Successful instances of duplicate keys, the past encountered worth overrides former ones. This behaviour, piece possibly overwriting information, provides a handy manner to prioritize circumstantial dictionaries successful the merge procedure.

For illustration:

dict1 = {'a': 1, 'b': 2} dict2 = {'b': three, 'c': four} merged_dict = {dict1, dict2} mark(merged_dict) Output: {'a': 1, 'b': three, 'c': four}

Arsenic you tin seat, the worth of ‘b’ from dict2 overwrites the worth from dict1.

The dict.replace() Methodology

The replace() technique gives an successful-spot modification attack to merging. This methodology modifies the dictionary it’s known as upon by including cardinal-worth pairs from different dictionary. Akin to the `` function, replace() overwrites values for duplicate keys, with the updating dictionary’s values taking priority. Piece not a azygous look merge, it supplies an businesslike alternate for situations wherever modifying an present dictionary is most popular.

dict1 = {'a': 1, 'b': 2} dict2 = {'b': three, 'c': four} dict1.replace(dict2) mark(dict1) Output: {'a': 1, 'b': three, 'c': four}

Leveraging collections.ChainMap

For situations requiring non-harmful merging and retaining entree to first dictionaries, collections.ChainMap presents a strong resolution. This people creates a azygous position of aggregate dictionaries, enabling lookups crossed each mapped dictionaries successful a concatenation-similar manner. Piece not strictly a merge, it offers akin performance with out altering the first dictionaries. This attack is peculiarly utile once the first dictionaries demand to stay unchanged.

from collections import ChainMap dict1 = {'a': 1, 'b': 2} dict2 = {'b': three, 'c': four} merged_dict = ChainMap(dict1, dict2) mark(merged_dict['b']) Output: 2 (prioritizes the archetypal mapping)

Merging with Dictionary Comprehension

Dictionary comprehension, a almighty characteristic successful Python, permits creating dictionaries primarily based connected present iterables. Piece not arsenic concise arsenic the `` function, it provides flexibility successful dealing with circumstantial merge logic, particularly once dealing with analyzable circumstances oregon transformations. This technique permits for granular power complete the merging procedure.

dict1 = {'a': 1, 'b': 2} dict2 = {'b': three, 'c': four} merged_dict = {ok: v for d successful (dict1, dict2) for okay, v successful d.gadgets()} mark(merged_dict) Output: {'a': 1, 'b': three, 'c': four}

Selecting the Correct Attack

The champion methodology for merging dictionaries relies upon connected the circumstantial necessities of your task. For elemental merges with broad priority guidelines, the `` function oregon replace() methodology supplies concise and businesslike options. Once preserving first dictionaries is paramount, collections.ChainMap affords a invaluable alternate. Eventually, for analyzable merge logic oregon transformations, dictionary comprehensions supply the essential flexibility and power. Knowing the nuances of all technique empowers you to take the about due method for immoderate fixed script.

  • Conciseness: function is the shortest.
  • Successful-spot Modification: replace() modifies the first dictionary.
  1. Measure your wants: Bash you demand to sphere the first dictionaries?
  2. Take a methodology: Choice the attack that champion aligns with your wants and coding kind.
  3. Instrumentality and trial: Guarantee the merged dictionary behaves arsenic anticipated.

Larn much astir dictionaries connected Python’s authoritative documentation.

Larn Much astir PythonFeatured Snippet: The about concise manner to merge dictionaries successful a azygous look successful Python three.5+ is utilizing the `` function, e.g., merged = {dict1, dict2}. For earlier variations oregon much analyzable eventualities, see dict.replace() oregon dictionary comprehension.

[Infographic Placeholder]

FAQ

Q: What occurs if some dictionaries person the aforesaid cardinal?

A: The worth related with the cardinal successful the past dictionary processed volition overwrite former values. The command of dictionaries successful the merging look determines the last worth.

Mastering dictionary merging strategies successful Python is important for businesslike information dealing with. From the concise function to the versatile dictionary comprehensions, Python affords a affluent toolset to cater to assorted merging eventualities. By knowing the nuances of all technique and making use of them judiciously, you tin importantly heighten your coding proficiency and streamline your information manipulation workflows. Research the offered examples and documentation hyperlinks to deepen your knowing and grow your Python skillset. Larn much astir information constructions and algorithms successful Python by visiting authoritative sources similar Existent Python and GeeksforGeeks. You tin besides delve deeper into dictionary manipulations by checking retired this tutorial connected W3Schools.

Question & Answer :
I privation to merge 2 dictionaries into a fresh dictionary.

x = {'a': 1, 'b': 2}y = {'b': three, 'c': four}z = merge(x, y)>>> z{'a': 1, 'b': three, 'c': four}

At any time when a cardinal okay is immediate successful some dictionaries, lone the worth y[okay] ought to beryllium stored.

However tin I merge 2 Python dictionaries successful a azygous look?

For dictionaries x and y, their shallowly-merged dictionary z takes values from y, changing these from x.

  • Successful Python three.9.zero oregon larger (launched 17 October 2020, PEP-584, mentioned present):

    z = x | y

  • Successful Python three.5 oregon higher:

    z = {**x, **y}

  • Successful Python 2, (oregon three.four oregon less) compose a relation:

    def merge_two_dicts(x, y): z = x.transcript() # commencement with keys and values of x z.replace(y) # modifies z with keys and values of y instrument z

    and present:

    z = merge_two_dicts(x, y)

Mentation

Opportunity you person 2 dictionaries and you privation to merge them into a fresh dictionary with out altering the first dictionaries:

x = {'a': 1, 'b': 2}y = {'b': three, 'c': four}

The desired consequence is to acquire a fresh dictionary (z) with the values merged, and the 2nd dictionary’s values overwriting these from the archetypal.

>>> z{'a': 1, 'b': three, 'c': four}

A fresh syntax for this, projected successful PEP 448 and disposable arsenic of Python three.5, is

z = {**x, **y}

And it is so a azygous look.

Line that we tin merge successful with literal notation arsenic fine:

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

and present:

>>> z{'a': 1, 'b': three, 'foo': 1, 'barroom': 2, 'c': four}

It is present exhibiting arsenic applied successful the merchandise agenda for three.5, PEP 478, and it has present made its manner into the What’s Fresh successful Python three.5 papers.

Nevertheless, since galore organizations are inactive connected Python 2, you whitethorn want to bash this successful a backward-suitable manner. The classically Pythonic manner, disposable successful Python 2 and Python three.zero-three.four, is to bash this arsenic a 2-measure procedure:

z = x.transcript()z.replace(y) # which returns No since it mutates z

Successful some approaches, y volition travel 2nd and its values volition regenerate x’s values, frankincense b volition component to three successful our last consequence.

Not but connected Python three.5, however privation a azygous look

If you are not but connected Python three.5 oregon demand to compose backward-appropriate codification, and you privation this successful a azygous look, the about performant piece the accurate attack is to option it successful a relation:

def merge_two_dicts(x, y): """Fixed 2 dictionaries, merge them into a fresh dict arsenic a shallow transcript.""" z = x.transcript() z.replace(y) instrument z

and past you person a azygous look:

z = merge_two_dicts(x, y)

You tin besides brand a relation to merge an arbitrary figure of dictionaries, from zero to a precise ample figure:

def merge_dicts(*dict_args): """ Fixed immoderate figure of dictionaries, shallow transcript and merge into a fresh dict, priority goes to cardinal-worth pairs successful second dictionaries. """ consequence = {} for dictionary successful dict_args: consequence.replace(dictionary) instrument consequence

This relation volition activity successful Python 2 and three for each dictionaries. e.g. fixed dictionaries a to g:

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

and cardinal-worth pairs successful g volition return priority complete dictionaries a to f, and truthful connected.

Critiques of Another Solutions

Don’t usage what you seat successful the previously accepted reply:

z = dict(x.gadgets() + y.objects())

Successful Python 2, you make 2 lists successful representation for all dict, make a 3rd database successful representation with dimension close to the dimension of the archetypal 2 option unneurotic, and past discard each 3 lists to make the dict. Successful Python three, this volition neglect due to the fact that you’re including 2 dict_items objects unneurotic, not 2 lists -

>>> c = dict(a.objects() + b.gadgets())Traceback (about new call past): Record "<stdin>", formation 1, successful <module>TypeError: unsupported operand kind(s) for +: 'dict_items' and 'dict_items'

and you would person to explicitly make them arsenic lists, e.g. z = dict(database(x.gadgets()) + database(y.objects())). This is a discarded of assets and computation powerfulness.

Likewise, taking the federal of gadgets() successful Python three (viewitems() successful Python 2.7) volition besides neglect once values are unhashable objects (similar lists, for illustration). Equal if your values are hashable, since units are semantically unordered, the behaviour is undefined successful regards to priority. Truthful don’t bash this:

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

This illustration demonstrates what occurs once values are unhashable:

>>> x = {'a': []}>>> y = {'b': []}>>> dict(x.gadgets() | y.gadgets())Traceback (about new call past): Record "<stdin>", formation 1, successful <module>TypeError: unhashable kind: 'database'

Present’s an illustration wherever y ought to person priority, however alternatively the worth from x is retained owed to the arbitrary command of units:

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

Different hack you ought to not usage:

z = dict(x, **y)

This makes use of the dict constructor and is precise accelerated and representation-businesslike (equal somewhat much truthful than our 2-measure procedure) however until you cognize exactly what is occurring present (that is, the 2nd dict is being handed arsenic key phrase arguments to the dict constructor), it’s hard to publication, it’s not the meant utilization, and truthful it is not Pythonic.

Present’s an illustration of the utilization being remediated successful django.

Dictionaries are meant to return hashable keys (e.g. frozensets oregon tuples), however this technique fails successful Python three once keys are not strings.

>>> c = dict(a, **b)Traceback (about new call past): Record "<stdin>", formation 1, successful <module>TypeError: key phrase arguments essential beryllium strings

From the mailing database, Guido van Rossum, the creator of the communication, wrote:

I americium good withdeclaring dict({}, **{1:three}) amerciable, since last each it is maltreatment ofthe ** mechanics.

and

Seemingly dict(x, **y) is going about arsenic “chill hack” for “callx.replace(y) and instrument x”. Personally, I discovery it much despicable thancool.

It is my knowing (arsenic fine arsenic the knowing of the creator of the communication) that the meant utilization for dict(**y) is for creating dictionaries for readability functions, e.g.:

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

alternatively of

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

Consequence to feedback

Contempt what Guido says, dict(x, **y) is successful formation with the dict specification, which btw. plant for some Python 2 and three. The information that this lone plant for drawstring keys is a nonstop effect of however key phrase parameters activity and not a abbreviated-coming of dict. Nor is utilizing the ** function successful this spot an maltreatment of the mechanics, successful information, ** was designed exactly to walk dictionaries arsenic key phrases.

Once more, it doesn’t activity for three once keys are not strings. The implicit calling declaration is that namespaces return average dictionaries, piece customers essential lone walk key phrase arguments that are strings. Each another callables enforced it. dict broke this consistency successful Python 2:

>>> foo(**{('a', 'b'): No})Traceback (about new call past): Record "<stdin>", formation 1, successful <module>TypeError: foo() key phrases essential beryllium strings>>> dict(**{('a', 'b'): No}){('a', 'b'): No}

This inconsistency was atrocious fixed another implementations of Python (PyPy, Jython, IronPython). Frankincense it was fastened successful Python three, arsenic this utilization might beryllium a breaking alteration.

I subject to you that it is malicious incompetence to deliberately compose codification that lone plant successful 1 interpretation of a communication oregon that lone plant fixed definite arbitrary constraints.

Much feedback:

dict(x.objects() + y.gadgets()) is inactive the about readable resolution for Python 2. Readability counts.

My consequence: merge_two_dicts(x, y) really appears overmuch clearer to maine, if we’re really afraid astir readability. And it is not guardant appropriate, arsenic Python 2 is progressively deprecated.

{**x, **y} does not look to grip nested dictionaries. the contents of nested keys are merely overwritten, not merged […] I ended ahead being burnt by these solutions that bash not merge recursively and I was amazed nary 1 talked about it. Successful my explanation of the statement “merging” these solutions depict “updating 1 dict with different”, and not merging.

Sure. I essential mention you backmost to the motion, which is asking for a shallow merge of 2 dictionaries, with the archetypal’s values being overwritten by the 2nd’s - successful a azygous look.

Assuming 2 dictionaries of dictionaries, 1 mightiness recursively merge them successful a azygous relation, however you ought to beryllium cautious not to modify the dictionaries from both origin, and the surest manner to debar that is to brand a transcript once assigning values. Arsenic keys essential beryllium hashable and are normally so immutable, it is pointless to transcript them:

from transcript import deepcopydef dict_of_dicts_merge(x, y): z = {} overlapping_keys = x.keys() & y.keys() for cardinal successful overlapping_keys: z[cardinal] = dict_of_dicts_merge(x[cardinal], y[cardinal]) for cardinal successful x.keys() - overlapping_keys: z[cardinal] = deepcopy(x[cardinal]) for cardinal successful y.keys() - overlapping_keys: z[cardinal] = deepcopy(y[cardinal]) instrument z

Utilization:

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

Coming ahead with contingencies for another worth sorts is cold past the range of this motion, truthful I volition component you astatine my reply to the canonical motion connected a “Dictionaries of dictionaries merge”.

Little Performant However Accurate Advertisement-hocs

These approaches are little performant, however they volition supply accurate behaviour.They volition beryllium overmuch little performant than transcript and replace oregon the fresh unpacking due to the fact that they iterate done all cardinal-worth brace astatine a increased flat of abstraction, however they bash regard the command of priority (second dictionaries person priority)

You tin besides concatenation the dictionaries manually wrong a dict comprehension:

{okay: v for d successful dicts for ok, v successful d.objects()} # iteritems successful Python 2.7

oregon successful Python 2.6 (and possibly arsenic aboriginal arsenic 2.four once generator expressions had been launched):

dict((ok, v) for d successful dicts for okay, v successful d.gadgets()) # iteritems successful Python 2

itertools.concatenation volition concatenation the iterators complete the cardinal-worth pairs successful the accurate command:

from itertools import chainz = dict(concatenation(x.gadgets(), y.objects())) # iteritems successful Python 2

Show Investigation

I’m lone going to bash the show investigation of the usages identified to behave accurately. (Same-contained truthful you tin transcript and paste your self.)

from timeit import repeatfrom itertools import chainx = dict.fromkeys('abcdefg')y = dict.fromkeys('efghijk')def merge_two_dicts(x, y): z = x.transcript() z.replace(y) instrument zmin(repetition(lambda: {**x, **y}))min(repetition(lambda: merge_two_dicts(x, y)))min(repetition(lambda: {okay: v for d successful (x, y) for ok, v successful d.gadgets()}))min(repetition(lambda: dict(concatenation(x.gadgets(), y.gadgets()))))min(repetition(lambda: dict(point for d successful (x, y) for point successful d.gadgets())))

Successful Python three.eight.1, NixOS:

>>> min(repetition(lambda: {**x, **y}))1.0804965235292912>>> min(repetition(lambda: merge_two_dicts(x, y)))1.636518670246005>>> min(repetition(lambda: {ok: v for d successful (x, y) for okay, v successful d.gadgets()}))three.1779992282390594>>> min(repetition(lambda: dict(concatenation(x.objects(), y.gadgets()))))2.740647904574871>>> min(repetition(lambda: dict(point for d successful (x, y) for point successful d.gadgets())))four.266070580109954

$ uname -aLinux nixos four.19.113 #1-NixOS SMP Wed Mar 25 07:06:15 UTC 2020 x86_64 GNU/Linux

Sources connected Dictionaries