How do I merge two dictionaries in a single expression taking union of dictionaries

Question

I have two Python dictionaries  and I want to write a single expression that returns these two dictionaries  merged  i e  taking the union    The update   method would be what I need  if it returned its result instead of modifying a dictionary in-place   gt  gt  gt  x     a   1   b   2   gt  gt  gt  y     b   10   c   11   gt  gt  gt  z   x update y   gt  gt  gt  print z  None  gt  gt  gt  x   a   1   b   10   c   11   How can I get that final merged dictionary in z  not x   To be extra-clear  the last-one-wins conflict-handling of dict update   is what I m looking for as well

User · Answer

I have a solution which is not specified here z      z update x  or z update y   This will not update x as well as y  Performance  I don t think it will be terribly slow

User · Answer

I think my ugly one-liners are just necessary here   z   next z update y  or z for z in  x copy       or z    lambda z  z update y  or z  x copy       Dicts are merged  Single expression  Don t ever dare to use it    P S  This is a solution working in both versions of Python  I know that Python 3 has this    x    y  thing and it is the right thing to use  as well as moving to Python 3 if you still have Python 2 is the right thing to do

User · Answer

Simple solution using itertools that preserves order  latter dicts have precedence    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     And it s usage   gt  gt  gt  x     a  1   b   2   gt  gt  gt  y     b  10   c   11   gt  gt  gt  merge x  y    a   1   b   10   c   11    gt  gt  gt  z     c   3   d   4   gt  gt  gt  merge x  y  z    a   1   b   10   c   3   d   4

User · Answer

A union of the OP s two dictionaries would be something like     a   1   b   2  10   c   11    Specifically  the union of two entities x and y  contains all the elements of x and or y  Unfortunately  what the OP asks for is not a union  despite the title of the post   My code below is neither elegant nor a one-liner  but I believe it is consistent with the meaning of union   From the OP s example   x     a  1   b   2  y     b  10   c   11   z      for k  v in x items        if not k in z          z k      v       else          z k  append  v   for k  v in y items        if not k in z          z k      v       else          z k  append  v      a    1    b    2  10    c    11     Whether one wants lists could be changed  but the above will work if a dictionary contains lists  and nested lists  as values in either dictionary

User · Answer

It s so silly that  update returns nothing  I just use a simple helper function to solve the problem   def merge dict1  dicts       for dict2 in dicts          dict1 update dict2      return dict1   Examples   merge dict1 dict2  merge dict1 dict2 dict3  merge dict1 dict2 dict3 dict4  merge    dict1 dict2     this one returns a new copy

User · Answer

This probably won t be a popular answer  but you almost certainly do not want to do this   If you want a copy that s a merge  then use copy  or deepcopy  depending on what you want  and then update   The two lines of code are much more readable - more Pythonic - than the single line creation with  items      items     Explicit is better than implicit   In addition  when you use  items    pre Python 3 0   you re creating a new list that contains the items from the dict   If your dictionaries are large  then that is quite a lot of overhead  two large lists that will be thrown away as soon as the merged dict is created    update   can work more efficiently  because it can run through the second dict item-by-item   In terms of time    gt  gt  gt  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  gt  gt  gt  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  gt  gt  gt  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 the tiny slowdown between the first two is worth it for the readability   In addition  keyword arguments for dictionary creation was only added in Python 2 3  whereas copy   and update   will work in older versions

User · Answer

Abuse leading to a one-expression solution for Matthew s answer    gt  gt  gt  x     a  1   b   2   gt  gt  gt  y     b  10   c   11   gt  gt  gt  z    lambda f x copy     f update y   f  1      gt  gt  gt  z   a   1   c   11   b   10    You said you wanted one expression  so I abused lambda to bind a name  and tuples to override lambda s one-expression limit  Feel free to cringe   You could also do this of course if you don t care about copying it    gt  gt  gt  x     a  1   b   2   gt  gt  gt  y     b  10   c   11   gt  gt  gt  z    x update y   x  1   gt  gt  gt  z   a   1   b   10   c   11

User · Answer

In a follow-up answer  you asked about the relative performance of these two alternatives   z1   dict x items     y items    z2   dict x    y    On my machine  at least  a fairly ordinary x86 64 running Python 2 5 2   alternative z2 is not only shorter and simpler but also significantly faster   You can verify this for yourself using the timeit module that comes with Python   Example 1  identical dictionaries mapping 20 consecutive integers to themselves     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 wins by a factor of 3 5 or so   Different dictionaries seem to yield quite different results  but z2 always seems to come out ahead    If you get inconsistent results for the same test  try passing in -r with a number larger than the default 3    Example 2  non-overlapping dictionaries mapping 252 short strings to integers and 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 wins by about a factor of 10   That s a pretty big win in my book   After comparing those two  I wondered if z1 s poor performance could be attributed to the overhead of constructing the two item lists  which in turn led me to wonder if this variation might work better   from itertools import chain z3   dict chain x iteritems    y iteritems       A few quick tests  e g     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   lead me to conclude that z3 is somewhat faster than z1  but not nearly as fast as z2   Definitely not worth all the extra typing   This discussion is still missing something important  which is a performance comparison of these alternatives with the  obvious  way of merging two lists  using the update method   To try to keep things on an equal footing with the expressions  none of which modify x or y  I m going to make a copy of x instead of modifying it in-place  as follows   z0   dict x  z0 update y    A typical result     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   In other words  z0 and z2 seem to have essentially identical performance   Do you think this might be a coincidence   I don t      In fact  I d go so far as to claim that it s impossible for pure Python code to do any better than this   And if you can do significantly better in a C extension module  I imagine the Python folks might well be interested in incorporating your code  or a variation on your approach  into the Python core   Python uses dict in lots of places  optimizing its operations is a big deal   You could also write this as  z0   x copy   z0 update y    as Tony does  but  not surprisingly  the difference in notation turns out not to have any measurable effect on performance   Use whichever looks right to you   Of course  he s absolutely correct to point out that the two-statement version is much easier to understand

