Bagaimana cara membandingkan dua objek JSON dengan elemen yang sama dalam urutan berbeda yang sama?

Bagaimana saya dapat menguji apakah dua objek JSON sama dengan python, mengabaikan urutan daftar?

Sebagai contoh ...

JSON dokumen a :

{
    "errors": [
        {"error": "invalid", "field": "email"},
        {"error": "required", "field": "name"}
    ],
    "success": false
}

Dokumen JSON b :

{
    "success": false,
    "errors": [
        {"error": "required", "field": "name"},
        {"error": "invalid", "field": "email"}
    ]
}

adan bharus membandingkan sama, meskipun urutan "errors"daftarnya berbeda.

Jika Anda menginginkan dua objek dengan elemen yang sama tetapi dalam urutan berbeda untuk membandingkan sama, maka hal yang harus dilakukan adalah membandingkan salinan yang diurutkan dari mereka - misalnya, untuk kamus yang diwakili oleh string JSON Anda adan b:

import json

a = json.loads("""
{
    "errors": [
        {"error": "invalid", "field": "email"},
        {"error": "required", "field": "name"}
    ],
    "success": false
}
""")

b = json.loads("""
{
    "success": false,
    "errors": [
        {"error": "required", "field": "name"},
        {"error": "invalid", "field": "email"}
    ]
}
""")

>>> sorted(a.items()) == sorted(b.items())
False

... tetapi itu tidak berhasil, karena dalam setiap kasus, "errors"item dari dict level teratas adalah daftar dengan elemen yang sama dalam urutan berbeda, dan sorted()tidak mencoba untuk mengurutkan apa pun kecuali level "teratas" dari sebuah iterable.

Untuk memperbaikinya, kita dapat mendefinisikan sebuah orderedfungsi yang secara rekursif akan mengurutkan daftar apa pun yang ditemukannya (dan mengonversi kamus menjadi daftar (key, value)pasangan sehingga dapat diurutkan):

def ordered(obj):
    if isinstance(obj, dict):
        return sorted((k, ordered(v)) for k, v in obj.items())
    if isinstance(obj, list):
        return sorted(ordered(x) for x in obj)
    else:
        return obj

Jika kita menerapkan fungsi ini ke adan b, hasilnya sebanding:

>>> ordered(a) == ordered(b)
True

Cara lain bisa menggunakan json.dumps(X, sort_keys=True)opsi:

import json
a, b = json.dumps(a, sort_keys=True), json.dumps(b, sort_keys=True)
a == b # a normal string comparison

Ini berfungsi untuk kamus dan daftar bertingkat.

Pecahkan kodenya dan bandingkan sebagai komentar mgilson.

Urutan tidak menjadi masalah bagi kamus selama kunci, dan nilainya cocok. (Kamus tidak memiliki urutan dengan Python)

>>> {'a': 1, 'b': 2} == {'b': 2, 'a': 1}
True

Tetapi urutan penting dalam daftar; penyortiran akan menyelesaikan masalah untuk daftar.

>>> [1, 2] == [2, 1]
False
>>> [1, 2] == sorted([2, 1])
True

>>> a = '{"errors": [{"error": "invalid", "field": "email"}, {"error": "required", "field": "name"}], "success": false}'
>>> b = '{"errors": [{"error": "required", "field": "name"}, {"error": "invalid", "field": "email"}], "success": false}'
>>> a, b = json.loads(a), json.loads(b)
>>> a['errors'].sort()
>>> b['errors'].sort()
>>> a == b
True

Contoh di atas akan berfungsi untuk JSON dalam pertanyaan. Untuk solusi umum, lihat jawaban Zero Piraeus.

Untuk dua dicts berikut 'dictWithListsInValue' dan 'reorderedDictWithReorderedListsInValue' yang merupakan versi yang disusun ulang satu sama lain

dictObj = {"foo": "bar", "john": "doe"}
reorderedDictObj = {"john": "doe", "foo": "bar"}
dictObj2 = {"abc": "def"}
dictWithListsInValue = {'A': [{'X': [dictObj2, dictObj]}, {'Y': 2}], 'B': dictObj2}
reorderedDictWithReorderedListsInValue = {'B': dictObj2, 'A': [{'Y': 2}, {'X': [reorderedDictObj, dictObj2]}]}
a = {"L": "M", "N": dictWithListsInValue}
b = {"L": "M", "N": reorderedDictWithReorderedListsInValue}

print(sorted(a.items()) == sorted(b.items()))  # gives false

memberi saya hasil yang salah yaitu salah.

Jadi saya membuat ObjectComparator cutstom saya sendiri seperti ini:

def my_list_cmp(list1, list2):
    if (list1.__len__() != list2.__len__()):
        return False

    for l in list1:
        found = False
        for m in list2:
            res = my_obj_cmp(l, m)
            if (res):
                found = True
                break

        if (not found):
            return False

    return True


