我有两个字典，但为了简化问题，我将仅使用这两个：
>>> x = dict(a=1, b=2)
>>> y = dict(a=2, b=2)
现在，我想比较 x 中的每一个 key, value 对是否有与之对应的相同的值在 y 中。所以我写了这个：
>>> for x_values, y_values in zip(x.iteritems(), y.iteritems()):
if x_values == y_values:
print 'Ok', x_values, y_values
else:
print 'Not', x_values, y_values
这有效，因为它返回一个元组，然后进行相等比较。
我的问题：
这是正确的吗？有没有更好的方法？我指的是代码的优雅程度，而不是速度上的优化。
更新：我忘记提到我需要检查有多少个键、值对是相等的。
shared_items = {k: x[k] for k in x if k in y and x[k] == y[k]}
print(len(shared_items))
x = {[1,2]: 2} 将失败。该问题已经有有效的“dicts”。 - AnnanFayx = dict(23\;dfg&^*$^%$^$%^)，然后抱怨字典的比较不起作用一样。当然它不会工作。另一方面，Tim的评论涉及可变的“值”，因此我说这些是不同的问题。 - AnnanFayset(x.keys()) 和 set(x.values())。但如果字典嵌套层数大于1，你需要递归地执行相同操作。 - MikeyEset 要求值必须是可哈希的，而 dict 要求键必须是可哈希的。set(x.keys()) 总是有效的，因为键必须是可哈希的，但是对于不可哈希的值，set(x.values()) 将会失败。 - Tim Tisdalldef dict_compare(d1, d2):
d1_keys = set(d1.keys())
d2_keys = set(d2.keys())
shared_keys = d1_keys.intersection(d2_keys)
added = d1_keys - d2_keys
removed = d2_keys - d1_keys
modified = {o : (d1[o], d2[o]) for o in shared_keys if d1[o] != d2[o]}
same = set(o for o in shared_keys if d1[o] == d2[o])
return added, removed, modified, same
x = dict(a=1, b=2)
y = dict(a=2, b=2)
added, removed, modified, same = dict_compare(x, y)
你想做的是简单地使用x==y
你所做的并不是一个好主意，因为字典中的项目不应该有任何顺序。你可能会将[('a',1),('b',1)]与[('b',1), ('a',1)]（同一字典，不同顺序）进行比较。
例如，请参见以下示例：
>>> x = dict(a=2, b=2,c=3, d=4)
>>> x
{'a': 2, 'c': 3, 'b': 2, 'd': 4}
>>> y = dict(b=2,c=3, d=4)
>>> y
{'c': 3, 'b': 2, 'd': 4}
>>> zip(x.iteritems(), y.iteritems())
[(('a', 2), ('c', 3)), (('c', 3), ('b', 2)), (('b', 2), ('d', 4))]
这两者之间的区别只有一项，但你的算法会认为所有的项都不同。
In [7]: y = {"key": 1}
In [8]: x == y
Out[8]: True您有什么看法？ - luca.giovagnolidic1 == dic2来自 Python文档：
在第一个示例中，仅使用关键字参数适用于有效的 Python 标识符作为键。否则，可以使用任何有效的键。The following examples all return a dictionary equal to
{"one": 1, "two": 2, "three": 3}:>>> a = dict(one=1, two=2, three=3) >>> b = {'one': 1, 'two': 2, 'three': 3} >>> c = dict(zip(['one', 'two', 'three'], [1, 2, 3])) >>> d = dict([('two', 2), ('one', 1), ('three', 3)]) >>> e = dict({'three': 3, 'one': 1, 'two': 2}) >>> a == b == c == d == e True
由于似乎没有人提到 deepdiff，我将其添加到这里以便完整性。我发现它非常方便，可用于获取（嵌套）对象的差异：
pip install deepdiff
import deepdiff
import json
dict_1 = {
"a": 1,
"nested": {
"b": 1,
}
}
dict_2 = {
"a": 2,
"nested": {
"b": 2,
}
}
diff = deepdiff.DeepDiff(dict_1, dict_2)
print(json.dumps(diff, indent=4))
{
"values_changed": {
"root['a']": {
"new_value": 2,
"old_value": 1
},
"root['nested']['b']": {
"new_value": 2,
"old_value": 1
}
}
}
json.dumps()会失败。TypeError: Object of type PrettyOrderedSet is not JSON serializable
解决方案：使用diff.to_json()和json.loads() / json.dumps()进行漂亮打印：
import deepdiff
import json
dict_1 = {
"a": 1,
"nested": {
"b": 1,
},
"extra": 3
}
dict_2 = {
"a": 2,
"nested": {
"b": 2,
}
}
diff = deepdiff.DeepDiff(dict_1, dict_2)
print(json.dumps(json.loads(diff.to_json()), indent=4))
输出：
{
"dictionary_item_removed": [
"root['extra']"
],
"values_changed": {
"root['a']": {
"new_value": 2,
"old_value": 1
},
"root['nested']['b']": {
"new_value": 2,
"old_value": 1
}
}
}
另一种选择：使用pprint，可以得到不同的格式：
import pprint
# same code as above
pprint.pprint(diff, indent=4)
输出：
{ 'dictionary_item_removed': [root['extra']],
'values_changed': { "root['a']": { 'new_value': 2,
'old_value': 1},
"root['nested']['b']": { 'new_value': 2,
'old_value': 1}}}
我刚开始学习Python，但最终做了与@mouad类似的事情。
unmatched_item = set(dict_1.items()) ^ set(dict_2.items())
len(unmatched_item) # should be 0
XOR运算符（^）应该在两个字典中的元素相同时清除所有相同的元素。
{'a':{'b':1}} 会产生 TypeError: unhashable type: 'dict' 错误提示。 - Tim Tisdall只需使用：
assert cmp(dict1, dict2) == 0
dict1 == dict2 是相同的。 - Trey Hunnercmp 已被删除（应视为早已删除）。他们提出的替代方案是：(a > b) - (a < b) == cmp(a, b)，以获得等效的功能（或更好的 __eq__ 和 __hash__）。 - nerdwallerunorderable types: dict() < dict()。请注意，字典的大小比较只适用于 Python 3.7 版本以上的字典，且仅限于相等性测试（即 == 或 !=）。 - Stefano@mouad的答案很好，但是只适用于包含简单值的字典。然而，如果你有包含字典的字典，你会得到一个异常，因为字典不可哈希。
我能想到的一种方法是：
def compare_dictionaries(dict1, dict2):
if dict1 is None or dict2 is None:
print('Nones')
return False
if (not isinstance(dict1, dict)) or (not isinstance(dict2, dict)):
print('Not dict')
return False
shared_keys = set(dict1.keys()) & set(dict2.keys())
if not ( len(shared_keys) == len(dict1.keys()) and len(shared_keys) == len(dict2.keys())):
print('Not all keys are shared')
return False
dicts_are_equal = True
for key in dict1.keys():
if isinstance(dict1[key], dict) or isinstance(dict2[key], dict):
dicts_are_equal = dicts_are_equal and compare_dictionaries(dict1[key], dict2[key])
else:
dicts_are_equal = dicts_are_equal and all(atleast_1d(dict1[key] == dict2[key]))
return dicts_are_equal
not isinstance(dict1, dict)而不是type(dict1) is not dict，这将适用于基于dict的其他类。此外，您可以使用all(atleast_1d(dict1[key] == dict2[key]))而不是(dict1[key] == dict2[key])来处理至少包含一个数组。 - EL_DONdicts_are_equal变为false，您可以立即退出for loop。没有必要继续进行下去。 - pfabri- thiezndict1 = {"a": {"a": {"a": "b"}}} dict1 == dict2 True dict1 = {"a": {"a": {"a": "a"}}} dict1 == dict2 False```
我认为这个函数很好，清晰易懂。但是为了给你提供（另一个）答案，这是我的意见：
def compare_dict(dict1, dict2):
for x1 in dict1.keys():
z = dict1.get(x1) == dict2.get(x1)
if not z:
print('key', x1)
print('value A', dict1.get(x1), '\nvalue B', dict2.get(x1))
print('-----\n')
这对你或其他人可能有用..
编辑:
我已经创建了一个递归版本，没有在其他答案中看到过。
def compare_dict(a, b):
# Compared two dictionaries..
# Posts things that are not equal..
res_compare = []
for k in set(list(a.keys()) + list(b.keys())):
if isinstance(a[k], dict):
z0 = compare_dict(a[k], b[k])
else:
z0 = a[k] == b[k]
z0_bool = np.all(z0)
res_compare.append(z0_bool)
if not z0_bool:
print(k, a[k], b[k])
return np.all(res_compare)
import json
if json.dumps(x, sort_keys=True) == json.dumps(y, sort_keys=True):
... Do something ...
x == y应该为真：“字典只有在它们具有相同的（键，值）对（无论顺序如何）时才相等。顺序比较（‘<’，‘<=’，‘>=’，‘>’）会引发TypeError错误。” - MestreLion