x = {'a':1, 'b': 2}
y = {'b':10, 'c': 11}
z = dict(x.items() + y.items())
print z

对于两个字典 （'b'） 中都有键的项目，您可以通过将哪个字典放在最后来控制哪个项目最终出现在输出中。

就您而言，您可以执行以下操作：

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

这将按照您的意愿将最终的字典放入 ，并使 key 的值被第二个 （） 字典的值正确覆盖：zby

>>> x = {'a': 1, 'b': 2}
>>> y = {'b': 10, 'c': 11}
>>> z = dict(list(x.items()) + list(y.items()))
>>> z
{'a': 1, 'c': 11, 'b': 10}

如果您使用 Python 2，您甚至可以删除调用。要创建 z：list()

>>> z = dict(x.items() + y.items())
>>> z
{'a': 1, 'c': 11, 'b': 10}

如果使用 Python 3.9.0a4 或更高版本，可以直接使用：

>>> x = {'a': 1, 'b': 2}
>>> y = {'b': 10, 'c': 11}
>>> z = x | y
>>> z
{'a': 1, 'c': 11, 'b': 10}

另一种选择：

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

另一个更简洁的选项：

z = dict(x, **y)

注意：这已经成为一个流行的答案，但重要的是要指出，如果有任何非字符串键，那么这根本就是滥用 CPython 实现细节，并且在 Python 3 或 PyPy、IronPython 或 Jython 中不起作用。另外，圭多不是粉丝。因此，我不能将这种技术推荐用于向前兼容或交叉实现的可移植代码，这实际上意味着应该完全避免使用这种技术。y

我想要类似的东西，但能够指定重复键上的值是如何合并的，所以我把它砍掉了（但没有对其进行大量测试）。显然，这不是一个表达式，而是一个单一的函数调用。

def merge(d1, d2, merge_fn=lambda x,y:y):
    """
    Merges two dictionaries, non-destructively, combining 
    values on duplicate keys as defined by the optional merge
    function.  The default behavior replaces the values in d1
    with corresponding values in d2.  (There is no other generally
    applicable merge strategy, but often you'll have homogeneous 
    types in your dicts, so specifying a merge technique can be 
    valuable.)

    Examples:

    >>> d1
    {'a': 1, 'c': 3, 'b': 2}
    >>> merge(d1, d1)
    {'a': 1, 'c': 3, 'b': 2}
    >>> merge(d1, d1, lambda x,y: x+y)
    {'a': 2, 'c': 6, 'b': 4}

    """
    result = dict(d1)
    for k,v in d2.iteritems():
        if k in result:
            result[k] = merge_fn(result[k], v)
        else:
            result[k] = v
    return result

这可能不是一个流行的答案，但你几乎可以肯定不想这样做。如果您想要合并的副本，请使用复制（或深度复制，具体取决于您想要的内容），然后更新。这两行代码比使用 .items（） + .items（） 创建的单行代码更具可读性 - 更 Pythonic。显式比隐式好。

此外，当您使用 .items（）（Python 3.0 之前的版本）时，您将创建一个包含字典中项目的新列表。如果你的词典很大，那么这是相当大的开销（两个大列表，一旦创建合并的词典，它们就会被丢弃）。update（） 可以更有效地工作，因为它可以逐项运行第二个字典。

在时间方面：

>>> timeit.Timer("dict(x, **y)", "x = dict(zip(range(1000), range(1000)))\ny=dict(zip(range(1000,2000), range(1000,2000)))").timeit(100000)
15.52571702003479
>>> timeit.Timer("temp = x.copy()\ntemp.update(y)", "x = dict(zip(range(1000), range(1000)))\ny=dict(zip(range(1000,2000), range(1000,2000)))").timeit(100000)
15.694622993469238
>>> timeit.Timer("dict(x.items() + y.items())", "x = dict(zip(range(1000), range(1000)))\ny=dict(zip(range(1000,2000), range(1000,2000)))").timeit(100000)
41.484580039978027

IMO 前两者之间的微小减速对于可读性来说是值得的。此外，用于创建字典的关键字参数仅在 Python 2.3 中添加，而 copy（） 和 update（） 将在旧版本中起作用。

在后续回答中，您询问了这两个备选方案的相对性能：

z1 = dict(x.items() + y.items())
z2 = dict(x, **y)

至少在我的机器上（运行 Python 2.5.2 的相当普通的x86_64），替代方案不仅更短、更简单，而且速度也快得多。您可以使用 Python 附带的模块自行验证这一点。z2timeit

示例 1：将 20 个连续整数映射到自身的相同字典：

% python -m timeit -s 'x=y=dict((i,i) for i in range(20))' 'z1=dict(x.items() + y.items())'
100000 loops, best of 3: 5.67 usec per loop
% python -m timeit -s 'x=y=dict((i,i) for i in range(20))' 'z2=dict(x, **y)' 
100000 loops, best of 3: 1.53 usec per loop

z2以 3.5 倍左右的优势获胜。不同的词典似乎会产生完全不同的结果，但似乎总是领先一步。（如果同一测试的结果不一致，请尝试使用大于默认 3 的数字传入。z2-r

示例 2：将 252 个短字符串映射到整数的非重叠字典，反之亦然：

% python -m timeit -s 'from htmlentitydefs import codepoint2name as x, name2codepoint as y' 'z1=dict(x.items() + y.items())'
1000 loops, best of 3: 260 usec per loop
% python -m timeit -s 'from htmlentitydefs import codepoint2name as x, name2codepoint as y' 'z2=dict(x, **y)'               
10000 loops, best of 3: 26.9 usec per loop

z2获胜的系数约为 10 倍。在我的书中，这是一个相当大的胜利！

在比较了这两者之后，我想知道性能不佳是否可以归因于构建两个项目列表的开销，这反过来又使我想知道这种变体是否可能更好：z1

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