User · Answer

Python 3 9  only  Merge     and update      operators have been added to the built-in dict class    gt  gt  gt  d     spam   1   eggs   2   cheese   3   gt  gt  gt  e     cheese    cheddar    aardvark    Ethel    gt  gt  gt  d   e   spam   1   eggs   2   cheese    cheddar    aardvark    Ethel     The augmented assignment version operates in-place    gt  gt  gt  d    e  gt  gt  gt  d   spam   1   eggs   2   cheese    cheddar    aardvark    Ethel     See PEP 584

User · Answer

For Python2 7  only  there are simpler solutions for Python3     If you re not averse to importing a standard library module  you can do  from functools import reduce  def merge dicts  dicts       return reduce lambda a  d  a update d  or a  dicts         The or a bit in the lambda is necessary because dict update always returns None on success

User · Answer

There will be a new option when Python 3 8 releases  scheduled for 20 October  2019   thanks to PEP 572  Assignment Expressions  The new assignment expression operator    allows you to assign the result of the copy and still use it to call update  leaving the combined code a single expression  rather than two statements  changing   newdict   dict1 copy   newdict update dict2    to    newdict    dict1 copy    update dict2    while behaving identically in every way  If you must also return the resulting dict  you asked for an expression returning the dict  the above creates and assigns to newdict  but doesn t return it  so you couldn t use it to pass an argument to a function as is  a la myfunc  newdict    dict1 copy    update dict2     then just add or newdict to the end  since update returns None  which is falsy  it will then evaluate and return newdict as the result of the expression     newdict    dict1 copy    update dict2  or newdict   Important caveat  In general  I d discourage this approach in favor of   newdict      dict1    dict2    The unpacking approach is clearer  to anyone who knows about generalized unpacking in the first place  which you should   doesn t require a name for the result at all  so it s much more concise when constructing a temporary that is immediately passed to a function or included in a list tuple literal or the like   and is almost certainly faster as well  being  on CPython  roughly equivalent to   newdict      newdict update dict1  newdict update dict2    but done at the C layer  using the concrete dict API  so no dynamic method lookup binding or function call dispatch overhead is involved  where  newdict    dict1 copy    update dict2  is unavoidably identical to the original two-liner in behavior  performing the work in discrete steps  with dynamic lookup binding invocation of methods   It s also more extensible  as merging three dicts is obvious    newdict      dict1    dict2    dict3    where using assignment expressions won t scale like that  the closest you could get would be     newdict    dict1 copy    update dict2   newdict update dict3    or without the temporary tuple of Nones  but with truthiness testing of each None result     newdict    dict1 copy    update dict2  or newdict update dict3    either of which is obviously much uglier  and includes further inefficiencies  either a wasted temporary tuple of Nones for comma separation  or pointless truthiness testing of each update s None return for or separation    The only real advantage to the assignment expression approach occurs if    You have generic code that needs handle both sets and dicts  both of them support copy and update  so the code works roughly as you d expect it to  You expect to receive arbitrary dict-like objects  not just dict itself  and must preserve the type and semantics of the left hand side  rather than ending up with a plain dict   While myspecialdict    speciala    specialb   might work  it would involve an extra temporary dict  and if myspecialdict has features plain dict can t preserve  e g  regular dicts now preserve order based on the first appearance of a key  and value based on the last appearance of a key  you might want one that preserves order based on the last appearance of a key so updating a value also moves it to the end   then the semantics would be wrong  Since the assignment expression version uses the named methods  which are presumably overloaded to behave appropriately   it never creates a dict at all  unless dict1 was already a dict   preserving the original type  and original type s semantics   all while avoiding any temporaries

User · Answer

The question is tagged python-3x but  taking into account that it s a relatively recent addition and that the most voted  accepted answer deals extensively with a Python 2 x solution  I dare add a one liner that draws on an irritating feature of Python 2 x list comprehension  that is name leaking       python2 Python 2 7 13  default  Jan 19 2017  14 48 08    GCC 6 3 0 20170118  on linux2 Type  help    copyright    credits  or  license  for more information   gt  gt  gt  x     a  1   b   2   gt  gt  gt  y     b  10   c   11   gt  gt  gt   z update d  for z in      for d in  x  y    None  None   gt  gt  gt  z   a   1   c   11   b   10   gt  gt  gt        I m happy to say that the above doesn t work any more on any version of Python 3

User · Answer

