我有两本字典，但为了简化起见，我就选这两本:
>>> x = dict(a=1, b=2)
>>> y = dict(a=2, b=2)
现在，我想比较x中的每个键值对在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
它的工作原理是返回一个元组，然后比较是否相等。
我的问题:
这对吗?还有更好的办法吗?最好不是在速度上，我说的是代码优雅。
更新:我忘了提到，我必须检查有多少键，值对是相等的。
当前回答
迟回复总比不回复好!
比较Not_Equal比比较Equal更有效。因此，如果一个字典中的任何键值在另一个字典中找不到，那么两个字典就不相等。下面的代码考虑到您可能会比较默认的dict，因此使用get而不是getitem[]。
在get调用中使用一种随机值作为默认值，等于要检索的键-以防dicts在一个dict中有None作为值，而该键在另一个dict中不存在。此外，为了提高效率，get !=条件是在not in条件之前检查的，因为您同时对两边的键和值进行检查。
def Dicts_Not_Equal(first,second):
""" return True if both do not have same length or if any keys and values are not the same """
if len(first) == len(second):
for k in first:
if first.get(k) != second.get(k,k) or k not in second: return (True)
for k in second:
if first.get(k,k) != second.get(k) or k not in first: return (True)
return (False)
return (True)
其他回答
在Python 3.6中，可以这样做:-
if (len(dict_1)==len(dict_2):
for i in dict_1.items():
ret=bool(i in dict_2.items())
如果dict_1中的所有项都出现在dict_2中，Ret变量将为真
为什么不只是遍历一个字典，并在过程中检查另一个字典(假设两个字典都有相同的键)?
x = dict(a=1, b=2)
y = dict(a=2, b=2)
for key, val in x.items():
if val == y[key]:
print ('Ok', val, y[key])
else:
print ('Not', val, y[key])
输出:
Not 1 2
Ok 2 2
由于似乎没有人提到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
}
}
}
注意关于检查结果的漂亮打印:如果两个字典具有相同的属性键(可能与示例中的属性值不同)，上面的代码就可以工作。但是，如果存在一个“extra”属性是字典之一，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}}}
你要做的就是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))]
虽然只有一项不同，但你的算法会发现所有项都是不同的
Code
def equal(a, b):
type_a = type(a)
type_b = type(b)
if type_a != type_b:
return False
if isinstance(a, dict):
if len(a) != len(b):
return False
for key in a:
if key not in b:
return False
if not equal(a[key], b[key]):
return False
return True
elif isinstance(a, list):
if len(a) != len(b):
return False
while len(a):
x = a.pop()
index = indexof(x, b)
if index == -1:
return False
del b[index]
return True
else:
return a == b
def indexof(x, a):
for i in range(len(a)):
if equal(x, a[i]):
return i
return -1
Test
>>> a = {
'number': 1,
'list': ['one', 'two']
}
>>> b = {
'list': ['two', 'one'],
'number': 1
}
>>> equal(a, b)
True