一些快速测试，例如

% python -m timeit -s 'from itertools import chain; from htmlentitydefs import codepoint2name as x, name2codepoint as y' 'z3=dict(chain(x.iteritems(), y.iteritems()))'
10000 loops, best of 3: 66 usec per loop

使我得出结论，它比 快一些，但远不如 快。绝对不值得所有额外的打字。z3z1z2

这个讨论仍然缺少一些重要的东西，即这些替代方案与合并两个列表的“明显”方法的性能比较：使用方法。为了尽量使表达式保持平等，它们都不会修改 x 或 y，我将复制 x 而不是就地修改它，如下所示：update

z0 = dict(x)
z0.update(y)

典型结果：

% python -m timeit -s 'from htmlentitydefs import codepoint2name as x, name2codepoint as y' 'z0=dict(x); z0.update(y)'
10000 loops, best of 3: 26.9 usec per loop

换言之，它们似乎具有基本相同的性能。你认为这可能是巧合吗？我没有。。。。z0z2

事实上，我甚至声称纯 Python 代码不可能做得比这更好。如果你能在 C 扩展模块中做得更好，我想 Python 的人可能会有兴趣将你的代码（或你的方法的变体）整合到 Python 核心中。Python 在很多地方使用;优化其运营是一件大事。dict

你也可以把它写成

z0 = x.copy()
z0.update(y)

就像托尼所做的那样，但（毫不奇怪）符号的差异对性能没有任何可衡量的影响。使用适合您的。当然，他指出两句话的版本更容易理解，这是绝对正确的。

在不使用复制的情况下，我能想到的最好的版本是：

from itertools import chain
x = {'a':1, 'b': 2}
y = {'b':10, 'c': 11}
dict(chain(x.iteritems(), y.iteritems()))

它比 快，但不如 快，至少在 CPython 上是这样。如果您更改为 ，此版本也适用于 Python 3，这是由 2to3 工具自动完成的。dict(x.items() + y.items())n = copy(a); n.update(b)iteritems()items()

就我个人而言，我最喜欢这个版本，因为它在单个函数语法中很好地描述了我想要的东西。唯一的小问题是，y 的值优先于 x 的值并不完全明显，但我认为这并不难弄清楚。

虽然这个问题已经回答了好几次， 尚未列出该问题的简单解决方案。

x = {'a':1, 'b': 2}
y = {'b':10, 'c': 11}
z4 = {}
z4.update(x)
z4.update(y)

它与上面提到的 z0 和邪恶的 z2 一样快，但易于理解和更改。

如果您认为 lambda 是邪恶的，那么不要再读下去了。 根据要求，您可以使用一个表达式编写快速且节省内存的解决方案：

x = {'a':1, 'b':2}
y = {'b':10, 'c':11}
z = (lambda a, b: (lambda a_copy: a_copy.update(b) or a_copy)(a.copy()))(x, y)
print z
{'a': 1, 'c': 11, 'b': 10}
print x
{'a': 1, 'b': 2}

如上所述，使用两行或编写一个函数可能是更好的方法。

递归/深度更新字典

def deepupdate(original, update):
    """
    Recursively update a dict.
    Subdict's won't be overwritten but also updated.
    """
    for key, value in original.iteritems(): 
        if key not in update:
            update[key] = value
        elif isinstance(value, dict):
            deepupdate(value, update[key]) 
    return update

示范：

pluto_original = {
    'name': 'Pluto',
    'details': {
        'tail': True,
        'color': 'orange'
    }
}

pluto_update = {
    'name': 'Pluutoo',
    'details': {
        'color': 'blue'
    }
}

print deepupdate(pluto_original, pluto_update)

输出：

{
    'name': 'Pluutoo',
    'details': {
        'color': 'blue',
        'tail': True
    }
}

感谢 rednaw 的编辑。

def dict_merge(a, b):
  c = a.copy()
  c.update(b)
  return c

new = dict_merge(old, extras)

在这些阴暗和可疑的答案中，这个光辉的例子是在 Python 中合并字典的唯一好方法，得到了终身独裁者 Guido van Rossum 本人的认可！其他人提出了其中的一半，但没有将其放入函数中。

print dict_merge(
      {'color':'red', 'model':'Mini'},
      {'model':'Ferrari', 'owner':'Carl'})

给：

{'color': 'red', 'owner': 'Carl', 'model': 'Ferrari'}

两本词典

def union2(dict1, dict2):
    return dict(list(dict1.items()) + list(dict2.items()))

n 词典

def union(*dicts):
    return dict(itertools.chain.from_iterable(dct.items() for dct in dicts))

sum表现不佳。查看 https://mathieularose.com/how-not-to-flatten-a-list-of-lists-in-python/

在 Python 3.0 及更高版本中，可以使用集合。ChainMap，它将多个字典或其他映射组合在一起，以创建一个单一的、可更新的视图：

>>> from collections import ChainMap
>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> z = dict(ChainMap({}, y, x))
>>> for k, v in z.items():
        print(k, '-->', v)
    
a --> 1
b --> 10
c --> 11

Python 3.5 及更高版本的更新：您可以使用 PEP 448 扩展字典打包和解包。这既快速又简单：

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

Python 3.9 及更高版本的更新：您可以使用 PEP 584 联合运算符：

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

使用字典推导，您可以

x = {'a':1, 'b': 2}
y = {'b':10, 'c': 11}

dc = {xi:(x[xi] if xi not in list(y.keys()) 
           else y[xi]) for xi in list(x.keys())+(list(y.keys()))}

给

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

请注意 in comprehension 的语法if else

{ (some_key if condition else default_key):(something_if_true if condition 
          else something_if_false) for key, value in dict_.items() }

借鉴这里和其他地方的想法，我理解了一个函数：

def merge(*dicts, **kv): 
      return { k:v for d in list(dicts) + [kv] for k,v in d.items() }