I benchmarked the suggested with perfplot and found that the good old temp   x copy   temp update y   is the fastest solution together with the new x   y    Code to reproduce the plot  from collections import ChainMap from itertools import chain import perfplot   def setup n       x   dict zip range n   range n        y   dict zip range n  2   n   range n  2   n        return x  y   def copy update data       x  y   data     temp   x copy       temp update y      return temp   def add items data       x  y   data     return dict list x items      list y items       def curly star data       x  y   data     return    x    y    def chain map data       x  y   data     return dict ChainMap     y  x     def itertools chain data       x  y   data     return dict chain x items    y items       def python39 concat data       x  y   data     return x   y   perfplot show      setup setup      kernels           copy update          add items          curly star          chain map          itertools chain          python39 concat             labels            quot copy update quot            quot dict list x items      list y items     quot            quot    x    y  quot            quot chain map quot            quot itertools chain quot            quot x   y quot              n range  2    k for k in range 15        xlabel  quot len x   len y  quot       equality check None

User · Answer

Drawing on ideas here and elsewhere I ve comprehended a function   def merge  dicts    kv          return   k v for d in list dicts     kv  for k v in d items       Usage  tested in 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     You could use a lambda instead

User · Answer

How can I merge two Python dictionaries in a single expression   For dictionaries x and y  z becomes a shallowly merged dictionary with values from y replacing those from x   In Python 3 9 0 or greater  released 17 October 2020   PEP-584  discussed here  was implemented and provides the simplest method  z   x   y            NOTE  3 9  ONLY   In Python 3 5 or greater  z      x    y    In Python 2   or 3 4 or lower  write a function  def merge two dicts x  y       z   x copy       start with x s keys and values     z update y       modifies z with y s keys and values  amp  returns None     return z  and now  z   merge two dicts x  y     Explanation Say you have two dictionaries and you want to merge them into a new dict without altering the original dictionaries  x     a   1   b   2  y     b   3   c   4   The desired result is to get a new dictionary  z  with the values merged  and the second dictionary s values overwriting those from the first   gt  gt  gt  z   a   1   b   3   c   4   A new syntax for this  proposed in PEP 448 and available as of Python 3 5  is z      x    y   And it is indeed a single expression  Note that we can merge in with literal notation as well  z      x   foo   1   bar   2    y   and now   gt  gt  gt  z   a   1   b   3   foo   1   bar   2   c   4   It is now showing as implemented in the release schedule for 3 5  PEP 478  and it has now made its way into What s New in Python 3 5 document  However  since many organizations are still on Python 2  you may wish to do this in a backward-compatible way  The classically Pythonic way  available in Python 2 and Python 3 0-3 4  is to do this as a two-step process  z   x copy   z update y    which returns None since it mutates z  In both approaches  y will come second and its values will replace x s values  thus  b  will point to 3 in our final result  Not yet on Python 3 5  but want a single expression If you are not yet on Python 3 5 or need to write backward-compatible code  and you want this in a single expression  the most performant while the correct approach is to put it in a function  def merge two dicts x  y        quot  quot  quot Given two dictionaries  merge them into a new dict as a shallow copy  quot  quot  quot      z   x copy       z update y      return z  and then you have a single expression  z   merge two dicts x  y   You can also make a function to merge an undefined number of dictionaries  from zero to a very large number  def merge dicts  dict args        quot  quot  quot      Given any number of dictionaries  shallow copy and merge into a new dict      precedence goes to key-value pairs in latter dictionaries       quot  quot  quot      result          for dictionary in dict args          result update dictionary      return result  This function will work in Python 2 and 3 for all dictionaries  e g  given dictionaries a to g  z   merge dicts a  b  c  d  e  f  g    and key-value pairs in g will take precedence over dictionaries a to f  and so on  Critiques of Other Answers Don t use what you see in the formerly accepted answer  z   dict x items     y items     In Python 2  you create two lists in memory for each dict  create a third list in memory with length equal to the length of the first two put together  and then discard all three lists to create the dict  In Python 3  this will fail because you re adding two dict items objects together  not two lists -  gt  gt  gt  c   dict a items     b items    Traceback  most recent call last     File  quot  lt stdin gt  quot   line 1  in  lt module gt  TypeError  unsupported operand type s  for     dict items  and  dict items   and you would have to explicitly create them as lists  e g  z   dict list x items      list y items      This is a waste of resources and computation power  Similarly  taking the union of items   in Python 3  viewitems   in Python 2 7  will also fail when values are unhashable objects  like lists  for example   Even if your values are hashable  since sets are semantically unordered  the behavior is undefined in regards to precedence  So don t do this   gt  gt  gt  c   dict a items     b items     This example demonstrates what happens when values are unhashable   gt  gt  gt  x     a        gt  gt  gt  y     b        gt  gt  gt  dict x items     y items    Traceback  most recent call last     File  quot  lt stdin gt  quot   line 1  in  lt module gt  TypeError  unhashable type   list   Here s an example where y should have precedence  but instead the value from x is retained due to the arbitrary order of sets   gt  gt  gt  x     a   2   gt  gt  gt  y     a   1   gt  gt  gt  dict x items     y items      a   2   Another hack you should not use  z   dict x    y   This uses the dict constructor and is very fast and memory-efficient  even slightly more-so than our two-step process  but unless you know precisely what is happening here  that is  the second dict is being passed as keyword arguments to the dict constructor   it s difficult to read  it s not the intended usage  and so it is not Pythonic  Here s an example of the usage being remediated in django  Dictionaries are intended to take hashable keys  e g  frozensets or tuples   but this method fails in Python 3 when keys are not strings   gt  gt  gt  c   dict a    b  Traceback  most recent call last     File  quot  lt stdin gt  quot   line 1  in  lt module gt  TypeError  keyword arguments must be strings  From the mailing list  Guido van Rossum  the creator of the language  wrote   I am fine with declaring dict        1 3   illegal  since after all it is abuse of the    mechanism   and  Apparently dict x    y  is going around as  quot cool hack quot  for  quot call x update y  and return x quot   Personally  I find it more despicable than cool   It is my understanding  as well as the understanding of the creator of the language  that the intended usage for dict   y  is for creating dictionaries for readability purposes  e g   dict a 1  b 10  c 11   instead of   a   1   b   10   c   11   Response to comments  Despite what Guido says  dict x    y  is in line with the dict specification  which btw  works for both Python 2 and 3  The fact that this only works for string keys is a direct consequence of how keyword parameters work and not a short-coming of dict  Nor is using the    operator in this place an abuse of the mechanism  in fact     was designed precisely to pass dictionaries as keywords   Again  it doesn t work for 3 when keys are non-strings  The implicit calling contract is that namespaces take ordinary dictionaries  while users must only pass keyword arguments that are strings  All other callables enforced it  dict broke this consistency in Python 2   gt  gt  gt  foo      a    b    None   Traceback  most recent call last     File  quot  lt stdin gt  quot   line 1  in  lt module gt  TypeError  foo   keywords must be strings  gt  gt  gt  dict      a    b    None      a    b    None   This inconsistency was bad given other implementations of Python  Pypy  Jython  IronPython   Thus it was fixed in Python 3  as this usage could be a breaking change  I submit to you that it is malicious incompetence to intentionally write code that only works in one version of a language or that only works given certain arbitrary constraints  More comments   dict x items     y items    is still the most readable solution for Python 2  Readability counts   My response  merge two dicts x  y  actually seems much clearer to me  if we re actually concerned about readability  And it is not forward compatible  as Python 2 is increasingly deprecated      x    y  does not seem to handle nested dictionaries  the contents of nested keys are simply overwritten  not merged       I ended up being burnt by these answers that do not merge recursively and I was surprised no one mentioned it  In my interpretation of the word  quot merging quot  these answers describe  quot updating one dict with another quot   and not merging   Yes  I must refer you back to the question  which is asking for a shallow merge of two dictionaries  with the first s values being overwritten by the second s - in a single expression  Assuming two dictionaries of dictionaries  one might recursively merge them in a single function  but you should be careful not to modify the dictionaries from either source  and the surest way to avoid that is to make a copy when assigning values  As keys must be hashable and are usually therefore immutable  it is pointless to copy them  from copy import deepcopy  def dict of dicts merge x  y       z          overlapping keys   x keys    amp  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  Usage   gt  gt  gt  x     a   1       b    2       gt  gt  gt  y     b   10       c    11       gt  gt  gt  dict of dicts merge x  y    b    2      10        a    1        c    11        Coming up with contingencies for other value types is far beyond the scope of this question  so I will point you at my answer to the canonical question on a  quot Dictionaries of dictionaries merge quot   Less Performant But Correct Ad-hocs These approaches are less performant  but they will provide correct behavior  They will be much less performant than copy and update or the new unpacking because they iterate through each key-value pair at a higher level of abstraction  but they do respect the order of precedence  latter dictionaries have precedence  You can also chain the dictionaries manually inside a dict comprehension   k  v for d in dicts for k  v in d items      iteritems in Python 2 7  or in python 2 6  and perhaps as early as 2 4 when generator expressions were introduced   dict  k  v  for d in dicts for k  v in d items      iteritems in Python 2  itertools chain will chain the iterators over the key-value pairs in the correct order  from itertools import chain z   dict chain x items    y items       iteritems in Python 2  Performance Analysis I m only going to do the performance analysis of the usages known to behave correctly   Self-contained so you can copy and paste yourself   from timeit import repeat from itertools import chain  x   dict fromkeys  abcdefg   y   dict fromkeys  efghijk    def merge two dicts x  y       z   x copy       z update y      return z  min repeat lambda     x    y    min repeat lambda  merge two dicts x  y    min repeat lambda   k  v for d in  x  y  for k  v in d items      min repeat lambda  dict chain x items    y items       min repeat lambda  dict item for d in  x  y  for item in d items       In Python 3 8 1  NixOS   gt  gt  gt  min repeat lambda     x    y    1 0804965235292912  gt  gt  gt  min repeat lambda  merge two dicts x  y    1 636518670246005  gt  gt  gt  min repeat lambda   k  v for d in  x  y  for k  v in d items      3 1779992282390594  gt  gt  gt  min repeat lambda  dict chain x items    y items       2 740647904574871  gt  gt  gt  min repeat lambda  dict item for d in  x  y  for item in d items      4 266070580109954    uname -a Linux nixos 4 19 113  1-NixOS SMP Wed Mar 25 07 06 15 UTC 2020 x86 64 GNU Linux  Resources on Dictionaries  My explanation of Python s dictionary implementation  updated for 3 6  Answer on how to add new keys to a dictionary Mapping two lists into a dictionary The official Python docs on dictionaries The Dictionary Even Mightier - talk by Brandon Rhodes at Pycon 2017 Modern Python Dictionaries  A Confluence of Great Ideas - talk by Raymond Hettinger at Pycon 2017