def my_obj_cmp(obj1, obj2):
    if isinstance(obj1, list):
        if (not isinstance(obj2, list)):
            return False
        return my_list_cmp(obj1, obj2)
    elif (isinstance(obj1, dict)):
        if (not isinstance(obj2, dict)):
            return False
        exp = set(obj2.keys()) == set(obj1.keys())
        if (not exp):
            # print(obj1.keys(), obj2.keys())
            return False
        for k in obj1.keys():
            val1 = obj1.get(k)
            val2 = obj2.get(k)
            if isinstance(val1, list):
                if (not my_list_cmp(val1, val2)):
                    return False
            elif isinstance(val1, dict):
                if (not my_obj_cmp(val1, val2)):
                    return False
            else:
                if val2 != val1:
                    return False
    else:
        return obj1 == obj2

    return True


dictObj = {"foo": "bar", "john": "doe"}
reorderedDictObj = {"john": "doe", "foo": "bar"}
dictObj2 = {"abc": "def"}
dictWithListsInValue = {'A': [{'X': [dictObj2, dictObj]}, {'Y': 2}], 'B': dictObj2}
reorderedDictWithReorderedListsInValue = {'B': dictObj2, 'A': [{'Y': 2}, {'X': [reorderedDictObj, dictObj2]}]}
a = {"L": "M", "N": dictWithListsInValue}
b = {"L": "M", "N": reorderedDictWithReorderedListsInValue}

print(my_obj_cmp(a, b))  # gives true

yang memberi saya hasil yang diharapkan benar!

Logikanya cukup sederhana:

Jika objek bertipe 'list' maka bandingkan setiap item dari list pertama dengan item dari list kedua hingga ditemukan, dan jika item tersebut tidak ditemukan setelah melalui list kedua, maka 'found' akan menjadi = false. nilai 'ditemukan' dikembalikan

Lain jika objek yang akan dibandingkan adalah tipe 'dict' kemudian bandingkan nilai-nilai yang ada untuk semua kunci masing-masing di kedua objek. (Perbandingan rekursif dilakukan)

Lain cukup panggil obj1 == obj2. Ini secara default berfungsi dengan baik untuk objek string dan angka dan untuk eq () itu didefinisikan dengan tepat.

(Perhatikan bahwa algoritme selanjutnya dapat ditingkatkan dengan menghapus item yang ditemukan di objek2, sehingga item objek1 berikutnya tidak akan membandingkan dirinya sendiri dengan item yang sudah ditemukan di objek2)

Anda dapat menulis fungsi sama dengan Anda sendiri:

• dicts sama jika: 1) semua kunci sama, 2) semua nilai sama
• daftar sama jika: semua item sama dan dalam urutan yang sama
• primitif sama jika a == b

Karena Anda sedang berhadapan dengan json, Anda akan memiliki jenis python standar: dict, list, dll, sehingga Anda dapat melakukan pengecekan jenis hard if type(obj) == 'dict':, dll

Contoh kasar (tidak diuji):

def json_equals(jsonA, jsonB):
    if type(jsonA) != type(jsonB):
        # not equal
        return False
    if type(jsonA) == dict:
        if len(jsonA) != len(jsonB):
            return False
        for keyA in jsonA:
            if keyA not in jsonB or not json_equal(jsonA[keyA], jsonB[keyA]):
                return False
    elif type(jsonA) == list:
        if len(jsonA) != len(jsonB):
            return False
        for itemA, itemB in zip(jsonA, jsonB):
            if not json_equal(itemA, itemB):
                return False
    else:
        return jsonA == jsonB

Bagi orang lain yang ingin men-debug dua objek JSON (biasanya, ada referensi dan target ), berikut adalah solusi yang dapat Anda gunakan. Ini akan mencantumkan " jalur " yang berbeda / tidak cocok dari target ke referensi.

level opsi digunakan untuk memilih seberapa dalam Anda ingin melihat.

show_variables opsi dapat diaktifkan untuk menunjukkan variabel yang relevan.

def compareJson(example_json, target_json, level=-1, show_variables=False):
  _different_variables = _parseJSON(example_json, target_json, level=level, show_variables=show_variables)
  return len(_different_variables) == 0, _different_variables

def _parseJSON(reference, target, path=[], level=-1, show_variables=False):  
  if level > 0 and len(path) == level:
    return []
  
  _different_variables = list()
  # the case that the inputs is a dict (i.e. json dict)  
  if isinstance(reference, dict):
    for _key in reference:      
      _path = path+[_key]
      try:
        _different_variables += _parseJSON(reference[_key], target[_key], _path, level, show_variables)
      except KeyError:
        _record = ''.join(['[%s]'%str(p) for p in _path])
        if show_variables:
          _record += ': %s <--> MISSING!!'%str(reference[_key])
        _different_variables.append(_record)
  # the case that the inputs is a list/tuple
  elif isinstance(reference, list) or isinstance(reference, tuple):
    for index, v in enumerate(reference):
      _path = path+[index]
      try:
        _target_v = target[index]
        _different_variables += _parseJSON(v, _target_v, _path, level, show_variables)
      except IndexError:
        _record = ''.join(['[%s]'%str(p) for p in _path])
        if show_variables:
          _record += ': %s <--> MISSING!!'%str(v)
        _different_variables.append(_record)
  # the actual comparison about the value, if they are not the same, record it
  elif reference != target:
    _record = ''.join(['[%s]'%str(p) for p in path])
    if show_variables:
      _record += ': %s <--> %s'%(str(reference), str(target))
    _different_variables.append(_record)

  return _different_variables