用法（在 python 3 中测试）：

assert (merge({1:11,'a':'aaa'},{1:99, 'b':'bbb'},foo='bar')==\
    {1: 99, 'foo': 'bar', 'b': 'bbb', 'a': 'aaa'})

assert (merge(foo='bar')=={'foo': 'bar'})

assert (merge({1:11},{1:99},foo='bar',baz='quux')==\
    {1: 99, 'foo': 'bar', 'baz':'quux'})

assert (merge({1:11},{1:99})=={1: 99})

您可以改用 lambda。

滥用导致了 Matthew 回答的单表达式解决方案：

>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> z = (lambda f=x.copy(): (f.update(y), f)[1])()
>>> z
{'a': 1, 'c': 11, 'b': 10}

你说你想要一个表达式，所以我滥用来绑定一个名称，并使用元组来覆盖 lambda 的单表达式限制。随意畏缩。lambda

当然，如果您不关心复制它，也可以这样做：

>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> z = (x.update(y), x)[1]
>>> z
{'a': 1, 'b': 10, 'c': 11}

在 python3 中，该方法不再返回列表，而是返回一个视图，其作用类似于集合。在这种情况下，您需要采用集合并集，因为连接 将不起作用：items+

dict(x.items() | y.items())

对于 2.7 版中类似 python3 的行为，该方法应代替：viewitemsitems

dict(x.viewitems() | y.viewitems())

无论如何，我更喜欢这种表示法，因为将其视为集合联合操作而不是串联（如标题所示）似乎更自然。

编辑：

python 3 还有几点。首先，请注意，除非 中的键是字符串，否则该技巧在 python 3 中不起作用。dict(x, **y)y

此外，Raymond Hettinger 的 Chainmap 答案非常优雅，因为它可以接受任意数量的字典作为参数，但从文档来看，它似乎按顺序查看了每次查找的所有字典列表：

查找将依次搜索基础映射，直到找到键。

如果您的应用程序中有很多查找，这可能会减慢您的速度：

In [1]: from collections import ChainMap
In [2]: from string import ascii_uppercase as up, ascii_lowercase as lo; x = dict(zip(lo, up)); y = dict(zip(up, lo))
In [3]: chainmap_dict = ChainMap(y, x)
In [4]: union_dict = dict(x.items() | y.items())
In [5]: timeit for k in union_dict: union_dict[k]
100000 loops, best of 3: 2.15 µs per loop
In [6]: timeit for k in chainmap_dict: chainmap_dict[k]
10000 loops, best of 3: 27.1 µs per loop

因此，查找速度大约慢了一个数量级。我是 Chainmap 的粉丝，但在可能有很多查找的地方看起来不太实用。

>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> x, z = dict(x), x.update(y) or x
>>> x
{'a': 1, 'b': 2}
>>> y
{'c': 11, 'b': 10}
>>> z
{'a': 1, 'c': 11, 'b': 10}

迄今为止，我对列出的解决方案的问题是，在合并的字典中，键“b”的值是 10，但按照我的思维方式，它应该是 12。 有鉴于此，我提出以下几点：

import timeit

n=100000
su = """
x = {'a':1, 'b': 2}
y = {'b':10, 'c': 11}
"""

def timeMerge(f,su,niter):
    print "{:4f} sec for: {:30s}".format(timeit.Timer(f,setup=su).timeit(n),f)

timeMerge("dict(x, **y)",su,n)
timeMerge("x.update(y)",su,n)
timeMerge("dict(x.items() + y.items())",su,n)
timeMerge("for k in y.keys(): x[k] = k in x and x[k]+y[k] or y[k] ",su,n)

#confirm for loop adds b entries together
x = {'a':1, 'b': 2}
y = {'b':10, 'c': 11}
for k in y.keys(): x[k] = k in x and x[k]+y[k] or y[k]
print "confirm b elements are added:",x

结果：

0.049465 sec for: dict(x, **y)
0.033729 sec for: x.update(y)                   
0.150380 sec for: dict(x.items() + y.items())   
0.083120 sec for: for k in y.keys(): x[k] = k in x and x[k]+y[k] or y[k]

confirm b elements are added: {'a': 1, 'c': 11, 'b': 12}

太傻了，什么也没回来。
我只是使用一个简单的辅助函数来解决问题：.update

def merge(dict1,*dicts):
    for dict2 in dicts:
        dict1.update(dict2)
    return dict1

例子：

merge(dict1,dict2)
merge(dict1,dict2,dict3)
merge(dict1,dict2,dict3,dict4)
merge({},dict1,dict2)  # this one returns a new copy

OP 的两个词典的合并是这样的：

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

具体来说，两个实体（和）的并集包含和/或的所有元素。 不幸的是，尽管帖子的标题如此，但 OP 要求的不是工会。xyxy

我下面的代码既不优雅也不单行，但我相信它与联合的含义是一致的。

从 OP 的示例中：

x = {'a':1, 'b': 2}
y = {'b':10, 'c': 11}

z = {}
for k, v in x.items():
    if not k in z:
        z[k] = [(v)]
    else:
        z[k].append((v))
for k, v in y.items():
    if not k in z:
        z[k] = [(v)]
    else:
        z[k].append((v))

{'a': [1], 'b': [2, 10], 'c': [11]}

是否可以更改列表，但如果字典包含列表（和嵌套列表）作为任一字典中的值，则上述方法将起作用。

如何在一个表达式中合并两个 Python 字典？

对于字典 和 ，其浅层合并字典从 中获取值，替换 中的值。xyzyx

• 在 Python 3.9.0 或更高版本（2020 年 10 月 17 日发布，PEP-584，在此处讨论）：

  z = x | y
  

• 在 Python 3.5 或更高版本中：

  z = {**x, **y}
  

