두 사전 비교 및 동일한 (키, 값) 쌍 수 확인

두 사전 비교 및 동일한 (키, 값) 쌍 수 확인

사전을 두 개 가지고 있습니다만, 간단하게 하기 위해 다음 두 개를 가지고 오겠습니다.

>>> 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반환된 후 동등성을 비교합니다.

질문:

이거 맞는건가요?더 좋은 방법이 있을까요?속도가 아니라 코드 엘레강스(code elaughthe code elegance.

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

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.

아무도 언급하지 않은 것 같기 때문에, 여기에 덧붙여 완성합니다.일반적으로 (네스트된) 오브젝트를 다른 오브젝트로 바꾸는데 매우 편리합니다.

인스톨

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"입니다.dict는 dict의 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 ')^)는의 dict 「dict」, 「dict」의 각 , 합니다.

사용방법:

assert cmp(dict1, dict2) == 0

양쪽 딕셔너리에 단순한 값만 포함되어 있다고 가정하면 @syslogad의 답변이 좋습니다.그러나 사전을 포함하는 사전이 있으면 사전이 해시 가능하지 않으므로 예외가 발생합니다.

즉석에서 다음과 같은 것이 효과가 있을 수 있습니다.

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의 )를 하는 방법도.SHA ★★★★★★★★★★★★★★★★★」MDJSON(JSON)을 참조해 주세요.해시 방식은 동일한 경우 소스 문자열도 같음을 보증합니다.이것은 매우 빠르고 수학적으로 건전합니다.

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)

키와 값이 동일한지 테스트하려면:

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

2개의 사전을 상세하게 비교하는 가장 쉬운 방법(그리고 그 중에서 가장 견고한 방법 중 하나)은 JSON 형식으로 시리얼화하여 키를 정렬하고 문자열 결과를 비교하는 것입니다.

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

답장이 늦는 것이 안하는 것보다 나아요!

Compare Not_Equal이 Equal 비교보다 효율적입니다.따라서 하나의 dict에 있는 키 값이 다른 dict에 없는 경우 두 dict는 동일하지 않습니다.다음 코드는 기본 dict를 비교하고 getitem [] 대신 get을 사용하는 것을 고려합니다.

취득하는 키와 같은 get 콜에서 랜덤한 값을 기본값으로 사용하는 경우(dicts의 1개의 dict에 None 값이 있고 그 키가 다른 쪽 dict에 존재하지 않는 경우).또한, 양쪽에서 동시에 키와 값을 체크하기 때문에 효율의 조건이 아닌 경우보다 먼저 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" 트리에 새 분기를 추가해야 합니다.

도움이 됐으면 좋겠다.

python3의 경우:

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

difference_set = data_set_a ^ data_set_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

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

Import는 권장하지 않습니다.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')])

이러한 사전 보기 개체는 교차, 결합, 차이(위 그림 참조), 대칭 차이 등을 수행할 수 있습니다.
나아요?고속화 - 확실하지는 않지만 표준 라이브러리의 일부이므로 휴대성에 큰 도움이 됩니다.

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

보시는 것처럼 두 아이디는 다릅니다.그러나 풍부한 비교 연산자는 다음과 같은 트릭을 사용하는 것 같습니다.

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

다음은 재귀화 방법을 사용하는 답입니다.

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)

도움이 됐으면 좋겠네요!

아래 코드는 python의 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())

ret 변수는 dict_2에 존재하는 dict_1의 모든 항목이 true가 됩니다.

다음과 같이 자신의 기능을 적으면 알 수 있습니다.

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

두 번째 지정된 사전에서 값을 업데이트하려는 기본/템플릿 사전이 있습니다.따라서 업데이트는 기본 딕셔너리에 있는 키와 관련 값이 기본 키/값 유형과 호환되는 경우 수행됩니다.

어쩐지 이것은 위의 질문과 비슷합니다.

저는 다음과 같은 해결책을 썼습니다.

코드

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'\nkey \'{gDictKey}\' does not exist! Dictionary key/value no set !!!\n')
        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('\n',dDict, 'update successful !!!\n')
            else:
               print(f'\nValue \'{gDict[gDictKey]}\' for \'{gDictKey}\' not a compatible data type !!!\n')
            

# 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']}

import json

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

언급URL : https://stackoverflow.com/questions/4527942/comparing-two-dictionaries-and-checking-how-many-key-value-pairs-are-equal