나는 두 개의 사전을 가지고 있지만 단순화를 위해 다음 두 가지를 취할 것입니다.

>>> 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

그리고 a tuple가 반환 된 후 작동 하고 평등을 비교합니다.

내 질문 :

이 올바른지? 거기에 더 나은 이 작업을 수행하는 방법은? 속도가 빠를수록 코드 우아함에 대해 이야기하고 있습니다.

업데이트 : 나는 얼마나 많은 key, value쌍이 같은지 확인해야한다는 것을 잊어 버렸습니다 .

두 사전에서 몇 개의 값이 일치하는지 알고 싶다면 다음과 같이 말해야합니다. :)

아마도 이런 식으로 뭔가 :

shared_items = {k: x[k] for k in x if k in y and x[k] == y[k]}
print len(shared_items)

당신이하고 싶은 것은 단순히 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))]

차이점은 하나의 항목이지만 알고리즘 에 따라 모든 항목이 다릅니다.

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)

dic1 == dic2

에서 파이썬 문서 :

설명하기 위해 다음의 예는 모두 사전 반환 동일을 하기 {"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 식별자 인 키에 대해서만 작동합니다. 그렇지 않으면 유효한 키를 사용할 수 있습니다.

py2및 모두에 유효합니다 py3.

나는 파이썬을 처음 사용하지만 @mouad와 비슷한 것을했습니다.

unmatched_item = set(dict_1.items()) ^ set(dict_2.items())
len(unmatched_item) # should be 0

XOR 연산자 ( ^)는 dict의 두 요소가 동일 할 때 dict의 모든 요소를 ​​제거해야합니다.

아무도 언급하지 않은 것 같으 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
        }
    }
}

검사 결과를 예쁘게 인쇄하는 것에 대한 참고 사항 : 위의 코드는 두 dicts에 동일한 속성 키가있는 경우 (예 에서와는 다른 속성 값으로 가능) 작동합니다. 는 IF 그러나, "extra"속성의 존재는 하나의 dicts 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
        }
    }
}

대안 : use를 사용 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}}}

그냥 사용하십시오 :

assert cmp(dict1, dict2) == 0

@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

OP의 마지막 메모까지 또 다른 가능성 은 JSON으로 덤프 된 dict 의 해시 ( 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))

이 기능은 깨끗하고 직관적 인 훌륭한 IMO입니다. 그러나 당신에게 (또 다른) 대답을하기 위해, 여기에 나의 길이 있습니다 :

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)

키와 값에서 두 개의 dicts가 같은지 테스트하려면 다음을 수행하십시오.

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) \
        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))

암호

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

요즘 ==과의 간단한 비교로 충분합니다 (파이썬 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

응답이 늦는 것이 결코 낫지 않습니다!

Not_Equal 비교는 Equal을 비교하는 것보다 효율적입니다. 따라서 한 dict의 키 값이 다른 dict에서 발견되지 않으면 두 dict는 동일하지 않습니다. 아래 코드는 기본 dict을 비교할 수 있으므로 getitem [] 대신 get을 사용한다는 것을 고려합니다 .

하나의 dict에 dicts에 None as 값이 있고 해당 키가 다른 dict에 존재하지 않는 경우를 위해 get call에서 기본값으로 임의의 값을 사용하여 검색되는 키와 동일합니다. 또한 키와 값을 동시에 양쪽에서 확인하기 때문에 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)

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

dict, list 및 "=="연산자를 직접 구현하는 다른 유형을 비교합니다. 다른 것을 비교해야하는 경우 "if tree"에 새 분기를 추가해야합니다.

희망이 도움이됩니다.

python3의 경우 :

data_set_a = dict_a.items()
data_set_b = dict_b.items()

difference_set = data_set_a ^ data_set_b

>>> 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.
>>>

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 = ('\n' + '\n'.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하는 "꽤 인쇄"사전을. 이 코드를 "제작 준비"가되도록 쉽게 적용 할 수 있습니다.

사전보기 객체를 참조하십시오 : 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')])

이러한 사전 뷰 객체를 교차, 합집합, 차이 (위 그림 참조), 대칭 적 차이로 교차 할 수 있습니다.
보다 나은? 빨리? -확실하지는 않지만 표준 라이브러리의 일부-이식성을 크게 향상시킵니다.

아래 코드는 파이썬에서 dict 목록을 비교하는 데 도움이됩니다.

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

>>> 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

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입니다.

내 대답은 다음과 같습니다.

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)

희망이 도움이됩니다!

한 사전을 반복하고 프로세스에서 다른 사전을 확인하는 것이 어떻습니까 (두 사전에 동일한 키가 있다고 가정)?

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

두 사전을 심도있게 비교할 수있는 가장 쉬운 방법 (및 그 중에서 가장 강력한 방법 중 하나)을 JSON 형식으로 직렬화하고 키를 정렬하고 문자열 결과를 비교하는 것입니다.

import json
if json.dumps(x, sort_keys=True) == json.dumps(y, sort_keys=True):
   ... Do something ...

import json

if json.dumps(dict1) == json.dumps(dict2):
    print("Equal")