User · Answer

Even though the answers were good for this shallow dictionary  none of the methods defined here actually do a deep dictionary merge   Examples follow   a      one      depth 2   True     two   True   b      one      extra   False     print dict a items     b items      One would expect a result of something like this      one      extra   False    depth 2   True     two   True     Instead  we get this     two   True   one     extra   False     The  one  entry should have had  depth 2  and  extra  as items inside its dictionary if it truly was a merge   Using chain also  does not work   from itertools import chain print dict chain a iteritems    b iteritems       Results in     two   True   one     extra   False     The deep merge that rcwesick gave also creates the same result   Yes  it will work to merge the sample dictionaries  but none of them are a generic mechanism to merge   I ll update this later once I write a method that does a true merge

User · Answer

I wanted something similar  but with the ability to specify how the values on duplicate keys were merged  so I hacked this out  but did not heavily test it    Obviously this is not a single expression  but it is a single function call   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        gt  gt  gt  d1       a   1   c   3   b   2       gt  gt  gt  merge d1  d1        a   1   c   3   b   2       gt  gt  gt  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

User · Answer

Python 3 5  PEP 448  allows a nicer syntax option   x     a   1   b   1  y     a   2   c   2  final      x    y   final     a   2   b   1   c   2    Or even   final     a   1   b   1    x    y    In Python 3 9 you also use   and    with the below example from PEP 584  d     spam   1   eggs   2   cheese   3  e     cheese    cheddar    aardvark    Ethel   d   e     spam   1   eggs   2   cheese    cheddar    aardvark    Ethel

