How to elegantly merge two dictionaries (dict) in Python

Dictionary is the only mapping type in the Python language, which we often encounter in our daily work. The following article mainly introduces you to the relevant information on how to elegantly merge two dictionaries (dict) in Python. In the article The introduction through the sample code is very detailed. Friends in need can refer to it. Let’s take a look together.

Preface

Dictionary is one of the most powerful data types in Python. This article will give you a detailed introduction to Python merging two dictionaries. (dict) related content is shared for everyone’s reference and study. Not much to say, let’s take a look at the detailed introduction.

One line of code merges two dicts

Suppose there are two dicts x and y, merge them into a new dict, no Change the values ​​of x and y, for example

 x = {'a': 1, 'b': 2}
 y = {'b': 3, 'c': 4}

expect to get a new result Z, if the key is the same, y covers x. The expected result is

>>> z
{'a': 1, 'b': 3, 'c': 4}

In PEP448, there is a new syntax that can be implemented, and this syntax is supported in python3.5. The merged code is as follows

z = {**x, **y}

A proper line of code. Since many people are still using python2, for people with python2 and python3.0-python3.4, there is a more elegant method, but it requires two lines of code.

z = x.copy()
z.update(y)

In the above method, y will overwrite the content in x, so the final result is b=3.

## How to do it in one line without using python3.5

If you are not using Python 3.5 yet, or need to write backwards compatible code, and you want to run in a single expression , the most effective way is to put it in a function:

def merge_two_dicts(x, y):
 """Given two dicts, merge them into a new dict as a shallow copy."""
 z = x.copy()
 z.update(y)
 return z

Then one line of code completes the call:

 z = merge_two_dicts(x, y)

You can also define a function to merge multiple dicts, for example

def merge_dicts(*dict_args):
 """
 Given any number of dicts, shallow copy and merge into a new dict,
 precedence goes to key value pairs in latter dicts.
 """
 result = {}
 for dictionary in dict_args:
 result.update(dictionary)
 return result

Then you can use it like this

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

In all of these, the same key always covers the previous one.

Some less elegant demonstrations

items

Some people This method will be used:

 z = dict(x.items() + y.items())

This is actually to create two lists in the memory, and then create a third list. After the copy is completed, create a new dict, delete the first three lists. This method consumes performance, and for python3, this cannot be executed successfully because items() returns an object.

>>> c = dict(a.items() + b.items())
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: &#39;dict_items&#39; and 
&#39;dict_items&#39;

You must explicitly cast it into a list,

z = dict(list(x.items()) list(y.items ())) , this is such a waste of performance. In addition, the union method based on the list returned by items() will also fail for python3. Moreover, the union method leads to uncertainty in the value of repeated keys. Therefore, if you have priority requirements for merging two dicts, this method is completely inappropriate.

>>> x = {'a': []}
>>> y = {'b': []}
>>> dict(x.items() | y.items())
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
TypeError: unhashable type: &#39;list&#39;

Here is an example where y should have priority, but due to arbitrary set order, the value of x is preserved:

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

Constructor

Some people also use it this way

z = dict(x, **y)

This is very good to use, much more efficient than the previous two-step method, but the readability is poor and not pythonic enough. If the key is not a string, the operation will still fail in python3

>>> c = dict(a, **b)
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
TypeError: keyword arguments must be strings

Guido van Rossum said: Declaring

dict({}, {1:3}) is illegal because it is an abuse of the mechanism after all. Although this method is more hacky, it is too opportunistic.

Some poor performance but more elegant methods

The following methods, although poor in performance, are much better than the items method . And supports priority.

{k: v for d in dicts for k, v in d.items()}

This can be done in python2.6

 dict((k, v) for d in dicts for k, v in d.items())

itertools.chain will be correct Chain the iterator over the key-value pairs in the order:

import itertools
z = dict(itertools.chain(x.iteritems(), y.iteritems()))

##Performance Test
The following was done on Ubuntu 14.04, in Python 2.7 (System Python):

>>> min(timeit.repeat(lambda: merge_two_dicts(x, y)))
0.5726828575134277
>>> min(timeit.repeat(lambda: {k: v for d in (x, y) for k, v in d.items()} ))
1.163769006729126
>>> min(timeit.repeat(lambda: dict(itertools.chain(x.iteritems(),y.iteritems()))))
1.1614501476287842
>>> min(timeit.repeat(lambda: dict((k, v) for d in (x, y) for k, v in d.items())))
2.2345519065856934

In python3.5

>>> min(timeit.repeat(lambda: {**x, **y}))
0.4094954460160807
>>> min(timeit.repeat(lambda: merge_two_dicts(x, y)))
0.7881555100320838
>>> min(timeit.repeat(lambda: {k: v for d in (x, y) for k, v in d.items()} ))
1.4525277839857154
>>> min(timeit.repeat(lambda: dict(itertools.chain(x.items(), y.items()))))
2.3143140770262107
>>> min(timeit.repeat(lambda: dict((k, v) for d in (x, y) for k, v in d.items())))
3.2069112799945287

The above is the detailed content of How to elegantly merge two dictionaries (dict) in Python. For more information, please follow other related articles on the PHP Chinese website!