How do I merge a list of dicts into a single dict?

Question

How can I turn a list of dicts like [{'a':1}, {'b':2}, {'c':1}, {'d':2}], into a single dict like {'a':1, 'b':2, 'c':1, 'd':2}?

_{Answers here will overwrite keys that match between two of the input dicts, because a dict cannot have duplicate keys. If you want to collect multiple values from matching keys, see How to merge dicts, collecting values from matching keys?.}

There really should be a one liner for this considering how often it comes up. Is there a reason why {**d for d in d_list} isn't supported? — markemus, Jan 16 '20 at 01:00
@markemus being able to use star-unpacking in the first clause of a comprehension would quickly lead to chaos. For just one example: should `[*a for a in (range(i) for i in range(10))]` flatten the output or not? A feature like this would take a LOT of careful design work. Also, for dict comprehensions specifically, the `:` is kind of needed in the syntax, or else how do you know it isn't a set comprehension instead? — Karl Knechtel, Aug 31 '22 at 01:20
@markemus See [Unpacking generalizations](https://stackoverflow.com/q/41251729/674039) about that. — wim, Nov 29 '22 at 17:48
@KarlKnechtel I'm not convinced on those syntactical points. The first example _should_ flatten the output, because not flattening it would be written as just `[range(i) for i in range(10)]`. A set union/unpack would look like `{*s for s in ss}` and dict merge/unpack would look like `{**d for d in ds}`. So, the * vs ** is enough - no `:` is needed. — wim, Nov 29 '22 at 17:50
" The first example should flatten the output," Okay, now have fun writing the parser logic for that, and making it not go "well, each `*a` produces a list clearly, and then we have a list comprehension of those". — Karl Knechtel, Nov 30 '22 at 06:00

score 292 · Accepted Answer · edited Nov 25 '18 at 20:05

292

This works for dictionaries of any length:

>>> result = {}
>>> for d in L:
...    result.update(d)
... 
>>> result
{'a':1,'c':1,'b':2,'d':2}

As a comprehension:

# Python >= 2.7
{k: v for d in L for k, v in d.items()}

# Python < 2.7
dict(pair for d in L for pair in d.items())

edited Nov 25 '18 at 20:05

wim

338,267
99
616
750

answered Aug 16 '10 at 16:56

score 179 · Answer 2 · edited May 23 '17 at 12:17

179

In case of Python 3.3+, there is a ChainMap collection:

>>> from collections import ChainMap
>>> a = [{'a':1},{'b':2},{'c':1},{'d':2}]
>>> dict(ChainMap(*a))
{'b': 2, 'c': 1, 'a': 1, 'd': 2}

Also see:

What is the purpose of collections.ChainMap?

edited May 23 '17 at 12:17

Community

1
1

answered Jan 13 '16 at 05:50

alecxe

462,703
120
1,088
1,195

6

slower by 10fold from 1st dict comprehension solution – Talis Aug 17 '21 at 08:12

score 23 · Answer 3 · answered Feb 09 '20 at 17:09

23

Little improvement for @dietbuddha answer with dictionary unpacking from PEP 448, for me, it`s more readable this way, also, it is faster as well:

from functools import reduce
result_dict = reduce(lambda a, b: {**a, **b}, list_of_dicts)

But keep in mind, this works only with Python 3.5+ versions.

answered Feb 09 '20 at 17:09

Insomniac631

1,018
12
20

14

After Python 3.9, the dictionary supports the use of `|` operator, so we can use `reduce(operator.ior, list_of_dicts, {})` instead, which will get the best performance. – Mechanic Pig Aug 09 '22 at 13:27
This `operator.ior` version works very nicely. – Ken Pronovici Apr 06 '23 at 21:41

score 16 · Answer 4 · answered May 04 '18 at 16:29

This is similar to @delnan but offers the option to modify the k/v (key/value) items and I believe is more readable:

new_dict = {k:v for list_item in list_of_dicts for (k,v) in list_item.items()}

for instance, replace k/v elems as follows:

new_dict = {str(k).replace(" ","_"):v for list_item in list_of_dicts for (k,v) in list_item.items()}

unpacks the k,v tuple from the dictionary .items() generator after pulling the dict object out of the list

score 12 · Answer 5 · edited Dec 12 '17 at 12:55

12

For flat dictionaries you can do this:

from functools import reduce
reduce(lambda a, b: dict(a, **b), list_of_dicts)

edited Dec 12 '17 at 12:55

SiHa

7,830
13
34
43

answered Apr 16 '13 at 22:36

dietbuddha

8,556
1
30
34

score 5 · Answer 6 · answered Jun 04 '14 at 21:05

5

You can use join function from funcy library:

from funcy import join
join(list_of_dicts)

answered Jun 04 '14 at 21:05

Suor

2,845
1
22
28

I think it's an underrated answer... – Soren V. Raben Nov 20 '21 at 17:14
Use this and not mine. – dietbuddha Jul 28 '23 at 18:55

John La Rooy · Answer 7 · 2014-09-11T14:17:58.867

4

>>> L=[{'a': 1}, {'b': 2}, {'c': 1}, {'d': 2}]    
>>> dict(i.items()[0] for i in L)
{'a': 1, 'c': 1, 'b': 2, 'd': 2}

Note: the order of 'b' and 'c' doesn't match your output because dicts are unordered

if the dicts can have more than one key/value

>>> dict(j for i in L for j in i.items())

edited Sep 11 '14 at 14:17

answered Aug 16 '10 at 16:38

John La Rooy

295,403
53
369
502

1

Fails if any of the dicts in the list has more than one item. – PaulMcG Aug 16 '10 at 16:52
3

*cough*(assuming each dictionary contains only one key-value pair)*cough* – Katriel Aug 16 '10 at 16:52
Ah, well first I posted a method that works with general dicts, but it looked like the OP didn't need that – John La Rooy Aug 16 '10 at 16:58

score 3 · Answer 8 · answered Oct 02 '21 at 12:41

3

If you don't need the singleton dicts anymore:

>>> L = [{'a':1}, {'b':2}, {'c':1}, {'d':2}]
>>> dict(map(dict.popitem, L))
{'a': 1, 'b': 2, 'c': 1, 'd': 2}

answered Oct 02 '21 at 12:41

no comment

6,381
4
12
30

3

This is really weird and breaks _silently_ if any of the dicts has more than one item. – wim Nov 29 '22 at 17:42
Breaks for me too, eg: with `L = [{'a':1}, {'b':2}, {'c':1}, {'d':2, 'e':3}]` – Damien Jan 28 '23 at 00:55

Katriel · Answer 9 · 2010-08-16T17:01:37.117

2

dict1.update( dict2 )

This is asymmetrical because you need to choose what to do with duplicate keys; in this case, dict2 will overwrite dict1. Exchange them for the other way.

EDIT: Ah, sorry, didn't see that.

It is possible to do this in a single expression:

>>> from itertools import chain
>>> dict( chain( *map( dict.items, theDicts ) ) )
{'a': 1, 'c': 1, 'b': 2, 'd': 2}

No credit to me for this last!

However, I'd argue that it might be more Pythonic (explicit > implicit, flat > nested ) to do this with a simple for loop. YMMV.

edited Aug 16 '10 at 17:01

answered Aug 16 '10 at 15:58

Katriel

120,462
19
136
170

1

its a list and not a dict: >>> type([{'a':1},{'b':2}]) – killown Aug 16 '10 at 16:27

score 1 · Answer 10 · answered Sep 26 '22 at 13:14

1

this way worked for me:

object = [{'a':1}, {'b':2}, {'c':1}, {'d':2}]
object = {k: v for dct in object for k, v in dct.items()}

printing object:

object = {'a':1,'b':2,'c':1,'d':2}

thanks Axes

answered Sep 26 '22 at 13:14

Shokouh Dareshiri

826
1
12
24

I wouldnt override the object keyword – Tom McLean Mar 07 '23 at 10:28

score 0 · Answer 11 · answered Aug 16 '10 at 16:59

>>> dictlist = [{'a':1},{'b':2},{'c':1},{'d':2, 'e':3}]
>>> dict(kv for d in dictlist for kv in d.iteritems())
{'a': 1, 'c': 1, 'b': 2, 'e': 3, 'd': 2}
>>>

Note I added a second key/value pair to the last dictionary to show it works with multiple entries. Also keys from dicts later in the list will overwrite the same key from an earlier dict.

score 0 · Answer 12 · answered Aug 02 '23 at 19:34

Using reduce and | seems to be slightly faster than the list comprehension in the accepted answer.

In [1]: %timeit reduce(lambda d1, d2: d1 | d2, L)
428 ns ± 5.41 ns per loop (mean ± std. dev. of 7 runs, 1,000,000 loops each)

In [2]: %timeit {k: v for d in L for k, v in d.items()}
476 ns ± 15.4 ns per loop (mean ± std. dev. of 7 runs, 1,000,000 loops each)

In [3]: reduce(lambda d1, d2: d1 | d2, L) == {k: v for d in L for k, v in d.items()}
Out[3]: True

How do I merge a list of dicts into a single dict?

12 Answers12

Linked

Related