• 在 Python 2（或 3.4 或更低版本）中，编写一个函数：

  def merge_two_dicts(x, y):
      z = x.copy()   # start with keys and values of x
      z.update(y)    # modifies z with keys and values of y
      return z
  

  现在：

  z = merge_two_dicts(x, y)
  

解释

假设您有两个词典，并且想要将它们合并到一个新词典中，而不更改原始词典：

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}

这确实是一个单一的表达方式。

请注意，我们也可以与文字表示法合并：

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

在这两种方法中，will 排在第二位，其值将取代 的值，因此将指向我们的最终结果。yxb3

尚未在 Python 3.5 上，但想要一个表达式

如果您还没有使用 Python 3.5 或需要编写向后兼容的代码，并且希望在单个表达式中实现此代码，那么性能最高的正确方法是将其放在函数中：

def merge_two_dicts(x, y):
    """Given two dictionaries, merge them into a new dict as a shallow copy."""
    z = x.copy()
    z.update(y)
    return z

然后你有一个表达式：

z = merge_two_dicts(x, y)

您还可以创建一个函数来合并任意数量的字典，从零到非常大的数字：

def merge_dicts(*dict_args):
    """
    Given any number of dictionaries, shallow copy and merge into a new dict,
    precedence goes to key-value pairs in latter dictionaries.
    """
    result = {}
    for dictionary in dict_args:
        result.update(dictionary)
    return result

此函数将在 Python 2 和 3 中适用于所有字典。例如，将词典提供给：ag

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

中的键值对将优先于 字典，依此类推。gaf

对其他答案的批评

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

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

同样，当值是不可哈希的对象（例如列表）时，在 Python 3（在 Python 2.7 中）中获取 的并集也会失败。即使您的值是可哈希的，由于集合在语义上是无序的，因此在优先级方面的行为是未定义的。所以不要这样做：items()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'

下面是一个示例，其中应该具有优先级，但由于集合的任意顺序，因此保留了 from 的值：yx

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

另一个你不应该使用的技巧：

z = dict(x, **y)

这使用构造函数，并且非常快速且节省内存（甚至比我们的两步过程略高），但除非您确切地知道这里发生了什么（也就是说，第二个 dict 作为关键字参数传递给 dict 构造函数），否则很难阅读，它不是预期的用法，因此它不是 Pythonic。dict

下面是 django 中修复的用法示例。

字典旨在采用可哈希键（例如 s 或元组），但当键不是字符串时，此方法在 Python 3 中失败。frozenset

>>> 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 规范，顺便说一句。适用于 Python 2 和 3。事实上，这只适用于字符串键，这是关键字参数工作方式的直接结果，而不是 dict 的缺点。在这个地方使用 ** 运算符也不是滥用该机制，事实上，** 被设计为将字典作为关键字传递。dict(x, **y)

同样，当键不是字符串时，它不适用于 3。隐式调用协定是命名空间采用普通字典，而用户只能传递字符串的关键字参数。所有其他可调用对象都强制执行它。 在 Python 2 中打破了这种一致性：dict

>>> 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 最具可读性的解决方案。可读性很重要。

我的回答是：实际上，如果我们真的关心可读性，对我来说似乎更清楚。而且它不向前兼容，因为 Python 2 越来越被弃用。merge_two_dicts(x, y)

{**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: {}}}

提出其他值类型的偶然性远远超出了这个问题的范围，所以我将向您指出我对“字典的字典合并”的规范问题的答案。

性能较低但正确的 Ad-hocs

这些方法的性能较低，但它们将提供正确的行为。 它们的性能将比 和/或新的解包低得多，因为它们在更高的抽象级别遍历每个键值对，但它们确实遵循优先级顺序（后面的字典具有优先级）copyupdate

您还可以在字典推导式中手动链接词典：

{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()) # iteritems in Python 2

itertools.chain将迭代器按正确的顺序链接到键值对上：

from itertools import chain
z = dict(chain(x.items(), y.items())) # iteritems in Python 2

性能分析

我只将对已知行为正确的用法进行性能分析。（独立，因此您可以自行复制和粘贴。

from timeit import repeat
from itertools import chain

x = dict.fromkeys('abcdefg')
y = dict.fromkeys('efghijk')

def merge_two_dicts(x, y):
    z = x.copy()
    z.update(y)
    return z

min(repeat(lambda: {**x, **y}))
min(repeat(lambda: merge_two_dicts(x, y)))
min(repeat(lambda: {k: v for d in (x, y) for k, v in d.items()}))
min(repeat(lambda: dict(chain(x.items(), y.items()))))
min(repeat(lambda: dict(item for d in (x, y) for item in d.items())))

在 Python 3.8.1 中，NixOS：

>>> min(repeat(lambda: {**x, **y}))
1.0804965235292912
>>> min(repeat(lambda: merge_two_dicts(x, y)))
1.636518670246005
>>> min(repeat(lambda: {k: v for d in (x, y) for k, v in d.items()}))
3.1779992282390594
>>> min(repeat(lambda: dict(chain(x.items(), y.items()))))
2.740647904574871
>>> min(repeat(lambda: dict(item for d in (x, y) for item in d.items())))
4.266070580109954

$ uname -a
Linux nixos 4.19.113 #1-NixOS SMP Wed Mar 25 07:06:15 UTC 2020 x86_64 GNU/Linux

词典资源

• 我对 Python 字典实现的解释，更新为 3.6。
• 关于如何向字典添加新键的答案
• 将两个列表映射到字典中
• 关于字典的官方 Python 文档
• The Dictionary Even Mightier - Brandon Rhodes 在 Pycon 2017 上的演讲
• Modern Python Dictionaries， A Confluence of Great Ideas - Raymond Hettinger 在 Pycon 2017 上的演讲

Python 3.5 （PEP 448） 允许更好的语法选项：