User · Answer

If you don t mind mutating x  x update y  or x  Simple  readable  performant  You know update   always returns None  which is a false value  So the above expression will always evaluate to x  after updating it  Most mutating methods in the standard library  like  update    return None by convention  so this kind of pattern will work on those too  However  if you re using a dict subclass or some other method that doesn t follow this convention  then or may return its left operand  which may not be what you want  Instead  you can use a tuple display and index  which works regardless of what the first element evaluates to  although it s not quite as pretty    x update y   x  -1   If you don t have x in a variable yet  you can use lambda to make a local without using an assignment statement  This amounts to using lambda as a let expression  which is a common technique in functional languages  but maybe unpythonic   lambda x  x update y  or x    a   1   b   2    Although it s not that different from the following use of the new walrus operator  Python 3 8  only    x      a   1   b   2   update y  or x  If you do want a copy  PEP 584 style x   y is the most Pythonic on 3 9   If you must support older versions  PEP 448 style    x    y  is easiest for 3 5   But if that s not available in your  even older  Python version  the let pattern works here too   lambda z  z update y  or z  x copy      That is  of course  nearly equivalent to  z    x copy    update y  or z  but if your Python version is new enough for that  then the PEP 448 style will be available

User · Answer

x     a  1   b   2  y     b  10   c   11  z   dict x items     y items    print z   For items with keys in both dictionaries   b    you can control which one ends up in the output by putting that one last

User · Answer

In python3  the items method no longer returns a list  but rather a view  which acts like a set  In this case you ll need to take the set union since concatenating with   won t work   dict x items     y items      For python3-like behavior in version 2 7  the viewitems method should work in place of items   dict x viewitems     y viewitems      I prefer this notation anyways since it seems more natural to think of it as a set union operation rather than concatenation  as the title shows    Edit   A couple more points for python 3  First  note that the dict x    y  trick won t work in python 3 unless the keys in y are strings   Also  Raymond Hettinger s Chainmap answer is pretty elegant  since it can take an arbitrary number of dicts as arguments  but from the docs it looks like it sequentially looks through a list of all the dicts for each lookup      Lookups search the underlying mappings successively until a key is found    This can slow you down if you have a lot of lookups in your 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   So about an order of magnitude slower for lookups  I m a fan of Chainmap  but looks less practical where there may be many lookups

User · Answer

New in Python 3 9  Use the union operator     to merge dicts similar to sets   gt  gt  gt  d     a   1   b   2   gt  gt  gt  e     a   9   c   3   gt  gt  gt  d   e   a   9   b   2   c   3   For matching keys  the right dict takes precedence  This also works for    to modify a dict in-place   gt  gt  gt  e    d      e   e   d  gt  gt  gt  e   a   1   c   3   b   2

User · Answer

You can use toolz merge  x  y   for this

User · Answer

In Python 3 0 and later  you can use collections ChainMap which groups multiple dicts or other mappings together to create a single  updateable view   gt  gt  gt  from collections import ChainMap  gt  gt  gt  x     a  1   b   2   gt  gt  gt  y     b  10   c   11   gt  gt  gt  z   dict ChainMap     y  x    gt  gt  gt  for k  v in z items            print k   -- gt    v       a -- gt  1 b -- gt  10 c -- gt  11  Update for Python 3 5 and later  You can use PEP 448 extended dictionary packing and unpacking   This is fast and easy   gt  gt  gt  x     a  1   b   2   gt  gt  gt  y     b  10   c   11   gt  gt  gt     x    y    a   1   b   10   c   11   Update for Python 3 9 and later   You can use the PEP 584 union operator   gt  gt  gt  x     a  1   b   2   gt  gt  gt  y     b  10   c   11   gt  gt  gt  x   y   a   1   b   10   c   11

User · Answer

