Say I have three dicts
d1={1:2,3:4}
d2={5:6,7:9}
d3={10:8,13:22}
How do I create a new d4
that combines these three dictionaries? i.e.:
d4={1:2,3:4,5:6,7:9,10:8,13:22}
Say I have three dicts
d1={1:2,3:4}
d2={5:6,7:9}
d3={10:8,13:22}
How do I create a new d4
that combines these three dictionaries? i.e.:
d4={1:2,3:4,5:6,7:9,10:8,13:22}
Slowest and doesn't work in Python3: concatenate the items
and call dict
on the resulting list:
$ python -mtimeit -s'd1={1:2,3:4}; d2={5:6,7:9}; d3={10:8,13:22}' \
'd4 = dict(d1.items() + d2.items() + d3.items())'
100000 loops, best of 3: 4.93 usec per loop
Fastest: exploit the dict
constructor to the hilt, then one update
:
$ python -mtimeit -s'd1={1:2,3:4}; d2={5:6,7:9}; d3={10:8,13:22}' \
'd4 = dict(d1, **d2); d4.update(d3)'
1000000 loops, best of 3: 1.88 usec per loop
Middling: a loop of update
calls on an initially-empty dict:
$ python -mtimeit -s'd1={1:2,3:4}; d2={5:6,7:9}; d3={10:8,13:22}' \
'd4 = {}' 'for d in (d1, d2, d3): d4.update(d)'
100000 loops, best of 3: 2.67 usec per loop
Or, equivalently, one copy-ctor and two updates:
$ python -mtimeit -s'd1={1:2,3:4}; d2={5:6,7:9}; d3={10:8,13:22}' \
'd4 = dict(d1)' 'for d in (d2, d3): d4.update(d)'
100000 loops, best of 3: 2.65 usec per loop
I recommend approach (2), and I particularly recommend avoiding (1) (which also takes up O(N) extra auxiliary memory for the concatenated list of items temporary data structure).
d4 = dict(d1, **dict(d2, **d3))
isn't faster than #2, but it isn't.
Commented
Nov 23, 2009 at 18:29
d1.items() + d2.items()
doesn't works in Python 3.
Commented
Jan 10, 2017 at 17:00
**
notation: d1={1:2,3:4}; d2={5:6,7:9}; d3={10:8,13:22}; d4 = {**d1, **d2, **d3}
, which for me was nearly 3x faster than #3 or #4 above (0.228 usec per loop vs. 0.661 or 0.595 usec for #3 or 4, respectively). As mentioned above, #1 and #2 don't work on Python 3.
In python 2:
d4 = dict(d1.items() + d2.items() + d3.items())
In python 3 (and supposedly faster):
d4 = dict(d1)
d4.update(d2)
d4.update(d3)
The previous SO question that both of these answers came from is here.
d4 = dict(d1)
one could use d4 = copy(d1)
.
Commented
Nov 23, 2009 at 7:49
from copy import copy; d4 = copy(d1)
or perhaps d4 = d1.copy()
.
Commented
Nov 23, 2009 at 9:05
dict_items
objects to real list
objects. This is another case where Python 3 prioritised minor performance optimisations over simplicity and ease of use.
Commented
Apr 12, 2017 at 13:26
You can use the update()
method to build a new dictionary containing all the items:
dall = {}
dall.update(d1)
dall.update(d2)
dall.update(d3)
Or, in a loop:
dall = {}
for d in [d1, d2, d3]:
dall.update(d)
dall
. This new dictionary gets repeatedly updated to contain all the elements. It's intentional that dall
is changed.
Here's a one-liner (imports
don't count :) that can easily be generalized to concatenate N dictionaries:
from itertools import chain
dict(chain.from_iterable(d.items() for d in (d1, d2, d3)))
and:
from itertools import chain
def dict_union(*args):
return dict(chain.from_iterable(d.items() for d in args))
from itertools import chain
dict(chain.from_iterable(d.iteritems() for d in (d1, d2, d3))
Output:
>>> from itertools import chain
>>> d1={1:2,3:4}
>>> d2={5:6,7:9}
>>> d3={10:8,13:22}
>>> dict(chain.from_iterable(d.iteritems() for d in (d1, d2, d3)))
{1: 2, 3: 4, 5: 6, 7: 9, 10: 8, 13: 22}
Generalized to concatenate N dicts:
from itertools import chain
def dict_union(*args):
return dict(chain.from_iterable(d.iteritems() for d in args))
I'm a little late to this party, I know, but I hope this helps someone.
imports
do count. but the solution here is still interesting
Commented
Jun 18, 2017 at 16:18
d.items()
instead of d.iteritems()
. thanks for your contribution!
Commented
Jan 4, 2018 at 20:30
Use the dict constructor
d1={1:2,3:4}
d2={5:6,7:9}
d3={10:8,13:22}
d4 = reduce(lambda x,y: dict(x, **y), (d1, d2, d3))
As a function
from functools import partial
dict_merge = partial(reduce, lambda a,b: dict(a, **b))
The overhead of creating intermediate dictionaries can be eliminated by using thedict.update()
method:
from functools import reduce
def update(d, other): d.update(other); return d
d4 = reduce(update, (d1, d2, d3), {})