x = {'a': 1, 'b': 1}
y = {'a': 2, 'c': 2}
final = {**x, **y} 
final
# {'a': 2, 'b': 1, 'c': 2}

甚至

final = {'a': 1, 'b': 1, **x, **y}

在 Python 3.9 中，您还可以使用 |和 |= 与以下来自 PEP 584 的示例

d = {'spam': 1, 'eggs': 2, 'cheese': 3}
e = {'cheese': 'cheddar', 'aardvark': 'Ethel'}
d | e
# {'spam': 1, 'eggs': 2, 'cheese': 'cheddar', 'aardvark': 'Ethel'}

这可以通过单个字典推导来完成：

>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> { key: y[key] if key in y else x[key]
      for key in set(x) + set(y)
    }

在我看来，“单一表达式”部分的最佳答案是不需要额外的函数，而且它很短。

使用保留顺序的迭代工具的简单解决方案（后面的字典具有优先权）

# py2
from itertools import chain, imap
merge = lambda *args: dict(chain.from_iterable(imap(dict.iteritems, args)))

# py3
from itertools import chain
merge = lambda *args: dict(chain.from_iterable(map(dict.items, args)))

它的用法是：

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

>>> z = {'c': 3, 'd': 4}
>>> merge(x, y, z)
{'a': 1, 'b': 10, 'c': 3, 'd': 4}

from collections import Counter
dict1 = {'a':1, 'b': 2}
dict2 = {'b':10, 'c': 11}
result = dict(Counter(dict1) + Counter(dict2))

这应该可以解决您的问题。

是 Pythonic。使用理解：

z={k: v for d in [x,y] for k, v in d.items()}

>>> print z
{'a': 1, 'c': 11, 'b': 10}

（仅适用于 Python 2.7*;Python 3* 有更简单的解决方案。

如果您不反对导入标准库模块，则可以这样做

from functools import reduce

def merge_dicts(*dicts):
    return reduce(lambda a, d: a.update(d) or a, dicts, {})

（中的位是必需的，因为总是在成功时返回。or alambdadict.updateNone

我知道这并不真正符合问题的具体细节（“一句话”），但由于上面的答案都没有朝这个方向发展，而很多答案都解决了性能问题，我觉得我应该贡献我的想法。

根据用例的不同，可能没有必要为给定的输入词典创建“真实”合并词典。在许多情况下，这样做的视图可能就足够了，即一个对象的行为类似于合并的字典，而无需完全计算它。可以这么说，合并词典的懒惰版本。

在 Python 中，这相当简单，可以使用我文章末尾显示的代码来完成。鉴于此，原始问题的答案将是：

z = MergeDict(x, y)

使用这个新对象时，它的行为类似于合并的字典，但它将具有恒定的创建时间和恒定的内存占用，同时保持原始字典不变。创建它比提出的其他解决方案便宜得多。

当然，如果你经常使用这个结果，那么你将在某个时候达到一个极限，创建一个真正的合并词典本来是更快的解决方案。正如我所说，这取决于您的用例。

如果您曾经觉得您更愿意进行真正的合并，那么调用会产生它（但当然比其他解决方案更昂贵，所以这值得一提）。dictdict(z)

你也可以使用这个类来制作一种写时复制字典：

a = { 'x': 3, 'y': 4 }
b = MergeDict(a)  # we merge just one dict
b['x'] = 5
print b  # will print {'x': 5, 'y': 4}
print a  # will print {'y': 4, 'x': 3}

这是直截了当的代码：MergeDict

class MergeDict(object):
  def __init__(self, *originals):
    self.originals = ({},) + originals[::-1]  # reversed

  def __getitem__(self, key):
    for original in self.originals:
      try:
        return original[key]
      except KeyError:
        pass
    raise KeyError(key)

  def __setitem__(self, key, value):
    self.originals[0][key] = value

  def __iter__(self):
    return iter(self.keys())

  def __repr__(self):
    return '%s(%s)' % (
      self.__class__.__name__,
      ', '.join(repr(original)
          for original in reversed(self.originals)))

  def __str__(self):
    return '{%s}' % ', '.join(
        '%r: %r' % i for i in self.iteritems())

  def iteritems(self):
    found = set()
    for original in self.originals:
      for k, v in original.iteritems():
        if k not in found:
          yield k, v
          found.add(k)

  def items(self):
    return list(self.iteritems())

  def keys(self):
    return list(k for k, _ in self.iteritems())

  def values(self):
    return list(v for _, v in self.iteritems())

为此，您可以使用 toolz.merge（[x， y]）。

这个问题被标记了，但考虑到这是一个相对较新的添加，并且投票最多、被接受的答案广泛涉及 Python 2.x 解决方案，我敢添加一个利用 Python 2.x 列表推导的令人讨厌的功能的一句话，即名称泄露......python-3x

$ python2
Python 2.7.13 (default, Jan 19 2017, 14:48:08) 
[GCC 6.3.0 20170118] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> [z.update(d) for z in [{}] for d in (x, y)]
[None, None]
>>> z
{'a': 1, 'c': 11, 'b': 10}
>>> ...

我很高兴地说，上述内容在任何版本的 Python 3 上都不再有效。

如果你不介意变异，x

x.update(y) or x

简单、可读、高性能。您知道总是返回 ，这是一个 false 值。因此，上面的表达式在更新后将始终计算为 。update()Nonex

标准库中的大多数突变方法（如）都按照约定返回，因此这种模式也适用于这些方法。但是，如果您使用的是 dict 子类或其他一些不遵循此约定的方法，则可能会返回其左操作数，这可能不是您想要的。相反，您可以使用元组显示和索引，无论第一个元素的计算结果如何，它都可以工作（尽管它不那么漂亮）：.update()Noneor

(x.update(y), x)[-1]

