如何在Python中合并词典？

据我所知，这本词典合并了这本词典。但是，它是独一无二的吗？如果d1的键与d2相同，但值不同，该怎么办？我希望将d1和d2合并，但如果存在重复密钥，则d1具有优先权。

如果不再需要原始

d2

，则可以使用该方法：

使用其他键/值对更新字典，覆盖现有键。返回

None

例如：

更新：

当然，为了创建新的合并词典，您可以先复制词典。这可能是必要的，也可能不是。如果您的字典中有复合对象（包含其他对象的对象，如列表或类实例），也应该考虑。

在Python2中

>>> d1 = {'a': 1, 'b': 2} 
>>> d2 = {'b': 1, 'c': 3}
>>> d2.update(d1)
>>> d2
{'a': 1, 'c': 3, 'b': 2}

d1凌驾d2：

d1={'a':1,'b':2}
d2={'a':10,'c':3}

d2凌驾于d1之上：

dict(d2,**d1)
# {'a': 1, 'c': 3, 'b': 2}

这种行为不仅仅是实现的侥幸；保证：

如果在 位置参数和作为关键字 参数，与 关键字将保留在 字典

---

如果希望

d1

在冲突中具有优先权，请执行以下操作：

dict(d1,**d2)
# {'a': 10, 'c': 3, 'b': 2}

---

否则，反向执行

d2

和

d1

我的解决方案是定义一个合并函数。它并不复杂，只需要一条线。下面是Python 3中的代码

d3 = d2.copy()
d3.update(d1)

测验

---

它适用于任意数量的字典参数。如果这些字典中有任何重复的键，则参数列表中最右边字典中的键将获胜。

概述了合并多个字典的几个选项，包括（对于python3.3+）和。

我相信，如上所述，使用

d2.update（d1）

是最好的方法，如果您仍然需要，也可以先复制

d2

尽管如此，我还是想指出，

dict（d1，**d2）

实际上是一种不好的合并词汇表的方法，因为关键字参数必须是字符串，因此如果您有一个

dict

，例如：

>>> d = {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
>>> d_letters = {0: 'a', 1: 'b', 2: 'c', 3: 'd', 4: 'e', 5: 'f', 6: 'g', 7: 'h', 8: 'i', 9: 'j', 10: 'k', 11: 'l', 12: 'm', 13: 'n', 14: 'o', 15: 'p', 16: 'q', 17: 'r', 18: 's', 19: 't', 20: 'u', 21: 'v', 22: 'w', 23: 'x', 24: 'y', 25: 'z', 26: 'A', 27: 'B', 28: 'C', 29: 'D', 30: 'E', 31: 'F', 32: 'G', 33: 'H', 34: 'I', 35: 'J', 36: 'K', 37: 'L', 38: 'M', 39: 'N', 40: 'O', 41: 'P', 42: 'Q', 43: 'R', 44: 'S', 45: 'T', 46: 'U', 47: 'V', 48: 'W', 49: 'X', 50: 'Y', 51: 'Z'}
>>> merge(d, d_letters)
{0: 'a', 1: 'b', 2: 'c', 3: 'd', 4: 'e', 5: 'f', 6: 'g', 7: 'h', 8: 'i', 9: 'j', 10: 'k', 11: 'l', 12: 'm', 13: 'n', 14: 'o', 15: 'p', 16: 'q', 17: 'r', 18: 's', 19: 't', 20: 'u', 21: 'v', 22: 'w', 23: 'x', 24: 'y', 25: 'z', 26: 'A', 27: 'B', 28: 'C', 29: 'D', 30: 'E', 31: 'F', 32: 'G', 33: 'H', 34: 'I', 35: 'J', 36: 'K', 37: 'L', 38: 'M', 39: 'N', 40: 'O', 41: 'P', 42: 'Q', 43: 'R', 44: 'S', 45: 'T', 46: 'U', 47: 'V', 48: 'W', 49: 'X', 50: 'Y', 51: 'Z'}
>>> merge(d_letters, d)
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 'f', 6: 'g', 7: 'h', 8: 'i', 9: 'j', 10: 'k', 11: 'l', 12: 'm', 13: 'n', 14: 'o', 15: 'p', 16: 'q', 17: 'r', 18: 's', 19: 't', 20: 'u', 21: 'v', 22: 'w', 23: 'x', 24: 'y', 25: 'z', 26: 'A', 27: 'B', 28: 'C', 29: 'D', 30: 'E', 31: 'F', 32: 'G', 33: 'H', 34: 'I', 35: 'J', 36: 'K', 37: 'L', 38: 'M', 39: 'N', 40: 'O', 41: 'P', 42: 'Q', 43: 'R', 44: 'S', 45: 'T', 46: 'U', 47: 'V', 48: 'W', 49: 'X', 50: 'Y', 51: 'Z'}
>>> merge(d)
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
>>> merge(d_letters)
{0: 'a', 1: 'b', 2: 'c', 3: 'd', 4: 'e', 5: 'f', 6: 'g', 7: 'h', 8: 'i', 9: 'j', 10: 'k', 11: 'l', 12: 'm', 13: 'n', 14: 'o', 15: 'p', 16: 'q', 17: 'r', 18: 's', 19: 't', 20: 'u', 21: 'v', 22: 'w', 23: 'x', 24: 'y', 25: 'z', 26: 'A', 27: 'B', 28: 'C', 29: 'D', 30: 'E', 31: 'F', 32: 'G', 33: 'H', 34: 'I', 35: 'J', 36: 'K', 37: 'L', 38: 'M', 39: 'N', 40: 'O', 41: 'P', 42: 'Q', 43: 'R', 44: 'S', 45: 'T', 46: 'U', 47: 'V', 48: 'W', 49: 'X', 50: 'Y', 51: 'Z'}
>>> merge()
{}

