Saya memiliki dua kamus, tetapi untuk penyederhanaan, saya akan mengambil dua ini:

>>> x = dict(a=1, b=2)
>>> y = dict(a=2, b=2)

Sekarang, saya ingin membandingkan apakah masing-masing key, valuepasangan xmemiliki nilai yang sesuai di y. Jadi saya menulis ini:

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

Dan itu berfungsi sejak a tupledikembalikan dan kemudian dibandingkan untuk kesetaraan.

Pertanyaan saya:

Apakah ini benar? Apakah ada cara yang lebih baik untuk melakukan ini? Lebih baik tidak dalam kecepatan, saya berbicara tentang keanggunan kode.

UPDATE: Saya lupa menyebutkan bahwa saya harus memeriksa berapa key, valuepasangan yang sama.

Jika Anda ingin tahu berapa banyak nilai yang cocok dengan kedua kamus, Anda harus mengatakan itu :)

Mungkin kira-kira seperti ini:

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

Yang ingin Anda lakukan hanyalah sederhana x==y

Apa yang Anda lakukan bukanlah ide yang baik, karena barang-barang dalam kamus tidak seharusnya dipesan. Anda mungkin membandingkan [('a',1),('b',1)]dengan[('b',1), ('a',1)] (kamus yang sama, urutan berbeda).

Sebagai contoh, lihat ini:

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

Perbedaannya hanya satu item, tetapi algoritma Anda akan melihat bahwa semua item berbeda

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

Dari python docs :

Untuk mengilustrasikan, contoh-contoh berikut semua mengembalikan kamus sama dengan {"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

Memberikan argumen kata kunci seperti pada contoh pertama hanya berfungsi untuk kunci yang merupakan pengidentifikasi Python yang valid. Kalau tidak, kunci apa pun yang valid dapat digunakan.

Berlaku untuk keduanya py2dan py3.

Saya baru mengenal python tapi akhirnya saya melakukan sesuatu yang mirip dengan @mouad

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

Operator XOR ( ^) harus menghilangkan semua elemen dict ketika keduanya sama di kedua dicts.

Karena sepertinya tidak ada yang disebutkan deepdiff, saya akan menambahkannya di sini untuk kelengkapan. Saya merasa sangat nyaman untuk mendapatkan objek yang berbeda (bersarang) secara umum:

Instalasi

pip install deepdiff

Kode sampel

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

Keluaran

{
    "values_changed": {
        "root['a']": {
            "new_value": 2,
            "old_value": 1
        },
        "root['nested']['b']": {
            "new_value": 2,
            "old_value": 1
        }
    }
}

Catatan tentang pencetakan cantik hasil untuk pemeriksaan: Kode di atas berfungsi jika kedua dikte memiliki kunci atribut yang sama (dengan nilai atribut yang mungkin berbeda seperti pada contoh). Namun, jika suatu "extra"atribut hadir adalah salah satu dicts, json.dumps()gagal dengan

TypeError: Object of type PrettyOrderedSet is not JSON serializable

Solusi: gunakan diff.to_json()dan json.loads()/ json.dumps()untuk mencetak-cantik:

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

Keluaran:

{
    "dictionary_item_removed": [
        "root['extra']"
    ],
    "values_changed": {
        "root['a']": {
            "new_value": 2,
            "old_value": 1
        },
        "root['nested']['b']": {
            "new_value": 2,
            "old_value": 1
        }
    }
}

Alternatif: gunakan pprint, menghasilkan pemformatan yang berbeda:

import pprint

# same code as above

pprint.pprint(diff, indent=4)

Keluaran:

{   'dictionary_item_removed': [root['extra']],
    'values_changed': {   "root['a']": {   'new_value': 2,
                                           'old_value': 1},
                          "root['nested']['b']": {   'new_value': 2,
                                                     'old_value': 1}}}

Cukup gunakan:

assert cmp(dict1, dict2) == 0

Jawaban @mouad bagus jika Anda menganggap bahwa kedua kamus hanya berisi nilai-nilai sederhana. Namun, jika Anda memiliki kamus yang berisi kamus Anda akan mendapatkan pengecualian karena kamus tidak dapat diacak.

Di atas kepala saya, sesuatu seperti ini mungkin bekerja:

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

Namun kemungkinan lain, hingga catatan terakhir OP, adalah untuk membandingkan hash ( SHAatau MD) dari dikte yang dibuang sebagai JSON. Cara hash dibangun menjamin bahwa jika mereka sama, string sumbernya juga sama. Ini sangat cepat dan suara secara matematis.

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

Fungsinya IMO baik, jelas dan intuitif. Tapi hanya untuk memberi Anda (yang lain) jawaban, ini dia:

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

Dapat bermanfaat bagi Anda atau orang lain ..

EDIT:

Saya telah membuat versi rekursif dari yang di atas .. Belum melihat jawaban yang lain

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)