如果还没有变量，则可以在不使用赋值语句的情况下创建局部变量。这相当于用作 let 表达式，这是函数式语言中的一种常见技术，但可能是非 pythonic。xlambdalambda

(lambda x: x.update(y) or x)({'a': 1, 'b': 2})

虽然它与以下使用 new walrus 运算符（仅限 Python 3.8+）没有太大区别，

(x := {'a': 1, 'b': 2}).update(y) or x

特别是当您使用默认参数时：

(lambda x={'a': 1, 'b': 2}: x.update(y) or x)()

如果你确实想要一个副本，PEP 584 风格是 3.9+ 上最 Pythonic 的。如果您必须支持旧版本，PEP 448 样式对于 3.5+ 来说是最简单的。但是，如果这在您（甚至更旧的）Python 版本中不可用，那么 let 表达式模式在这里也有效。x | y{**x, **y}

(lambda z=x.copy(): z.update(y) or z)()

（当然，这几乎等同于 ，但如果您的 Python 版本足够新，那么 PEP 448 样式将可用。(z := x.copy()).update(y) or z

我很好奇我是否可以用一行字符串化方法击败公认的答案的时间：

我尝试了 5 种方法，之前没有提到过 - 所有一种衬里 - 都产生了正确的答案 - 我无法接近。

所以。。。为了省去你的麻烦，也许满足你的好奇心：

import json
import yaml
import time
from ast import literal_eval as literal

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

x = {'a':1, 'b': 2}
y = {'b':10, 'c': 11}

start = time.time()
for i in range(10000):
    z = yaml.load((str(x)+str(y)).replace('}{',', '))
elapsed = (time.time()-start)
print (elapsed, z, 'stringify yaml')

start = time.time()
for i in range(10000):
    z = literal((str(x)+str(y)).replace('}{',', '))
elapsed = (time.time()-start)
print (elapsed, z, 'stringify literal')

start = time.time()
for i in range(10000):
    z = eval((str(x)+str(y)).replace('}{',', '))
elapsed = (time.time()-start)
print (elapsed, z, 'stringify eval')

start = time.time()
for i in range(10000):
    z = {k:int(v) for k,v in (dict(zip(
            ((str(x)+str(y))
            .replace('}',' ')
            .replace('{',' ')
            .replace(':',' ')
            .replace(',',' ')
            .replace("'",'')
            .strip()
            .split('  '))[::2], 
            ((str(x)+str(y))
            .replace('}',' ')
            .replace('{',' ').replace(':',' ')
            .replace(',',' ')
            .replace("'",'')
            .strip()
            .split('  '))[1::2]
             ))).items()}
elapsed = (time.time()-start)
print (elapsed, z, 'stringify replace')

start = time.time()
for i in range(10000):
    z = json.loads(str((str(x)+str(y)).replace('}{',', ').replace("'",'"')))
elapsed = (time.time()-start)
print (elapsed, z, 'stringify json')

start = time.time()
for i in range(10000):
    z = merge_two_dicts(x, y)
elapsed = (time.time()-start)
print (elapsed, z, 'accepted')

结果：

7.693928956985474 {'c': 11, 'b': 10, 'a': 1} stringify yaml
0.29134678840637207 {'c': 11, 'b': 10, 'a': 1} stringify literal
0.2208399772644043 {'c': 11, 'b': 10, 'a': 1} stringify eval
0.1106564998626709 {'c': 11, 'b': 10, 'a': 1} stringify replace
0.07989692687988281 {'c': 11, 'b': 10, 'a': 1} stringify json
0.005082368850708008 {'c': 11, 'b': 10, 'a': 1} accepted

我从中学到的是，JSON方法是从字典字符串返回字典的最快方法（尝试过的方法）;比我认为是正常方法快得多（大约是 1/4 的时间）。我还了解到，应该不惜一切代价避免使用 YAML 方法。ast

是的，我知道这不是最好/正确的方法。我很好奇它是否更快，但事实并非如此;我发帖证明这一点。

这是 Python 3.5 或更高版本的表达式，它使用以下命令合并字典：reduce

>>> from functools import reduce
>>> l = [{'a': 1}, {'b': 2}, {'a': 100, 'c': 3}]
>>> reduce(lambda x, y: {**x, **y}, l, {})
{'a': 100, 'b': 2, 'c': 3}

注意：即使字典列表为空或仅包含一个元素，这也有效。

为了在 Python 3.9 或更高版本上进行更有效的合并，可以直接替换为：lambdaoperator.ior

>>> from functools import reduce
>>> from operator import ior
>>> l = [{'a': 1}, {'b': 2}, {'a': 100, 'c': 3}]
>>> reduce(ior, l, {})
{'a': 100, 'b': 2, 'c': 3}

对于 Python 3.8 或更低版本，可以使用以下内容作为替代：ior

>>> from functools import reduce
>>> l = [{'a': 1}, {'b': 2}, {'a': 100, 'c': 3}]
>>> reduce(lambda x, y: x.update(y) or x, l, {})
{'a': 100, 'b': 2, 'c': 3}

我认为我丑陋的单行本在这里是必要的。

z = next(z.update(y) or z for z in [x.copy()])
# or
z = (lambda z: z.update(y) or z)(x.copy())

1. 字典被合并。
2. 单个表达式。
3. 永远不敢使用它。

附言这是一个适用于两个 Python 版本的解决方案。我知道 Python 3 有这个东西，而且使用起来是正确的（如果你仍然有 Python 2，那么迁移到 Python 3 是正确的做法）。{**x, **y}

Python 3.8 发布时（计划于 2019 年 10 月 20 日发布）将有一个新选项，这要归功于 PEP 572：赋值表达式。新的赋值表达式运算符允许您赋值 的结果，并且仍然使用它来调用 ，使组合代码成为单个表达式，而不是两个语句，更改：:=copyupdate

newdict = dict1.copy()
newdict.update(dict2)