---

从Python 3.9开始，操作员使用两个字典中的合并键和值创建一个新字典：

{
  1: 'foo',
  2: 'bar'
}

这：

使用合并的键和值d2和d1创建一个新字典d3。当d2和d1共享密钥时，d1的值优先

---

另请注意

|=

运算符，该运算符通过将d1合并到中来修改d2，优先级为d1值：

# d1 = { 'a': 1, 'b': 2 }
# d2 = { 'b': 1, 'c': 3 }
d3 = d2 | d1
# d3: {'b': 2, 'c': 3, 'a': 1}

---




在这种情况下，如果找到了冲突的键，d1元素应该正确地获得优先级。如果您仍然需要它，只需复制一份即可。d3=d2.copy（）d3.update（d1），但我希望看到将d1+d2添加到该语言中。d1+d2是有问题的，因为一个字典在冲突期间必须具有优先级，并且不太清楚哪一个。d1+d2只有在Python获得多重映射的情况下才会实现，否则，对于8字节的键入增益来说，用户的歧义太令人困惑了。在本例中，字典中有对象：

isinstance（int，object）是真的

，但是

deepcopy

似乎没有必要。请注意，除非

d2

的所有键都是字符串，否则此技巧被视为滥用

**

关键字参数传递。如果不是

d2

的所有键都是字符串，那么在Python3.2中以及在Jython、IronPython和PyPy等Python的替代实现中，这将失败。例如，请参见。在Python 3.2中，示例的可能副本将失败（产生TypeError），在Jython、PyPy和IronPython的当前版本中：对于这些版本的Python，当使用

**

符号传递dict时，该dict的所有键都应为字符串。有关详细信息，请参阅从开始的python开发线程。@Mark:谢谢您的提醒。我对代码进行了编辑，使其与非CPython实现兼容。如果键是字符串和数字的元组，则会失败。例如d1={（1，'a'）：1，（1，'b'）：0，}d2={（1，'a'）：1，（2，'b'）：2，（2，'a'）：1，}关于解包语法，请参阅python 3.5中即将出现的更改。我想说

d=dict（**d1，**d2）

是有效的，但@IoannisFilippidis在其注释中引用了这一点。也许在这里包含代码片段会更清晰，就是这样。一个包含

.update

调用的简单循环（

merged={}

，然后在dict:merged.update（d））中为d添加

）会更短、更可读、更高效。或者如果您真的想使用
reduce
和
lambda
s，如何
返回reduce（lambda x，y:x.update（y）或x，dicts，{}）
？您可以在shell中尝试您的代码，看看它是否正确。我想做的是编写一个函数，它可以使用相同的功能接受不同数量的字典参数。最好不要在lambda下使用x.update（y），因为它总是返回None。我正在尝试编写一个更通用的函数merge_，它接受不同数量的dictionary参数，并使用提供的函数处理重复键。完成后，我将在另一个与解决方案更相关的线程中发布它。这里是我编写更通用解决方案的地方。欢迎光临。
{
  1: 'foo',
  2: 'bar'
}

# d1 = { 'a': 1, 'b': 2 }
# d2 = { 'b': 1, 'c': 3 }
d3 = d2 | d1
# d3: {'b': 2, 'c': 3, 'a': 1}

# d1 = { 'a': 1, 'b': 2 }
# d2 = { 'b': 1, 'c': 3 }
d2 |= d1
# d2: {'b': 2, 'c': 3, 'a': 1}