对于字典x和y，z变成了浅层合并的字典，带有y替换的值x。

在Python 3.5或更高版本中：

z = {**x, **y}

在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)

请注意，此处讨论了一个建议（PEP 584），以通过提供合并操作符（预期为）在Python的未来版本中进一步简化此操作，该操作将允许：dict+

z = x + y                       # pseudocode for now...

但这尚未实现。

说明

假设你有两个字典，并且想要将它们合并为新字典而不更改原始字典：

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

理想的结果是获得一个z合并了值的新字典（），第二个dict的值覆盖第一个字典的值。

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

在PEP 448中提出并从Python 3.5开始可用的新语法是

z = {**x, **y}

它确实是一个表达。

注意，我们也可以使用文字符号合并：

z = {**x, 'foo': 1, 'bar': 2, **y}

现在：

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

它现在显示为在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上运行，但需要一个表达式

如果你尚未使用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)

你还可以创建一个函数来合并未定义数量的dict，从零到非常大的数字：

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

此功能将在Python 2和3中适用于所有字典。例如给以下a命令g：

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

和中的键值对g优先a于f，以此类推。

其他答案的批判

不要使用以前接受的答案中看到的内容：

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

在Python 2中，你将在每个内存字典中创建两个列表，在内存中创建第三个列表，其长度等于前两个字典的长度，然后丢弃所有三个列表以创建字典。在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（viewitems()在Python 2.7中）进行联合也将失败。即使你的值是可哈希的，由于集合在语义上是无序的，因此关于优先级的行为是不确定的。所以不要这样做：

>>> 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。

这是在django中修复的用法的示例。

字典旨在获取可散列的键（例如，frozenset或元组），但是当键不是字符串时，此方法在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)是出于可读性目的创建字典，例如：

dict(a=1, b=10, c=11)

代替

{'a': 1, 'b': 10, 'c': 11}

对评论的回应

尽管Guido说了什么dict(x, **y)，但符合dict规范，顺便说一句。它仅适用于Python 2和3。事实上，这仅适用于字符串键，这是关键字参数如何工作的直接结果，而不是字典的缩写。在这个地方使用**运算符也不会滥用该机制，实际上**正是为了将dict作为关键字传递而设计的。

同样，当键为非字符串时，它不适用于3。隐式调用协定是名称空间采用普通命令，而用户只能传递字符串形式的关键字参数。所有其他可调用对象都强制执行了它。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越来越不推荐使用。

{**x, **y}似乎不处理嵌套字典。嵌套键的内容只是被覆盖，没有被合并，而最终我被这些没有递归合并的答案所烧死，我很惊讶没有人提及它。在我对“合并”一词的解释中，这些答案描述的是“将一个词典与另一个词典更新”，而不是合并。

是。我必须回头再问这个问题，该问题要求将两个字典进行浅层合并，第一个字典的值将被第二个字典的值覆盖-在一个表达式中。

假设有两个字典，一个字典可能会递归地将它们合并到一个函数中，但是你应注意不要从任何一个源修改字典，避免这种情况的最可靠方法是在分配值时进行复制。由于键必须是可散列的，因此通常是不可变的，因此复制它们毫无意义：

from copy import deepcopy

def dict_of_dicts_merge(x, y):
    z = {}
    overlapping_keys = x.keys() & y.keys()
    for key in overlapping_keys:
        z[key] = dict_of_dicts_merge(x[key], y[key])
    for key in x.keys() - overlapping_keys:
        z[key] = deepcopy(x[key])
    for key in y.keys() - overlapping_keys:
        z[key] = deepcopy(y[key])
    return z

用法：

>>> x = {'a':{1:{}}, 'b': {2:{}}}
>>> y = {'b':{10:{}}, 'c': {11:{}}}
>>> dict_of_dicts_merge(x, y)
{'b': {2: {}, 10: {}}, 'a': {1: {}}, 'c': {11: {}}}

提出其他值类型的偶发性问题远远超出了此问题的范围，因此，我将为你回答有关“词典合并词典”的规范问题。

性能较差但临时性正确

这些方法的性能较差，但是它们将提供正确的行为。它们的性能将不及copy和update或新的解压缩，因为它们在更高的抽象级别上遍历每个键值对，但它们确实遵循优先级顺序（后继命令具有优先级）

你还可以在dict理解内手动将dict链接：

{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（deadsnakesPPA）中：

>>> 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