本文由 简悦 SimpRead 转码， 原文地址 segmentfault.com

一行代码合并两个 dict

假设有两个 dict x 和 y，合并成一个新的 dict，不改变 x 和 y 的值，例如

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

期望得到一个新的结果 Z，如果 key 相同，则 y 覆盖 x。期望的结果是

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

在 PEP448 中，有个新的语法可以实现，并且在 python3.5 中支持了该语法，合并代码如下

  1. z = {**x, **y}

妥妥的一行代码。

由于现在很多人还在用 python2，对于 python2 和 python3.0-python3.4 的人来说，有一个比较优雅的方法，但是需要两行代码。

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

上面的方法，y 都会覆盖 x 里的内容，所以最终结果 b=3.

不使用 python3.5 如何一行完成了

如果您还没有使用 Python 3.5，或者需要编写向后兼容的代码，并且您希望在单个表达式中运行，则最有效的方法是将其放在一个函数中：

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

然后一行代码完成调用:

  1. z = merge_two_dicts(x, y)

你也可以定义一个函数，合并多个 dict，例如

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

然后可以这样使用

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

所有这些里面，相同的 key，都是后面的覆盖前面的。

一些不够优雅的示范

items

有些人会使用这种方法：

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

这其实就是在内存中创建两个列表，再创建第三个列表，拷贝完成后，创建新的 dict，删除掉前三个列表。这个方法耗费性能，而且对于 python3，这个无法成功执行，因为 items() 返回是个对象。

  1. >>> c = dict(a.items() + b.items())
  2. Traceback (most recent call last):
  3.   File "<stdin>", line 1, in <module>
  4. TypeError: unsupported operand type(s) for +: 'dict_items' and 
  5. 'dict_items'

你必须明确的把它强制转换成 list，z = dict(list(x.items()) + list(y.items()))，这太浪费性能了。

另外，想以来于 items() 返回的 list 做并集的方法对于 python3 来说也会失败，而且，并集的方法，导致了重复的 key 在取值时的不确定，所以，如果你对两个 dict 合并有优先级的要求，这个方法就彻底不合适了。

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

这里有一个例子，其中 y 应该具有优先权，但是由于任意的集合顺序，x 的值被保留：

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

构造函数

也有人会这么用

  1. z = dict(x, **y)

这样用很好，比前面的两步的方法高效多了，但是可阅读性差，不够 pythonic，如果当 key 不是字符串的时候，python3 中还是运行失败

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

Guido van Rossum 大神说了：宣告 dict（{}， {1：3}）是非法的，因为毕竟是滥用机制。虽然这个方法比较 hacker，但是太投机取巧了。

一些性能较差但是比较优雅的方法

下面这些方法，虽然性能差，但也比 items 方法好多了。并且支持优先级。

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

python2.6 中可以这样

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

itertools.chain:

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

性能测试

以下是在 Ubuntu 14.04 上完成的，在 Python 2.7（系统 Python）中：

  1. >>> min(timeit.repeat(lambda: merge_two_dicts(x, y)))
  2. 0.5726828575134277
  3. >>> min(timeit.repeat(lambda: {k: v for d in (x, y) for k, v in d.items()} ))
  4. 1.163769006729126
  5. >>> min(timeit.repeat(lambda: dict(itertools.chain(x.iteritems(),y.iteritems()))))
  6. 1.1614501476287842
  7. >>> min(timeit.repeat(lambda: dict((k, v) for d in (x, y) for k, v in d.items())))
  8. 2.2345519065856934

在 python3.5 中

  1. >>> min(timeit.repeat(lambda: {**x, **y}))
  2. 0.4094954460160807
  3. >>> min(timeit.repeat(lambda: merge_two_dicts(x, y)))
  4. 0.7881555100320838
  5. >>> min(timeit.repeat(lambda: {k: v for d in (x, y) for k, v in d.items()} ))
  6. 1.4525277839857154
  7. >>> min(timeit.repeat(lambda: dict(itertools.chain(x.items(), y.items()))))
  8. 2.3143140770262107
  9. >>> min(timeit.repeat(lambda: dict((k, v) for d in (x, y) for k, v in d.items())))
  10. 3.2069112799945287