In your case  what you can do is  z   dict list x items      list y items      This will  as you want it  put the final dict in z  and make the value for key b be properly overridden by the second  y  dict s value   gt  gt  gt  x     a  1   b   2   gt  gt  gt  y     b  10   c   11   gt  gt  gt  z   dict list x items      list y items      gt  gt  gt  z   a   1   c   11   b   10    If you use Python 2  you can even remove the list   calls  To create z   gt  gt  gt  z   dict x items     y items     gt  gt  gt  z   a   1   c   11   b   10   If you use Python version 3 9 0a4 or greater  then you can directly use  x     a  1   b   2  y     b  10   c   11  z   x   y print z     a   1   c   11   b   10

User · Answer

For Python 3   from collections import ChainMap a     a  1   b  2  b     c  5   d  8  dict ChainMap a  b        a  1   b  2   c  5   d  8    If you have the same key in both dictionaries  ChainMap will use the first key s value and ignores the second key s value   Cheers

User · Answer

from collections import Counter dict1     a  1   b   2  dict2     b  10   c   11  result   dict Counter dict1    Counter dict2     This should solve your problem

User · Answer

If you think lambdas are evil then read no further  As requested  you can write the fast and memory-efficient solution with one 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    As suggested above  using two lines or writing a function is probably a better way to go

User · Answer

The best version I could think while not using copy would be   from itertools import chain x     a  1   b   2  y     b  10   c   11  dict chain x iteritems    y iteritems       It s faster than dict x items     y items    but not as fast as n   copy a   n update b   at least on CPython  This version also works in Python 3 if you change iteritems   to items    which is automatically done by the 2to3 tool   Personally I like this version best because it describes fairly good what I want in a single  functional syntax  The only minor problem is that it doesn t make completely obvious that values from y takes precedence over values from x  but I don t believe it s difficult to figure that out

User · Answer

In Python 3 9 Based on PEP 584  the new version of Python introduces two new operators for dictionaries  union     and in-place union       You can use   to merge two dictionaries  while    will update a dictionary in place   gt  gt  gt  pycon    2016   quot Portland quot   2018   quot Cleveland quot    gt  gt  gt  europython    2017   quot Rimini quot   2018   quot Edinburgh quot   2019   quot Basel quot     gt  gt  gt  pycon   europython  2016   Portland   2018   Edinburgh   2017   Rimini   2019   Basel     gt  gt  gt  pycon    europython  gt  gt  gt  pycon  2016   Portland   2018   Edinburgh   2017   Rimini   2019   Basel     If d1 and d2 are two dictionaries  then d1   d2 does the same as    d1    d2   The   operator is used for calculating the union of sets  so the notation may already be familiar to you  One advantage of using   is that it works on different dictionary-like types and keeps the type through the merge   gt  gt  gt  from collections import defaultdict  gt  gt  gt  europe   defaultdict lambda   quot  quot     quot Norway quot    quot Oslo quot    quot Spain quot    quot Madrid quot     gt  gt  gt  africa   defaultdict lambda   quot  quot     quot Egypt quot    quot Cairo quot    quot Zimbabwe quot    quot Harare quot      gt  gt  gt  europe   africa defaultdict  lt function  lt lambda gt  at 0x7f0cb42a6700 gt       Norway    Oslo    Spain    Madrid    Egypt    Cairo    Zimbabwe    Harare      gt  gt  gt     europe    africa    Norway    Oslo    Spain    Madrid    Egypt    Cairo    Zimbabwe    Harare    You can use a defaultdict when you want to effectively handle missing keys  Note that   preserves the defaultdict  while    europe    africa  does not  There are some similarities between how   works for dictionaries and how   works for lists  In fact  the   operator was originally proposed to merge dictionaries as well  This correspondence becomes even more evident when you look at the in-place operator  The basic use of    is to update a dictionary in place  similar to  update     gt  gt  gt  libraries              quot collections quot    quot Container datatypes quot            quot math quot    quot Mathematical functions quot          gt  gt  gt  libraries      quot zoneinfo quot    quot IANA time zone support quot    gt  gt  gt  libraries   collections    Container datatypes    math    Mathematical functions     zoneinfo    IANA time zone support    When you merge dictionaries with    both dictionaries need to be of a proper dictionary type  On the other hand  the in-place operator      is happy to work with any dictionary-like data structure   gt  gt  gt  libraries       quot graphlib quot    quot Functionality for graph-like structures quot     gt  gt  gt  libraries   collections    Container datatypes    math    Mathematical functions     zoneinfo    IANA time zone support     graphlib    Functionality for graph-like structures

User · Answer

def dict merge a  b     c   a copy     c update b    return c  new   dict merge old  extras    Among such shady and dubious answers  this shining example is the one and only good way to merge dicts in Python  endorsed by dictator for life Guido van Rossum himself   Someone else suggested half of this  but did not put it in a function   print dict merge          color   red    model   Mini            model   Ferrari    owner   Carl      gives     color    red    owner    Carl    model    Ferrari

User · Answer

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  Demonstration   pluto original          name    Pluto        details              tail   True           color    orange           pluto update          name    Pluutoo        details              color    blue           print deepupdate pluto original  pluto update   Outputs          name    Pluutoo        details              color    blue            tail   True          Thanks rednaw for edits

User · Answer