自：

(newdict := dict1.copy()).update(dict2)

同时在各个方面都表现得相同。如果你还必须返回结果（你要求一个返回的表达式;上面的表达式创建并赋值给 ，但没有返回它，所以你不能用它来将参数按原样传递给函数，a la ），那么只需添加到末尾（因为 returns ，这是虚假的，然后它将计算并返回作为表达式的结果）：dictdictnewdictmyfunc((newdict := dict1.copy()).update(dict2))or newdictupdateNonenewdict

(newdict := dict1.copy()).update(dict2) or newdict

重要警告：一般来说，我不鼓励这种方法，而赞成：

newdict = {**dict1, **dict2}

解包方法更清晰（对于任何首先了解广义解包的人来说，你应该这样做），根本不需要结果的名称（因此在构造一个立即传递给函数或包含在 / 文字等中的临时时，它要简洁得多），并且几乎可以肯定也更快， （在 CPython 上）大致相当于：listtuple

newdict = {}
newdict.update(dict1)
newdict.update(dict2)

但是在 C 层完成，使用具体的 API，因此不涉及动态方法查找/绑定或函数调用调度开销（其中不可避免地与行为上的原始两行相同，以离散步骤执行工作，动态查找/绑定/调用方法。dict(newdict := dict1.copy()).update(dict2)

它也更具可扩展性，因为合并三个 S 是显而易见的：dict

newdict = {**dict1, **dict2, **dict3}

其中使用赋值表达式不会像那样缩放;你能得到的最接近的是：

(newdict := dict1.copy()).update(dict2), newdict.update(dict3)

或者没有 s 的临时元组，但对每个结果进行真实性测试：NoneNone

(newdict := dict1.copy()).update(dict2) or newdict.update(dict3)

这两者显然都更丑陋，并且包括进一步的低效率（要么是暂时浪费 S 用于逗号分隔，要么是对每个 ' 返回进行毫无意义的真实性测试以进行分离）。tupleNoneupdateNoneor

赋值表达式方法的唯一真正优势发生在以下情况下：

1. 你有通用代码，需要同时处理 set s 和 dict s（它们都支持 和 ，所以代码的工作方式大致符合你的预期）copyupdate
2. 你希望收到任意的类似字典的对象，而不仅仅是它自己，并且必须保留左侧的类型和语义（而不是以普通的结尾结束）。虽然可能有效，但它会涉及一个额外的临时，如果具有普通无法保留的功能（例如，常规 s 现在根据键的第一次出现保留顺序，而值基于键的最后一次出现;你可能想要一个根据键的最后一次出现保留顺序，因此更新值也会将其移动到末尾）， 那么语义就错了。由于赋值表达式版本使用命名方法（这些方法可能被重载以适当运行），因此它根本不会创建一个（除非已经是 ），保留原始类型（和原始类型的语义），同时避免任何临时性。dictdictmyspecialdict({**speciala, **specialb})dictmyspecialdictdictdictdictdict1dict

仅限 Python 3.9+

合并 （|） 和更新 （|=） 运算符已添加到内置类中。dict

>>> d = {'spam': 1, 'eggs': 2, 'cheese': 3}
>>> e = {'cheese': 'cheddar', 'aardvark': 'Ethel'}
>>> d | e
{'spam': 1, 'eggs': 2, 'cheese': 'cheddar', 'aardvark': 'Ethel'}

增强分配版本就地运行：

>>> d |= e
>>> d
{'spam': 1, 'eggs': 2, 'cheese': 'cheddar', 'aardvark': 'Ethel'}

参见 PEP 584

Python 3.9 中的新功能：使用联合运算符 （） 合并 s，类似于 s：|dictset

>>> d = {'a': 1, 'b': 2}
>>> e = {'a': 9, 'c': 3}
>>> d | e
{'a': 9, 'b': 2, 'c': 3}

对于匹配的键，正确的字典优先。

这也适用于修改就地：|=dict

>>> e |= d    # e = e | d
>>> e
{'a': 1, 'c': 3, 'b': 2}

我用perfplot对建议进行了基准测试，发现

x | y   # Python 3.9+

是与老好一起最快的解决方案

{**x, **y}

和

temp = x.copy()
temp.update(y)

---

重现绘图的代码：

from collections import ChainMap
from itertools import chain
import perfplot


def setup(n):
    x = dict(zip(range(n), range(n)))
    y = dict(zip(range(n, 2 * n), range(n, 2 * n)))
    return x, y


def copy_update(x, y):
    temp = x.copy()
    temp.update(y)
    return temp


def add_items(x, y):
    return dict(list(x.items()) + list(y.items()))


def curly_star(x, y):
    return {**x, **y}


def chain_map(x, y):
    return dict(ChainMap({}, y, x))


def itertools_chain(x, y):
    return dict(chain(x.items(), y.items()))


def python39_concat(x, y):
    return x | y


b = perfplot.bench(
    setup=setup,
    kernels=[
        copy_update,
        add_items,
        curly_star,
        chain_map,
        itertools_chain,
        python39_concat,
    ],
    labels=[
        "copy_update",
        "dict(list(x.items()) + list(y.items()))",
        "{**x, **y}",
        "chain_map",
        "itertools.chain",
        "x | y",
    ],
    n_range=[2 ** k for k in range(18)],
    xlabel="len(x), len(y)",
    equality_check=None,
)
b.save("out.png")
b.show()

在 Python 3.9 中

基于 PEP 584，新版本的 Python 为字典引入了两个新的运算符：union （|） 和 in-place union （|=）。您可以使用 |合并两个字典，而 |= 将就地更新字典：

>>> pycon = {2016: "Portland", 2018: "Cleveland"}
>>> europython = {2017: "Rimini", 2018: "Edinburgh", 2019: "Basel"}

