How to elegantly merge two dictionaries (dict) in Python

不言
Release: 2018-06-02 15:44:37
Original
1722 people have browsed it

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}
Copy after login

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}
Copy after login

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}
Copy after login

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)
Copy after login

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
Copy after login

Then one line of code completes the call:

 z = merge_two_dicts(x, y)
Copy after login

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
Copy after login

Then you can use it like this

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

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())
Copy after login

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;
Copy after login

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

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

>>> x = {&#39;a&#39;: 2}
>>> y = {&#39;a&#39;: 1}
>>> dict(x.items() | y.items())
{&#39;a&#39;: 2}
Copy after login

Constructor

Some people also use it this way

z = dict(x, **y)
Copy after login

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
Copy after login

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()}
Copy after login

This can be done in python2.6

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

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()))
Copy after login

##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
Copy after login

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
Copy after login

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!

Related labels:
source:php.cn
Statement of this Website
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn
Popular Tutorials
More>
Latest Downloads
More>
Web Effects
Website Source Code
Website Materials
Front End Template