Untuk menguji apakah dua dicts sama dalam kunci dan nilai:

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)

Jika Anda ingin mengembalikan nilai yang berbeda, tulis secara berbeda:

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

Anda harus menyebutnya dua kali yaitu

dict1_minus_d2(d1,d2).extend(dict1_minus_d2(d2,d1))

Kode

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

Uji

>>> a = {
    'number': 1,
    'list': ['one', 'two']
}
>>> b = {
    'list': ['two', 'one'],
    'number': 1
}
>>> equal(a, b)
True

Perbandingan sederhana dengan == sudah cukup saat ini (python 3.8). Bahkan ketika Anda membandingkan dict yang sama dalam urutan yang berbeda (contoh terakhir). Yang terbaik adalah, Anda tidak perlu paket pihak ketiga untuk mencapai ini.

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

Terlambat dalam respons saya lebih baik daripada tidak pernah!

Bandingkan Not_Equal lebih efisien daripada membandingkan Equal. Dengan demikian, dua dict tersebut tidak sama jika nilai kunci dalam satu dict tidak ditemukan di dict lainnya. Kode di bawah ini mempertimbangkan bahwa Anda mungkin membandingkan dict default dan karenanya menggunakan get bukannya getitem [].

Menggunakan semacam nilai acak sebagai default dalam panggilan panggil sama dengan kunci yang diambil - untuk jaga-jaga jika dicts memiliki nilai None sebagai dalam satu dict dan kunci tersebut tidak ada di yang lain. Juga kondisi get! = Diperiksa sebelum tidak dalam kondisi untuk efisiensi karena Anda melakukan pemeriksaan pada kunci dan nilai dari kedua sisi pada saat yang sama.

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)

Saya menggunakan solusi ini yang bekerja sempurna untuk saya di 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

Ini membandingkan dict, daftar, dan jenis lainnya yang mengimplementasikan operator "==" sendiri. Jika Anda perlu membandingkan sesuatu yang berbeda, Anda perlu menambahkan cabang baru di "if tree".

Semoga itu bisa membantu.

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

Ini pilihan lain:

>>> id(hash_1)
140640738806240
>>> id(hash_2)
140640738994848

Jadi seperti yang Anda lihat, kedua id berbeda. Tapi operator pembanding kaya sepertinya melakukan trik:

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

Di PyUnit ada metode yang membandingkan kamus dengan indah. Saya mengujinya menggunakan dua kamus berikut, dan ia melakukan apa yang Anda cari.

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

Saya tidak merekomendasikan mengimpor unittestke kode produksi Anda. Pikiran saya adalah sumber di PyUnit dapat digunakan kembali untuk berjalan dalam produksi. Ini menggunakan pprint"cetakan cantik" kamus. Tampaknya mudah untuk mengadaptasi kode ini menjadi "siap produksi".

lihat objek tampilan kamus: https://docs.python.org/2/library/stdtypes.html#dict

Dengan cara ini Anda dapat mengurangi dictView2 dari dictView1 dan itu akan mengembalikan satu set pasangan kunci / nilai yang berbeda di 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')])

Anda dapat memotong, menyatukan, perbedaan (ditampilkan di atas), perbedaan simetris objek tampilan kamus ini.
Lebih baik? Lebih cepat? - tidak yakin, tetapi bagian dari perpustakaan standar - yang membuatnya menjadi nilai tambah yang besar untuk portabilitas

Kode di bawah ini akan membantu Anda membandingkan daftar dict dengan 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

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

Dalam Python 3.6, Ini dapat dilakukan sebagai: -

if (len(dict_1)==len(dict_2): 
  for i in dict_1.items():
        ret=bool(i in dict_2.items())

variabel ret akan benar jika semua item dict_1 hadir di dict_2

Inilah jawaban saya, gunakan cara rekursif:

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)

Semoga itu bisa membantu!

Mengapa tidak hanya beralih melalui satu kamus dan memeriksa kamus lain dalam proses (dengan asumsi kedua kamus memiliki kunci yang sama)?

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

Keluaran:

Not 1 2
Ok 2 2

Cara termudah (dan salah satu yang lebih kuat pada saat itu) untuk melakukan perbandingan yang mendalam dari dua kamus adalah dengan membuat serial mereka dalam format JSON, mengurutkan kunci, dan membandingkan hasil string:

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