我有两个 Python 字典，我想编写一个返回这两个字典的表达式，合并。 update()方法将是我需要的，如果它返回其结果而不是就地修改 dict。
>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> z = x.update(y)
>>> print(z)
None
>>> x
{'a': 1, 'b': 10, 'c': 11}如何在z获得最终合并的 dict，而不是x ？
（要清楚的是， dict.update()的最后一次胜利冲突处理也是我正在寻找的。）
如何在单个表达式中合并两个 Python 词典？
对于字典x和y ， z成为合并字典， y值替换x 。
在 Python 3.5 或更高版本中，：
z = {**x, **y}
w = {'foo': 'bar', 'baz': 'qux', **y} # merge a dict with literal values在 Python 2 中，（或 3.4 或更低版本）编写一个函数：
def merge_two_dicts(x, y):
z = x.copy() # start with x's keys and values
z.update(y) # modifies z with y's keys and values & returns None
return z和
z = merge_two_dicts(x, y)假设您有两个 dicts，并且您希望将它们合并到一个新的 dict 而不更改原始的 dicts：
x = {'a': 1, 'b': 2}
y = {'b': 3, 'c': 4}期望的结果是获得具有合并值的新字典（ z ），并且第二个字典的值覆盖来自第一个的字典。
>>> z
{'a': 1, 'b': 3, 'c': 4}在PEP 448 中提出并且从 Python 3.5 开始提供的新语法是
z = {**x, **y}它确实是一个表达式。它现在显示为在3.5，PEP 478的发布时间表中实现，现在它已经进入了 Python 3.5文档中的新功能 。
但是，由于许多组织仍在使用 Python 2，因此您可能希望以向后兼容的方式执行此操作。 Python 2 和 Python 3.0-3.4 中提供的经典 Pythonic 方法是通过两个步骤完成的：
z = x.copy()
z.update(y) # which returns None since it mutates z在这两种方法中， y将成为第二个，其值将替换x的值，因此在最终结果中'b'将指向3 。
如果您尚未使用 Python 3.5，或者需要编写向后兼容的代码，并且您希望在单个表达式中使用它 ，那么最正确的方法是将其放在函数中：
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然后你有一个表达式：
z = merge_two_dicts(x, y)您还可以创建一个函数来合并未定义数量的 dicts，从零到非常大的数字：
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对于所有 dicts，此函数将在 Python 2 和 3 中使用。例如，给出a字母a到g ：
z = merge_dicts(a, b, c, d, e, f, g)和g键值对优先于 dicts a到f ，依此类推。
不要使用你在以前接受的答案中看到的内容：
z = dict(x.items() + y.items())在 Python 2 中，您在内存中为每个 dict 创建两个列表，在内存中创建第三个列表，其长度等于放在一起的前两个列表的长度，然后丢弃所有三个列表以创建 dict。 在 Python 3 中，这将失败，因为您将两个dict_items对象一起添加，而不是两个列表 -
>>> c = dict(a.items() + b.items())
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'dict_items' and 'dict_items'你必须明确地将它们创建为列表，例如z = dict(list(x.items()) + list(y.items())) 。这是浪费资源和计算能力。
类似地，当值是不可用的对象（例如列表items()在 Python 3 中使用items()的联合items() Python 2.7 中的viewitems() ）也会失败。即使您的值是可清除的， 因为集合在语义上是无序的，所以行为在优先级方面是未定义的。所以不要这样做：
>>> c = dict(a.items() | b.items())此示例演示了值不可用时会发生什么：
>>> x = {'a': []}
>>> y = {'b': []}
>>> dict(x.items() | y.items())
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'这是 y 应该具有优先权的示例，但是由于任意顺序的集合而保留 x 中的值：
>>> x = {'a': 2}
>>> y = {'a': 1}
>>> dict(x.items() | y.items())
{'a': 2}另一个黑客你不应该使用：
z = dict(x, **y)这使用了dict构造函数，并且非常快且内存效率高（甚至比我们的两步过程稍微多一点）但除非你确切地知道这里发生了什么（也就是说，第二个 dict 作为关键字参数传递给 dict 构造函数），它很难读，它不是预期的用法，所以它不是 Pythonic。
Dicts 旨在获取可散列密钥（例如 frozensets 或 tuples），但是当密钥不是字符串时 ， 此方法在 Python 3 中失败。
>>> c = dict(a, **b)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: keyword arguments must be strings从邮件列表中 ，该语言的创建者 Guido van Rossum 写道：
我很好地宣布 dict（{}，** {1：3}）是非法的，因为它毕竟是滥用 ** 机制。
和
显然 dict（x，** y）作为 “调用 x.update（y）并返回 x” 的 “酷黑客”。就个人而言，我发现它比酷酷更卑鄙。
我的理解（以及对语言创建者的理解） dict(**y)的预期用法是为了可读性目的而创建 dicts，例如：
dict(a=1, b=10, c=11)代替
{'a': 1, 'b': 10, 'c': 11}尽管 Guido 说，
dict(x, **y)符合 dict 规范，顺便说一下。适用于 Python 2 和 3. 事实上，这仅适用于字符串键，这是关键字参数如何工作而不是 dict 短路的直接结果。在这个地方也没有使用 ** 运算符滥用该机制，事实上 ** 被精确地设计为将 dicts 作为关键字传递。
同样，当键是非字符串时，它不适用于 3。隐式调用契约是命名空间采用普通的 dicts，而用户只能传递字符串的关键字参数。所有其他 callables 强制执行它。 dict打破了 Python 2 中的这种一致性：
>>> foo(**{('a', 'b'): None})
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: foo() keywords must be strings
>>> dict(**{('a', 'b'): None})
{('a', 'b'): None}鉴于 Python 的其他实现（Pypy，Jython，IronPython），这种不一致性很糟糕。因此它在 Python 3 中得到了修复，因为这种用法可能是一个突破性的变化。
我向你提出，故意编写只能在一种语言版本中工作的代码或仅在某些任意约束条件下工作的代码是恶意无能的。
另一条评论：
dict(x.items() + y.items())仍然是 Python 2 最易读的解决方案。可读性很重要。
我的回答： merge_two_dicts(x, y)实际上对我来说更清楚，如果我们真的关心可读性的话。并且它不向前兼容，因为 Python 2 越来越被弃用。
这些方法性能较差，但它们会提供正确的行为。它们的copy和update或新解包的性能要低得多，因为它们在更高的抽象级别迭代每个键值对，但它们确实尊重优先顺序（后面的 dicts 优先）
你也可以在 dict 理解中手动链接 dicts：
{k: v for d in dicts for k, v in d.items()} # iteritems in Python 2.7或者在 python 2.6 中（当引入生成器表达式时可能早在 2.4）：
dict((k, v) for d in dicts for k, v in d.items()) itertools.chain将以正确的顺序将迭代器链接到键值对：
import itertools
z = dict(itertools.chain(x.iteritems(), y.iteritems()))我只会对已知行为正确的用法进行性能分析。
import timeit以下是在 Ubuntu 14.04 上完成的
在 Python 2.7（系统 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在 Python 3.5（deadsnakes PPA）中：
>>> 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在您的情况下，您可以做的是：
z = dict(x.items() + y.items())这将根据您的需要将最终的 dict 放在z ，并使键b的值被第二个（ y ）dict 的值正确覆盖：
>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> z = dict(x.items() + y.items())
>>> z
{'a': 1, 'c': 11, 'b': 10}如果你使用 Python 3，它只是稍微复杂一点。要创建z ：
>>> z = dict(list(x.items()) + list(y.items()))
>>> z
{'a': 1, 'c': 11, 'b': 10}替代：
z = x.copy()
z.update(y)