比较两个字典并检查有多少个 (键,值) 对相等
- 2025-01-10 08:46:00
- admin 原创
- 17
问题描述:
我有两本词典,但为了简单起见,我将选择这两本:
>>> x = dict(a=1, b=2)
>>> y = dict(a=2, b=2)
现在,我想比较key, value
中的每一对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
并且它可以起作用,因为tuple
返回了 a 然后进行比较是否相等。
我的问题:
这是正确的吗?有没有更好的方法?最好不是速度,而是代码的优雅性。
更新:我忘了说我必须检查有多少key, value
对是相等的。
解决方案 1:
如果你想知道两个字典中有多少个值匹配,你应该这么说:)
也许是这样的:
shared_items = {k: x[k] for k in x if k in y and x[k] == y[k]}
print(len(shared_items))
解决方案 2:
def 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)
解决方案 3:
dict1 == dict2
来自python文档:
以下示例均返回等于 的
字典{"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
像第一个示例一样提供关键字参数仅适用于有效的 Python 标识符键。否则,可以使用任何有效的键。
有效期为python2
和python3
。
解决方案 4:
你想要做的就是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))]
差异只有一个项目,但你的算法会发现所有项目都是不同的
解决方案 5:
由于似乎没人提到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()
and 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}}}
解决方案 6:
我是 python 新手,但我最终做了类似@mouad 的事情
unmatched_item = set(dict_1.items()) ^ set(dict_2.items())
len(unmatched_item) # should be 0
^
当两个字典中的元素相同时,XOR 运算符 ( ) 应该消除字典中的所有元素。
解决方案 7:
只需使用:
assert cmp(dict1, dict2) == 0
解决方案 8:
如果您假设两个字典都只包含简单值,那么 @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
解决方案 9:
在我看来,该功能很好,清晰直观。但只是为了给你(另一个)答案,以下是我的做法:
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), '
value B', dict2.get(x1))
print('-----
')
对您或其他任何人都有用。
编辑:
我已经创建了上面的递归版本..在其他答案中没有看到过
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)
解决方案 10:
对两个字典进行深度比较的最简单方法(也是最强大的方法之一)是将它们序列化为 JSON 格式,按键进行排序,然后比较字符串结果:
import json
if json.dumps(x, sort_keys=True) == json.dumps(y, sort_keys=True):
... Do something ...
解决方案 11:
另一种可能性,直到 OP 的最后一点,是比较转储为 JSON 的字典的哈希值(SHA
或MD
)。哈希值的构造方式保证如果它们相等,则源字符串也相等。这非常快并且从数学上讲是合理的。
import json
import hashlib
def hash_dict(d):
return hashlib.sha1(json.dumps(d, sort_keys=True)).hexdigest()
x = dict(a=1, b=2)
y = dict(a=2, b=2)
z = dict(a=1, b=2)
print(hash_dict(x) == hash_dict(y))
print(hash_dict(x) == hash_dict(z))
解决方案 12:
测试两个字典的键和值是否相等:
def dicts_equal(d1,d2):
""" return True if all keys and values are the same """
return all(k in d2 and d1[k] == d2[k]
for k in d1) \n and all(k in d1 and d1[k] == d2[k]
for k in d2)
如果要返回不同的值,请以不同的方式编写:
def dict1_minus_d2(d1, d2):
""" return the subset of d1 where the keys don't exist in d2 or
the values in d2 are different, as a dict """
return {k,v for k,v in d1.items() if k in d2 and v == d2[k]}
你必须调用它两次,即
dict1_minus_d2(d1,d2).extend(dict1_minus_d2(d2,d1))
解决方案 13:
代码
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
测试
>>> a = {
'number': 1,
'list': ['one', 'two']
}
>>> b = {
'list': ['two', 'one'],
'number': 1
}
>>> equal(a, b)
True
解决方案 14:
如今,使用 == 进行简单的比较就足够了(python 3.8)。即使您以不同的顺序比较相同的字典(最后一个例子)。最好的是,您不需要第三方包来实现这一点。
a = {'one': 'dog', 'two': 'cat', 'three': 'mouse'}
b = {'one': 'dog', 'two': 'cat', 'three': 'mouse'}
c = {'one': 'dog', 'two': 'cat', 'three': 'mouse'}
d = {'one': 'dog', 'two': 'cat', 'three': 'mouse', 'four': 'fish'}
e = {'one': 'cat', 'two': 'dog', 'three': 'mouse'}
f = {'one': 'dog', 'two': 'cat', 'three': 'mouse'}
g = {'two': 'cat', 'one': 'dog', 'three': 'mouse'}
h = {'one': 'dog', 'two': 'cat', 'three': 'mouse'}
print(a == b) # True
print(c == d) # False
print(e == f) # False
print(g == h) # True
解决方案 15:
我正在使用这个解决方案,它在 Python 3 中对我来说非常有效
import logging
log = logging.getLogger(__name__)
...
def deep_compare(self,left, right, level=0):
if type(left) != type(right):
log.info("Exit 1 - Different types")
return False
elif type(left) is dict:
# Dict comparison
for key in left:
if key not in right:
log.info("Exit 2 - missing {} in right".format(key))
return False
else:
if not deep_compare(left[str(key)], right[str(key)], level +1 ):
log.info("Exit 3 - different children")
return False
return True
elif type(left) is list:
# List comparison
for key in left:
if key not in right:
log.info("Exit 4 - missing {} in right".format(key))
return False
else:
if not deep_compare(left[left.index(key)], right[right.index(key)], level +1 ):
log.info("Exit 5 - different children")
return False
return True
else:
# Other comparison
return left == right
return False
它比较字典、列表和任何其他自行实现“==”运算符的类型。如果您需要比较其他不同的东西,则需要在“if 树”中添加一个新分支。
希望有所帮助。
解决方案 16:
对于python3:
data_set_a = dict_a.items()
data_set_b = dict_b.items()
difference_set = data_set_a ^ data_set_b
解决方案 17:
在 PyUnit 中,有一种方法可以很好地比较字典。我使用以下两个字典对其进行了测试,它完全符合您的要求。
d1 = {1: "value1",
2: [{"subKey1":"subValue1",
"subKey2":"subValue2"}]}
d2 = {1: "value1",
2: [{"subKey2":"subValue2",
"subKey1": "subValue1"}]
}
def assertDictEqual(self, d1, d2, msg=None):
self.assertIsInstance(d1, dict, 'First argument is not a dictionary')
self.assertIsInstance(d2, dict, 'Second argument is not a dictionary')
if d1 != d2:
standardMsg = '%s != %s' % (safe_repr(d1, True), safe_repr(d2, True))
diff = ('
' + '
'.join(difflib.ndiff(
pprint.pformat(d1).splitlines(),
pprint.pformat(d2).splitlines())))
standardMsg = self._truncateMessage(standardMsg, diff)
self.fail(self._formatMessage(msg, standardMsg))
我不建议将其导入unittest
到您的生产代码中。我的想法是 PyUnit 中的源代码可以重新调整以在生产中运行。它使用pprint
哪个“漂亮地打印”字典。似乎很容易将此代码调整为“可用于生产”。
解决方案 18:
迟点回复总比不回复要好!
比较 Not_Equal 比比较 Equal 更有效。因此,如果一个字典中的任何键值在另一个字典中未找到,则两个字典不相等。下面的代码考虑到您可能比较默认字典,因此使用 get 而不是getitem []。
在 get 调用中使用一种随机值作为默认值,该值等于要检索的键 - 以防万一,其中一个字典中的值为 None,而另一个字典中不存在该键。此外,为了提高效率,在 not in 条件之前会检查 get != 条件,因为您要同时检查两侧的键和值。
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)
解决方案 19:
为什么不只是遍历一本字典并在过程中检查另一本字典(假设两本字典都有相同的键)?
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
解决方案 20:
查看字典视图对象:
https ://docs.python.org/2/library/stdtypes.html#dict
这样,您可以从 dictView1 中减去 dictView2,它将返回一组在 dictView2 中不同的键/值对:
original = {'one':1,'two':2,'ACTION':'ADD'}
originalView=original.viewitems()
updatedDict = {'one':1,'two':2,'ACTION':'REPLACE'}
updatedDictView=updatedDict.viewitems()
delta=original | updatedDict
print delta
>>set([('ACTION', 'REPLACE')])
您可以对这些字典视图对象进行相交、并集、差集(如上所示)和对称差集。
更好?更快?——不确定,但它是标准库的一部分——这对可移植性来说是一个很大的优势
解决方案 21:
下面的代码将帮助你比较 Python 中的字典列表
def compate_generic_types(object1, object2):
if isinstance(object1, str) and isinstance(object2, str):
return object1 == object2
elif isinstance(object1, unicode) and isinstance(object2, unicode):
return object1 == object2
elif isinstance(object1, bool) and isinstance(object2, bool):
return object1 == object2
elif isinstance(object1, int) and isinstance(object2, int):
return object1 == object2
elif isinstance(object1, float) and isinstance(object2, float):
return object1 == object2
elif isinstance(object1, float) and isinstance(object2, int):
return object1 == float(object2)
elif isinstance(object1, int) and isinstance(object2, float):
return float(object1) == object2
return True
def deep_list_compare(object1, object2):
retval = True
count = len(object1)
object1 = sorted(object1)
object2 = sorted(object2)
for x in range(count):
if isinstance(object1[x], dict) and isinstance(object2[x], dict):
retval = deep_dict_compare(object1[x], object2[x])
if retval is False:
print "Unable to match [{0}] element in list".format(x)
return False
elif isinstance(object1[x], list) and isinstance(object2[x], list):
retval = deep_list_compare(object1[x], object2[x])
if retval is False:
print "Unable to match [{0}] element in list".format(x)
return False
else:
retval = compate_generic_types(object1[x], object2[x])
if retval is False:
print "Unable to match [{0}] element in list".format(x)
return False
return retval
def deep_dict_compare(object1, object2):
retval = True
if len(object1) != len(object2):
return False
for k in object1.iterkeys():
obj1 = object1[k]
obj2 = object2[k]
if isinstance(obj1, list) and isinstance(obj2, list):
retval = deep_list_compare(obj1, obj2)
if retval is False:
print "Unable to match [{0}]".format(k)
return False
elif isinstance(obj1, dict) and isinstance(obj2, dict):
retval = deep_dict_compare(obj1, obj2)
if retval is False:
print "Unable to match [{0}]".format(k)
return False
else:
retval = compate_generic_types(obj1, obj2)
if retval is False:
print "Unable to match [{0}]".format(k)
return False
return retval
解决方案 22:
这是我的答案,使用递归方式:
def dict_equals(da, db):
if not isinstance(da, dict) or not isinstance(db, dict):
return False
if len(da) != len(db):
return False
for da_key in da:
if da_key not in db:
return False
if not isinstance(db[da_key], type(da[da_key])):
return False
if isinstance(da[da_key], dict):
res = dict_equals(da[da_key], db[da_key])
if res is False:
return False
elif da[da_key] != db[da_key]:
return False
return True
a = {1:{2:3, 'name': 'cc', "dd": {3:4, 21:"nm"}}}
b = {1:{2:3, 'name': 'cc', "dd": {3:4, 21:"nm"}}}
print dict_equals(a, b)
希望有帮助!
解决方案 23:
>>> x = {'a':1,'b':2,'c':3}
>>> x
{'a': 1, 'b': 2, 'c': 3}
>>> y = {'a':2,'b':4,'c':3}
>>> y
{'a': 2, 'b': 4, 'c': 3}
METHOD 1:
>>> common_item = x.items()&y.items() #using union,x.item()
>>> common_item
{('c', 3)}
METHOD 2:
>>> for i in x.items():
if i in y.items():
print('true')
else:
print('false')
false
false
true
解决方案 24:
>>> hash_1
{'a': 'foo', 'b': 'bar'}
>>> hash_2
{'a': 'foo', 'b': 'bar'}
>>> set_1 = set (hash_1.iteritems())
>>> set_1
set([('a', 'foo'), ('b', 'bar')])
>>> set_2 = set (hash_2.iteritems())
>>> set_2
set([('a', 'foo'), ('b', 'bar')])
>>> len (set_1.difference(set_2))
0
>>> if (len(set_1.difference(set_2)) | len(set_2.difference(set_1))) == False:
... print "The two hashes match."
...
The two hashes match.
>>> hash_2['c'] = 'baz'
>>> hash_2
{'a': 'foo', 'c': 'baz', 'b': 'bar'}
>>> if (len(set_1.difference(set_2)) | len(set_2.difference(set_1))) == False:
... print "The two hashes match."
...
>>>
>>> hash_2.pop('c')
'baz'
这是另一个选择:
>>> id(hash_1)
140640738806240
>>> id(hash_2)
140640738994848
因此,如您所见,这两个 ID 是不同的。但丰富的比较运算符似乎可以解决问题:
>>> hash_1 == hash_2
True
>>>
>>> hash_2
{'a': 'foo', 'b': 'bar'}
>>> set_2 = set (hash_2.iteritems())
>>> if (len(set_1.difference(set_2)) | len(set_2.difference(set_1))) == False:
... print "The two hashes match."
...
The two hashes match.
>>>
解决方案 25:
在 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 变量将为 true
解决方案 26:
您可以通过以下方式编写自己的函数来找到答案。
class Solution:
def find_if_dict_equal(self,dict1,dict2):
dict1_keys=list(dict1.keys())
dict2_keys=list(dict2.keys())
if len(dict1_keys)!=len(dict2_keys):
return False
for i in dict1_keys:
if i not in dict2 or dict2[i]!=dict1[i]:
return False
return True
def findAnagrams(self, s, p):
if len(s)<len(p):
return []
p_dict={}
for i in p:
if i not in p_dict:
p_dict[i]=0
p_dict[i]+=1
s_dict={}
final_list=[]
for i in s[:len(p)]:
if i not in s_dict:
s_dict[i]=0
s_dict[i]+=1
if self.find_if_dict_equal(s_dict,p_dict):
final_list.append(0)
for i in range(len(p),len(s)):
element_to_add=s[i]
element_to_remove=s[i-len(p)]
if element_to_add not in s_dict:
s_dict[element_to_add]=0
s_dict[element_to_add]+=1
s_dict[element_to_remove]-=1
if s_dict[element_to_remove]==0:
del s_dict[element_to_remove]
if self.find_if_dict_equal(s_dict,p_dict):
final_list.append(i-len(p)+1)
return final_list
解决方案 27:
我有一个默认/模板字典,我想从第二个给定字典更新其值。因此,更新将发生在默认字典中存在的键上,并且相关值与默认键/值类型兼容。
在某种程度上,这与上面的问题类似。
我写了这个解决方案:
代码
def compDict(gDict, dDict):
gDictKeys = list(gDict.keys())
for gDictKey in gDictKeys:
try:
dDict[gDictKey]
except KeyError:
# Do the operation you wanted to do for "key not present in dict".
print(f'
key \'{gDictKey}\' does not exist! Dictionary key/value no set !!!
')
else:
# check on type
if type(gDict[gDictKey]) == type(dDict[gDictKey]):
if type(dDict[gDictKey])==dict:
compDict(gDict[gDictKey],dDict[gDictKey])
else:
dDict[gDictKey] = gDict[gDictKey]
print('
',dDict, 'update successful !!!
')
else:
print(f'
Value \'{gDict[gDictKey]}\' for \'{gDictKey}\' not a compatible data type !!!
')
# default dictionary
dDict = {'A':str(),
'B':{'Ba':int(),'Bb':float()},
'C':list(),
}
# given dictionary
gDict = {'A':1234, 'a':'addio', 'C':['HELLO'], 'B':{'Ba':3,'Bb':'wrong'}}
compDict(gDict, dDict)
print('Updated default dictionry: ',dDict)
输出
‘A’ 的值‘1234’不是兼容的数据类型!!!
键 'a' 不存在!字典键/值未设置 !!!
{'A': '', 'B': {'Ba': 0, 'Bb': 0.0}, 'C': ['HELLO']} 更新成功!!!
{'Ba': 3, 'Bb': 0.0} 更新成功!!!
‘Bb’ 的值‘错误’,不是兼容的数据类型!!!
更新默认词典:{'A': '', 'B': {'Ba': 3, 'Bb': 0.0}, 'C': ['HELLO']}
解决方案 28:
代码:
dict1 = {"a": 1, "b": 2}
dict2 = {"a": 2, "b": 2}
for key, value1 in dict1.items():
value2 = dict2[key]
if value1 == value2:
print('Values match:', value1, value2)
else:
print('Values do not match:', value1, value2)
输出:
Values do not match: 1 2
Values match: 2 2
这里,通过迭代键并检查相应键的值来比较和dict1
。dict2
解决方案 29:
import json
if json.dumps(dict1) == json.dumps(dict2):
print("Equal")
- 2024年20款好用的项目管理软件推荐,项目管理提效的20个工具和技巧
- 2024年开源项目管理软件有哪些?推荐5款好用的项目管理工具
- 2024年常用的项目管理软件有哪些?推荐这10款国内外好用的项目管理工具
- 项目管理软件有哪些?推荐7款超好用的项目管理工具
- 项目管理软件有哪些最好用?推荐6款好用的项目管理工具
- 项目管理软件哪个最好用?盘点推荐5款好用的项目管理工具
- 项目管理软件有哪些,盘点推荐国内外超好用的7款项目管理工具
- 项目管理软件排行榜:2024年项目经理必备5款开源项目管理软件汇总
- 2024项目管理软件排行榜(10类常用的项目管理工具全推荐)
- 项目管理必备:盘点2024年13款好用的项目管理软件