This is an expression for Python 3 5 or greater that merges dictionaries using reduce    gt  gt  gt  from functools import reduce  gt  gt  gt  l      a   1     b   2     a   100   c   3    gt  gt  gt  reduce lambda x  y     x    y   l        a   100   b   2   c   3    Note  this works even if the dictionary list is empty or contains only one element

User · Answer

While the question has already been answered several times  this simple solution to the problem has not been listed yet   x     a  1   b   2  y     b  10   c   11  z4      z4 update x  z4 update y    It is as fast as z0 and the evil z2 mentioned above  but easy to understand and change

User · Answer

gt  gt  gt  x     a  1   b   2   gt  gt  gt  y     b  10   c   11   gt  gt  gt  x  z   dict x   x update y  or x  gt  gt  gt  x   a   1   b   2   gt  gt  gt  y   c   11   b   10   gt  gt  gt  z   a   1   c   11   b   10

User · Answer

I know this does not really fit the specifics of the questions   one liner    but since none of the answers above went into this direction while lots and lots of answers addressed the performance issue  I felt I should contribute my thoughts   Depending on the use case it might not be necessary to create a  real  merged dictionary of the given input dictionaries   A view which does this might be sufficient in many cases  i  e  an object which acts like the merged dictionary would without computing it completely   A lazy version of the merged dictionary  so to speak   In Python  this is rather simple and can be done with the code shown at the end of my post   This given  the answer to the original question would be   z   MergeDict x  y    When using this new object  it will behave like a merged dictionary but it will have constant creation time and constant memory footprint while leaving the original dictionaries untouched   Creating it is way cheaper than in the other solutions proposed   Of course  if you use the result a lot  then you will at some point reach the limit where creating a real merged dictionary would have been the faster solution   As I said  it depends on your use case   If you ever felt you would prefer to have a real merged dict  then calling dict z  would produce it  but way more costly than the other solutions of course  so this is just worth mentioning    You can also use this class to make a kind of copy-on-write dictionary   a      x   3   y   4   b   MergeDict a     we merge just one dict b  x     5 print b    will print   x   5   y   4  print a    will print   y   4   x   3    Here s the straight-forward code of MergeDict   class MergeDict object     def   init   self   originals       self originals           originals   -1     reversed    def   getitem   self  key       for original in self originals        try          return original key        except KeyError          pass     raise KeyError key     def   setitem   self  key  value       self originals 0  key    value    def   iter   self       return iter self keys       def   repr   self       return   s  s             self   class     name               join repr original            for original in reversed self originals       def   str   self       return    s          join            r   r    i for i in self iteritems       def iteritems self       found   set       for original in self originals        for k  v in original iteritems            if k not in found            yield k  v           found add k     def items self       return list self iteritems       def keys self       return list k for k    in self iteritems       def values self       return list v for    v in self iteritems

User · Answer

Instead  if  say  you want to combine the two dictionaries by adding the values  we could rely on the Collections module  I am not sure whether this existed 12 years ago - when the question was first asked   from collections import Counter x   Counter   a   1   b   2   y   Counter   b   10   c   11    Then x   y equates to Counter   a   1   b   12   c   11

User · Answer

I was curious if I could beat the accepted answer s time with a one line stringify approach   I tried 5 methods  none previously mentioned - all one liner - all producing correct answers - and I couldn t come close   So    to save you the trouble and perhaps fulfill curiosity   import json import yaml import time from ast import literal eval as literal  def merge two dicts x  y       z   x copy       start with x s keys and values     z update y       modifies z with y s keys and values  amp  returns None     return z  x     a  1   b   2  y     b  10   c   11   start   time time   for i in range 10000       z   yaml load  str x  str y   replace             elapsed    time time  -start  print  elapsed  z   stringify yaml    start   time time   for i in range 10000       z   literal  str x  str y   replace             elapsed    time time  -start  print  elapsed  z   stringify literal    start   time time   for i in range 10000       z   eval  str x  str y   replace             elapsed    time time  -start  print  elapsed  z   stringify eval    start   time time   for i in range 10000       z    k int v  for k v in  dict zip                str x  str y                replace                       replace                       replace                       replace                       replace                      strip                split          2                  str x  str y                replace                       replace          replace                       replace                       replace                      strip                split        1  2                   items    elapsed    time time  -start  print  elapsed  z   stringify replace    start   time time   for i in range 10000       z   json loads str  str x  str y   replace            replace            elapsed    time time  -start  print  elapsed  z   stringify json    start   time time   for i in range 10000       z   merge two dicts x  y  elapsed    time time  -start  print  elapsed  z   accepted     results   7 693928956985474   c   11   b   10   a   1  stringify yaml 0 29134678840637207   c   11   b   10   a   1  stringify literal 0 2208399772644043   c   11   b   10   a   1  stringify eval 0 1106564998626709   c   11   b   10   a   1  stringify replace 0 07989692687988281   c   11   b   10   a   1  stringify json 0 005082368850708008   c   11   b   10   a   1  accepted   What I did learn from this is that JSON approach is the fastest way  of those attempted  to return a dictionary from string-of-dictionary  much faster  about 1 4th of the time  of what I considered to be the normal method using ast   I also learned that  the YAML approach should be avoided at all cost   Yes  I understand that this is not the best correct way  I was curious if it was faster  and it isn t  I posted to prove it so

User · Answer

The problem I have with solutions listed to date is that  in the merged dictionary  the value for key  b  is 10 but  to my way of thinking  it should be 12  In that light  I present the following   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   Results   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

