Example sharing of how to merge two dictionaries 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. The relevant content of (dict) 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 perfect 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.

Do not use python3 .5 How to do it in one line

If you are not using Python 3.5 yet, or need to write backwards-compatible code, and you want to run it in a single expression, the best What works 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

and then one line of code completes the call:

 z = merge_two_dicts(x, y)

You can also define a function to merge multiple dicts, such as

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

and then use

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

all Among 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 and delete it. Drop 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 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 an arbitrary set order, the value of x is retained:

>>> 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, It is much more efficient than the previous two-step method, but it is less readable and not pythonic enough. If the key is not a string, it will still fail to run in python3

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

Guido Master 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 put the key-value pairs in the correct order Iterator link on:

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

Performance Test

The following is on Ubuntu 14.04 Done on, 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

Summarize

The above is the detailed content of Example sharing of how to merge two dictionaries in Python. For more information, please follow other related articles on the PHP Chinese website!