>>> pycon | europython
{2016: 'Portland', 2018: 'Edinburgh', 2017: 'Rimini', 2019: 'Basel'}

>>> pycon |= europython
>>> pycon
{2016: 'Portland', 2018: 'Edinburgh', 2017: 'Rimini', 2019: 'Basel'}

如果 d1 和 d2 是两个字典，则执行与 相同的操作。这 |运算符用于计算集合的并集，因此您可能已经熟悉了该符号。d1 | d2{**d1, **d2}

使用的一个优点是它适用于不同的类似字典的类型，并在合并过程中保留该类型：|

>>> from collections import defaultdict
>>> europe = defaultdict(lambda: "", {"Norway": "Oslo", "Spain": "Madrid"})
>>> africa = defaultdict(lambda: "", {"Egypt": "Cairo", "Zimbabwe": "Harare"})

>>> europe | africa
defaultdict(<function <lambda> at 0x7f0cb42a6700>,
  {'Norway': 'Oslo', 'Spain': 'Madrid', 'Egypt': 'Cairo', 'Zimbabwe': 'Harare'})

>>> {**europe, **africa}
{'Norway': 'Oslo', 'Spain': 'Madrid', 'Egypt': 'Cairo', 'Zimbabwe': 'Harare'}

当您想要有效地处理缺少的键时，可以使用 defaultdict。请注意，保留 defaultdict，而不保留。|{**europe, **africa}

字典的工作方式与列表的工作方式之间存在一些相似之处。事实上，运算符最初也被提议合并字典。当您查看就地运算符时，这种对应关系变得更加明显。|++

的基本用途是就地更新字典，类似于：|=.update()

>>> libraries = {
...     "collections": "Container datatypes",
...     "math": "Mathematical functions",
... }
>>> libraries |= {"zoneinfo": "IANA time zone support"}
>>> libraries
{'collections': 'Container datatypes', 'math': 'Mathematical functions',
 'zoneinfo': 'IANA time zone support'}

将词典与 合并时，两个词典都需要具有正确的词典类型。另一方面，就地运算符 （） 乐于使用任何类似字典的数据结构：||=

>>> libraries |= [("graphlib", "Functionality for graph-like structures")]
>>> libraries
{'collections': 'Container datatypes', 'math': 'Mathematical functions',
 'zoneinfo': 'IANA time zone support',
 'graphlib': 'Functionality for graph-like structures'}

一种方法是深度合并。在 3.9+ 中使用运算符，用于 dict 是一组默认设置，dict 是一组正在使用的现有设置。我的目标是合并任何添加的设置，而不覆盖 中的现有设置。我相信这种递归实现将允许人们使用来自另一个字典的新值升级字典。|newexistingnewexisting

def merge_dict_recursive(new: dict, existing: dict):
    merged = new | existing

    for k, v in merged.items():
        if isinstance(v, dict):
            if k not in existing:
                # The key is not in existing dict at all, so add entire value
                existing[k] = new[k]

            merged[k] = merge_dict_recursive(new[k], existing[k])
    return merged

测试数据示例：

new
{'dashboard': True,
 'depth': {'a': 1, 'b': 22222, 'c': {'d': {'e': 69}}},
 'intro': 'this is the dashboard',
 'newkey': False,
 'show_closed_sessions': False,
 'version': None,
 'visible_sessions_limit': 9999}
existing
{'dashboard': True,
 'depth': {'a': 5},
 'intro': 'this is the dashboard',
 'newkey': True,
 'show_closed_sessions': False,
 'version': '2021-08-22 12:00:30.531038+00:00'}
merged
{'dashboard': True,
 'depth': {'a': 5, 'b': 22222, 'c': {'d': {'e': 69}}},
 'intro': 'this is the dashboard',
 'newkey': True,
 'show_closed_sessions': False,
 'version': '2021-08-22 12:00:30.531038+00:00',
 'visible_sessions_limit': 9999}

字典深度合并：

from typing import List, Dict
from copy import deepcopy

def merge_dicts(*from_dicts: List[Dict], no_copy: bool=False) -> Dict :
    """ no recursion deep merge of two dicts

    By default creates fresh Dict and merges all to it.

    no_copy = True, will merge all dicts to a fist one in a list without copy.
    Why? Sometime I need to combine one dictionary from "layers".
    The "layers" are not in use and dropped immediately after merging.
    """

    if no_copy:
        xerox = lambda x:x
    else:
        xerox = deepcopy

    result = xerox(from_dicts[0])

    for _from in from_dicts[1:]:
        merge_queue = [(result, _from)]
        for _to, _from in merge_queue:
            for k, v in _from.items():
                if k in _to and isinstance(_to[k], dict) and isinstance(v, dict):
                    # key collision add both are dicts.
                    # add to merging queue
                    merge_queue.append((_to[k], v))
                    continue
                _to[k] = xerox(v)

    return result

用法：

print("=============================")
print("merge all dicts to first one without copy.")
a0 = {"a":{"b":1}}
a1 = {"a":{"c":{"d":4}}}
a2 = {"a":{"c":{"f":5}, "d": 6}}
print(f"a0 id[{id(a0)}] value:{a0}")
print(f"a1 id[{id(a1)}] value:{a1}")
print(f"a2 id[{id(a2)}] value:{a2}")
r = merge_dicts(a0, a1, a2, no_copy=True)
print(f"r  id[{id(r)}] value:{r}")

print("=============================")
print("create fresh copy of all")
a0 = {"a":{"b":1}}
a1 = {"a":{"c":{"d":4}}}
a2 = {"a":{"c":{"f":5}, "d": 6}}
print(f"a0 id[{id(a0)}] value:{a0}")
print(f"a1 id[{id(a1)}] value:{a1}")
print(f"a2 id[{id(a2)}] value:{a2}")
r = merge_dicts(a0, a1, a2)
print(f"r  id[{id(r)}] value:{r}")