User · Answer

A hacky one-liner for 2 5     gt  gt  gt  a   dict x 2  y 3   gt  gt  gt  b   dict y 4  z 5   gt  gt  gt  c    No Effect  if a update b  else a  gt  gt  gt  c   x   2   y   4   z   5   Things to keep in mind   dict update modifies the dict in-place  hence it evaluates to None In expression A if C else B  C is evaluated first  See here  So here  a update b  is evaluated first  a gets updated with b and operation results in None  thus the expression will always return the value given in the else condition  i e  a  Since  a is already modified  it will return the new value of a  which is the updated dict  IMPROVEMENT This can be further improved  and it be made to work for even older versions  probably python 1 0 as well     gt  gt  gt  c   a update b  or a  Here also  the first part produces None  hence it always returns the second part  but as the update operation is already done  it always returns the updated dict  CRITIQUE  Both the solution modify the value of a  so if one wants to keep both the input dictionaries unchanged  this is not a good idea   IMPROVEMENT If copy of a is needed  the second one can be slightly modified   gt  gt  gt  a   dict x 2  y 3   gt  gt  gt  b   dict y 4  z 5   gt  gt  gt  a  c   a copy    a update b  or a  gt  gt  gt  c   x   2   y   4   z   5   gt  gt  gt  d   dict m 10  n 11   gt  gt  gt  a  c   a copy    a update b  or a update d  or a  gt  gt  gt  c   x   2   y   4   z   5   m   10   n   11   gt  gt  gt  a   x   2   y   4   CAVEATS  It  especially the first one  gets ugly and impractical for any number of dicts greater than 2 Furthermore  this is not explicit  which is un-pythonic   Even though these solutions are extremely fast  especially the or method which is probably faster than the new python 3 9 union operator  not entirely sure  further testing required  if anyone wants to add it afterwards  they are welcome   I would not recommend these methods due to the abovementioned reasons  Added it for the sake of completeness

User · Answer

An alternative   z   x copy   z update y

User · Answer

Be pythonic  Use a comprehension   z  i d i  for d in  x y  for i in d    gt  gt  gt  print z   a   1   c   11   b   10

User · Answer

Some ways to solve it without using any python modules  no dependencies  with few lines of codes   ALL Python Versions  using Lambda    merge dicts   lambda old  new  old update new  or old      Python Version    3 5    def merge dicts old  new       return    old    new        Older Python Version    def merge dicts old  new       merged   old copy       merged update new      return merged   This example will merge old and new while erasing old values with the new values      USAGE    old     name    Kevin    phone number     33 12 34 45 67   new     name    Kevin    phone number     33 88 88 88 88    print merge dicts old  new        OUTPUT      name    Kevin    phone number     33 88 88 88 88     IF you have to deal with multiples merged from old to new version  without losing any data one example approach below using an array of dictionaries      ALL Python Versions    def merge dicts old  news       merged   old copy       for new in news          merged update new      return merged      USAGE    old     name    Kevin    phone number     33 12 34 45 67   new 01     name    Kevin    phone number     33 77 77 77 77    age   28  new 02     name    SabK    phone number     33 88 88 88 89   new 03     phone number     33 99 99 99 99    print merge dicts old   new 01  new 02  new 03         OUTPUT      phone number     33 99 99 99 99    age   28   name    SabK     In this example  the new dictionary will be generated from the old one  first argument  and then will update sequentially from the first element of the array to the last one  new 01   new 02   new 03   At the end  you will get all the datas from all the dictionary will updating values that as been change  This function can be really useful when you have deal with datas that change frequently

User · Answer

As of Python 3 9  PEP584  there is a new method available for this  z   x union y   now works as you desire  without modifying either x or y  y values will override x values with the same key  You can also now use the union merge syntax for this  z   x   y  which gives the same result

User · Answer

Using  a dict comprehension  you may  x     a  1   b   2  y     b  10   c   11   dc    xi  x xi  if xi not in list y keys                else y xi   for xi in list x keys     list y keys        gives   gt  gt  gt  dc   a   1   c   11   b   10    Note the syntax for if else in comprehension      some key if condition else default key   something if true if condition            else something if false  for key  value in dict  items

User · Answer

Another  more concise  option   z   dict x    y    Note  this has become a popular answer  but it is important to point out that if y has any non-string keys  the fact that this works at all is an abuse of a CPython implementation detail  and it does not work in Python 3  or in PyPy  IronPython  or Jython  Also  Guido is not a fan  So I can t recommend this technique for forward-compatible or cross-implementation portable code  which really means it should be avoided entirely

User · Answer

Two dictionaries  def union2 dict1  dict2       return dict list dict1 items      list dict2 items       n dictionaries  def union  dicts       return dict itertools chain from iterable dct items   for dct in dicts     sum has bad performance  See https   mathieularose com how-not-to-flatten-a-list-of-lists-in-python

User · Answer

This can be done with a single dict comprehension    gt  gt  gt  x     a  1   b   2   gt  gt  gt  y     b  10   c   11   gt  gt  gt    key  y key  if key in y else x key        for key in set x    set y          In my view the best answer for the  single expression  part as no extra functions are needed  and it is short

[python] How do I merge two dictionaries in a single expression (taking union of dictionaries)?

Examples related to python

Examples related to dictionary

Examples related to merge