## The Question :

*506 people think this question is useful*

What is the best way to extend a dictionary with another one while avoiding the use of a `for`

loop? For instance:

>>> a = { "a" : 1, "b" : 2 }
>>> b = { "c" : 3, "d" : 4 }
>>> a
{'a': 1, 'b': 2}
>>> b
{'c': 3, 'd': 4}

Result:

{ "a" : 1, "b" : 2, "c" : 3, "d" : 4 }

Something like:

a.extend(b) # This does not work

*The Question Comments :*

## The Answer 1

*758 people think this answer is useful*

## The Answer 2

*194 people think this answer is useful*

A beautiful gem in this closed question:

The “oneliner way”, altering neither of the input dicts, is

basket = dict(basket_one, **basket_two)

Learn what `**basket_two`

(the `**`

) means here.

In case of conflict, the items from `basket_two`

will override the ones from `basket_one`

. As one-liners go, this is pretty readable and transparent, and I have no compunction against using it any time a dict that’s a mix of two others comes in handy (any reader who has trouble understanding it will in fact be very well served by the way this prompts him or her towards learning about `dict`

and the `**`

form;-). So, for example, uses like:

x = mungesomedict(dict(adict, **anotherdict))

are reasonably frequent occurrences in my code.

Originally submitted by Alex Martelli

*Note:* In Python 3, this will only work if every key in basket_two is a `string`

.

## The Answer 3

*58 people think this answer is useful*

Have you tried using dictionary comprehension with dictionary mapping:

a = {'a': 1, 'b': 2}
b = {'c': 3, 'd': 4}
c = {**a, **b}
# c = {"a": 1, "b": 2, "c": 3, "d": 4}

Another way of doing is by Using dict(iterable, **kwarg)

c = dict(a, **b)
# c = {'a': 1, 'b': 2, 'c': 3, 'd': 4}

In Python 3.9 you can add two dict using union | operator

# use the merging operator |
c = a | b
# c = {'a': 1, 'b': 2, 'c': 3, 'd': 4}

## The Answer 4

*24 people think this answer is useful*

a.update(b)

Will add keys and values from *b* to *a*, overwriting if there’s already a value for a key.

## The Answer 5

*18 people think this answer is useful*

As others have mentioned, `a.update(b)`

for some dicts `a`

and `b`

will achieve the result you’ve asked for in your question. However, I want to point out that many times I have seen the `extend`

method of mapping/set objects desire that in the syntax `a.extend(b)`

, `a`

‘s values should NOT be overwritten by `b`

‘s values. `a.update(b)`

overwrites `a`

‘s values, and so isn’t a good choice for `extend`

.

Note that some languages call this method `defaults`

or `inject`

, as it can be thought of as a way of injecting b’s values (which might be a set of default values) in to a dictionary without overwriting values that might already exist.

Of course, you could simple note that `a.extend(b)`

is nearly the same as `b.update(a); a=b`

. To remove the assignment, you could do it thus:

def extend(a,b):
"""Create a new dictionary with a's properties extended by b,
without overwriting.
>>> extend({'a':1,'b':2},{'b':3,'c':4})
{'a': 1, 'c': 4, 'b': 2}
"""
return dict(b,**a)

Thanks to Tom Leys for that smart idea using a side-effect-less `dict`

constructor for `extend`

.

## The Answer 6

*1 people think this answer is useful*

You can also use python’s collections.Chainmap which was introduced in python 3.3.

from collections import Chainmap
c = Chainmap(a, b)
c['a'] # returns 1

This has a few possible advantages, depending on your use-case. They are explained in more detail here, but I’ll give a brief overview:

- A chainmap only uses views of the dictionaries, so no data is actually copied. This results in faster chaining (but slower lookup)
- No keys are actually overwritten so, if necessary, you know whether the data comes from a or b.

This mainly makes it useful for things like configuration dictionaries.

## The Answer 7

*0 people think this answer is useful*

In case you need it as a *Class*, you can extend it with *dict* and use *update* method:

Class a(dict):
# some stuff
self.update(b)