我有两个字典，我需要找到它们之间的差异，这应该给我一个键和一个值。
我搜索并找到了一些类似datadiff和dictdiff-master的插件/包，但是当我尝试在Python 2.7中导入它们时，它说没有定义这样的模块。
我在这里使用了一个集合：
first_dict = {}
second_dict = {}
value = set(second_dict) - set(first_dict)
print value
我的输出是：
>>> set(['SCD-3547', 'SCD-3456'])
我只得到键，但我也需要获取值。
我认为最好使用集合的对称差运算来实现这个功能。这里是文档链接。
>>> dict1 = {1:'donkey', 2:'chicken', 3:'dog'}
>>> dict2 = {1:'donkey', 2:'chimpansee', 4:'chicken'}
>>> set1 = set(dict1.items())
>>> set2 = set(dict2.items())
>>> set1 ^ set2
{(2, 'chimpansee'), (4, 'chicken'), (2, 'chicken'), (3, 'dog')}
它是对称的，因为：
>>> set2 ^ set1
{(2, 'chimpansee'), (4, 'chicken'), (2, 'chicken'), (3, 'dog')}
使用差异运算符时并非如此。
>>> set1 - set2
{(2, 'chicken'), (3, 'dog')}
>>> set2 - set1
{(2, 'chimpansee'), (4, 'chicken')}
然而，将结果集转换为字典可能不是一个好主意，因为您可能会丢失信息：
>>> dict(set1 ^ set2)
{2: 'chicken', 3: 'dog', 4: 'chicken'}
TypeError: unhashable type: 'dict'的错误提示是因为你的“顶层字典”中有一个值是另一个字典。这个提议的解决方案只适用于扁平的字典。 - josebamaset(...) 的解决方案都无法处理字典键或值中存在的不可哈希类型。 - Levko Ivanchuk尝试使用字典推导式来运行下面的代码段：
```python ```value = { k : second_dict[k] for k in set(second_dict) - set(first_dict) }
dict和set都是哈希表，我不明白为什么dict不能支持difference()方法，尤其是set可以支持。 - Rayvalue = { k : second_dict[k] for k, _ in set(second_dict.items()) - set(first_dict.items()) }使用dict.items()可以得到从键到值的元组，然后在集合差异中进行比较。因此，这将提供所有新的键以及更改的值。 - ascrookessecond_dict.keys() - first_dict.keys()。 - user3064538dictdiffer（https://github.com/inveniosoftware/dictdiffer）。import dictdiffer
a_dict = {
'a': 'foo',
'b': 'bar',
'd': 'barfoo'
}
b_dict = {
'a': 'foo',
'b': 'BAR',
'c': 'foobar'
}
for diff in list(dictdiffer.diff(a_dict, b_dict)):
print(diff)
('change', 'b', ('bar', 'BAR'))
('add', '', [('c', 'foobar')])
('remove', '', [('d', 'barfoo')])
你可以使用DeepDiff：
pip install deepdiff
除了其他功能外，它还使您可以递归计算字典、可迭代对象、字符串和其他对象的差异：
>>> from deepdiff import DeepDiff
>>> d1 = {1:1, 2:2, 3:3, "foo":4}
>>> d2 = {1:1, 2:4, 3:3, "bar":5, 6:6}
>>> DeepDiff(d1, d2)
{'dictionary_item_added': [root['bar'], root[6]],
'dictionary_item_removed': [root['foo']],
'values_changed': {'root[2]': {'new_value': 4, 'old_value': 2}}}
它让您看到了发生了什么更改（包括类型），添加了什么，移除了什么。 它还可以让您做很多其他事情，例如忽略重复项和忽略路径（由正则表达式定义）。
一个解决方案是使用 unittest 模块：
from unittest import TestCase
TestCase().assertDictEqual(expected_dict, actual_dict)
ValueError: no such test method in <class 'unittest.case.TestCase'>: runTest。 - Matt你考虑使用集合是正确的，我们只需要深入挖掘一下，就可以让你的方法生效。
首先，看一下示例代码：
test_1 = {"foo": "bar", "FOO": "BAR"}
test_2 = {"foo": "bar", "f00": "b@r"}
我们现在可以看到，这两个字典都包含一个相似的键/值对：
{"foo": "bar", ...}
每个字典还包含完全不同的键值对。但是我们如何检测差异？字典不支持该操作。相反，您需要使用集合。
以下是如何将每个字典转换为可用的集合：
set_1 = set(test_1.items())
set_2 = set(test_2.items())
这将返回一个包含一系列元组的集合。每个元组代表字典中的一个键值对。
现在，要找到set_1和set_2之间的差异：
print set_1 - set_2
>>> {('FOO', 'BAR')}
想要收回一个字典？很容易，只需：
dict(set_1 - set_2)
>>> {'FOO': 'BAR'}
(set 1 - set 2)之外，您还需要执行(set 2 - set 1)。否则，您将无法捕获所有差异，例如{("f00": "b@r")}，该输出中缺少此内容。 - PeJota我建议使用由优秀开发人员编写的已有代码，如pytest。它可以处理任何数据类型，不仅限于字典类型。顺便提一下，pytest在测试方面非常出色。
from _pytest.assertion.util import _compare_eq_any
print('\n'.join(_compare_eq_any({'a': 'b'}, {'aa': 'vv'}, verbose=3)))
输出结果为：
Left contains 1 more item:
{'a': 'b'}
Right contains 1 more item:
{'aa': 'vv'}
Full diff:
- {'aa': 'vv'}
? - ^^
+ {'a': 'b'}
? ^
如果您不喜欢使用以_开头的私有函数，只需查看源代码并将函数复制/粘贴到您的代码中。
P.S.：已测试通过pytest==6.2.4
def dict_diff(dict_a, dict_b, show_value_diff=True):
result = {}
result['added'] = {k: dict_b[k] for k in set(dict_b) - set(dict_a)}
result['removed'] = {k: dict_a[k] for k in set(dict_a) - set(dict_b)}
if show_value_diff:
common_keys = set(dict_a) & set(dict_b)
result['value_diffs'] = {
k:(dict_a[k], dict_b[k])
for k in common_keys
if dict_a[k] != dict_b[k]
}
return result
在其他答案中提到的使用对称差集运算符的函数，可以保留值的来源：
def diff_dicts(a, b, missing=KeyError):
"""
Find keys and values which differ from `a` to `b` as a dict.
If a value differs from `a` to `b` then the value in the returned dict will
be: `(a_value, b_value)`. If either is missing then the token from
`missing` will be used instead.
:param a: The from dict
:param b: The to dict
:param missing: A token used to indicate the dict did not include this key
:return: A dict of keys to tuples with the matching value from a and b
"""
return {
key: (a.get(key, missing), b.get(key, missing))
for key in dict(
set(a.items()) ^ set(b.items())
).keys()
}
print(diff_dicts({'a': 1, 'b': 1}, {'b': 2, 'c': 2}))
# {'c': (<class 'KeyError'>, 2), 'a': (1, <class 'KeyError'>), 'b': (1, 2)}
我们使用对称差集合操作符在获取项目的元组生成的两个字典中生成一组不同的 (key, value) 元组。
然后，我们从中创建一个新的字典来将键合并在一起，并对这些进行迭代。这些是从一个字典到另一个字典唯一发生了变化的键。
然后，我们使用这些键组成一个新的字典，每个字典的值都用我们的缺失标记替换键不存在的情况。
这个功能基于字典键提供所有差异（以及保持不变的内容）。它还突出了一些漂亮的字典推导、集合操作和 Python 3.6 类型注释 :)
from typing import Dict, Any, Tuple
def get_dict_diffs(a: Dict[str, Any], b: Dict[str, Any]) -> Tuple[Dict[str, Any], Dict[str, Any], Dict[str, Any], Dict[str, Any]]:
added_to_b_dict: Dict[str, Any] = {k: b[k] for k in set(b) - set(a)}
removed_from_a_dict: Dict[str, Any] = {k: a[k] for k in set(a) - set(b)}
common_dict_a: Dict[str, Any] = {k: a[k] for k in set(a) & set(b)}
common_dict_b: Dict[str, Any] = {k: b[k] for k in set(a) & set(b)}
return added_to_b_dict, removed_from_a_dict, common_dict_a, common_dict_b
values_in_b_not_a_dict = {k : b[k] for k, _ in set(b.items()) - set(a.items())}