Python: Periksa apakah satu kamus adalah bagian dari kamus lain yang lebih besar

Saya mencoba untuk menulis metode filter kustom yang mengambil sejumlah kwarg dan mengembalikan daftar yang berisi elemen dari daftar mirip database yang berisi kwarg tersebut .

Misalnya, d1 = {'a':'2', 'b':'3'}and d2= hal yang sama. d1 == d2menghasilkan True. Tapi misalkan d2= hal yang sama ditambah banyak hal lainnya. Metode saya harus dapat mengetahui apakah d1 dalam d2 , tetapi Python tidak dapat melakukannya dengan kamus.

Konteks:

Aku punya kelas Word, dan setiap objek memiliki sifat seperti word, definition, part_of_speech, dan sebagainya. Saya ingin dapat memanggil metode filter pada daftar utama kata-kata ini, seperti Word.objects.filter(word='jump', part_of_speech='verb-intransitive'). Saya tidak tahu cara mengelola kunci dan nilai ini secara bersamaan. Tetapi ini bisa memiliki fungsi yang lebih besar di luar konteks ini untuk orang lain.

Ubah menjadi pasangan item dan periksa penahanan.

all(item in superset.items() for item in subset.items())

Optimasi dibiarkan sebagai latihan bagi pembaca.

Di Python 3, Anda bisa menggunakan dict.items()untuk mendapatkan tampilan set-like dari item dict. Anda kemudian dapat menggunakan <=operator untuk menguji apakah satu tampilan adalah "subset" dari yang lain:

d1.items() <= d2.items()

Di Python 2.7, gunakan dict.viewitems()untuk melakukan hal yang sama:

d1.viewitems() <= d2.viewitems()

Di Python 2.6 dan di bawahnya Anda akan membutuhkan solusi yang berbeda, seperti menggunakan all():

all(key in d2 and d2[key] == d1[key] for key in d1)

Catatan untuk orang yang membutuhkan ini untuk pengujian unit: ada juga assertDictContainsSubset()metode di TestCasekelas Python .

http://docs.python.org/2/library/unittest.html?highlight=assertdictcontainssubset#unittest.TestCase.assertDictContainsSubset

Namun itu sudah usang di 3.2, tidak yakin mengapa, mungkin ada penggantinya.

untuk kunci dan nilai, gunakan cek: set(d1.items()).issubset(set(d2.items()))

jika Anda hanya perlu memeriksa kunci: set(d1).issubset(set(d2))

Untuk kelengkapan, Anda juga bisa melakukan ini:

def is_subdict(small, big):
    return dict(big, **small) == big

Namun, saya tidak membuat klaim apa pun tentang kecepatan (atau ketiadaan) atau keterbacaan (atau ketiadaan).

>>> d1 = {'a':'2', 'b':'3'}
>>> d2 = {'a':'2', 'b':'3','c':'4'}
>>> all((k in d2 and d2[k]==v) for k,v in d1.iteritems())
True

konteks:

>>> d1 = {'a':'2', 'b':'3'}
>>> d2 = {'a':'2', 'b':'3','c':'4'}
>>> list(d1.iteritems())
[('a', '2'), ('b', '3')]
>>> [(k,v) for k,v in d1.iteritems()]
[('a', '2'), ('b', '3')]
>>> k,v = ('a','2')
>>> k
'a'
>>> v
'2'
>>> k in d2
True
>>> d2[k]
'2'
>>> k in d2 and d2[k]==v
True
>>> [(k in d2 and d2[k]==v) for k,v in d1.iteritems()]
[True, True]
>>> ((k in d2 and d2[k]==v) for k,v in d1.iteritems())
<generator object <genexpr> at 0x02A9D2B0>
>>> ((k in d2 and d2[k]==v) for k,v in d1.iteritems()).next()
True
>>> all((k in d2 and d2[k]==v) for k,v in d1.iteritems())
True
>>>

Fungsi saya untuk tujuan yang sama, melakukan ini secara rekursif:

def dictMatch(patn, real):
    """does real dict match pattern?"""
    try:
        for pkey, pvalue in patn.iteritems():
            if type(pvalue) is dict:
                result = dictMatch(pvalue, real[pkey])
                assert result
            else:
                assert real[pkey] == pvalue
                result = True
    except (AssertionError, KeyError):
        result = False
    return result

Dalam contoh Anda, dictMatch(d1, d2)harus mengembalikan True meskipun d2 memiliki hal lain di dalamnya, ditambah itu berlaku juga untuk tingkat yang lebih rendah:

d1 = {'a':'2', 'b':{3: 'iii'}}
d2 = {'a':'2', 'b':{3: 'iii', 4: 'iv'},'c':'4'}

dictMatch(d1, d2)   # True

Catatan: Mungkin ada solusi yang lebih baik yang menghindari if type(pvalue) is dictklausa dan berlaku untuk kasus yang lebih luas (seperti daftar hash dll). Juga rekursi tidak terbatas di sini jadi gunakan dengan resiko Anda sendiri. ;)

Berikut adalah solusi yang juga berulang dengan benar ke dalam daftar dan set yang terdapat dalam kamus. Anda juga dapat menggunakan ini untuk daftar yang berisi penis dll ...

def is_subset(subset, superset):
    if isinstance(subset, dict):
        return all(key in superset and is_subset(val, superset[key]) for key, val in subset.items())

    if isinstance(subset, list) or isinstance(subset, set):
        return all(any(is_subset(subitem, superitem) for superitem in superset) for subitem in subset)

    # assume that subset is a plain value if none of the above match
    return subset == superset

Masalah yang tampaknya langsung ini membuat saya menghabiskan beberapa jam dalam penelitian untuk menemukan solusi yang 100% andal, jadi saya mendokumentasikan apa yang saya temukan dalam jawaban ini.

1. Berbicara "Pythonic-ally", small_dict <= big_dictakan menjadi cara yang paling intuitif, tapi sayang sekali itu tidak akan berhasil . {'a': 1} < {'a': 1, 'b': 2}tampaknya berfungsi dengan Python 2, tetapi tidak dapat diandalkan karena dokumentasi resmi secara eksplisit menyebutkannya. Lakukan pencarian "Hasil selain kesetaraan diselesaikan secara konsisten, tetapi tidak ditentukan sebaliknya." di bagian ini . Belum lagi, membandingkan 2 dicts dengan Python 3 menghasilkan pengecualian TypeError.

2. Hal kedua yang paling intuitif adalah small.viewitems() <= big.viewitems()untuk Python 2.7 saja, dan small.items() <= big.items()untuk Python 3. Tapi ada satu peringatan: ini berpotensi buggy . Jika program Anda berpotensi digunakan pada Python <= 2.6, d1.items() <= d2.items()ini sebenarnya membandingkan 2 daftar tupel, tanpa urutan tertentu, sehingga hasil akhirnya tidak dapat diandalkan dan menjadi bug yang tidak menyenangkan dalam program Anda. Saya tidak tertarik untuk menulis implementasi lain untuk Python <= 2.6, tetapi saya masih merasa tidak nyaman bahwa kode saya dilengkapi dengan bug yang diketahui (bahkan jika itu pada platform yang tidak didukung). Jadi saya meninggalkan pendekatan ini.

3. Saya tenang dengan jawaban @blubberdiblub (Penghargaan diberikan kepadanya):

   def is_subdict(small, big): return dict(big, **small) == big

   Perlu ditunjukkan bahwa, jawaban ini bergantung pada ==perilaku antar dicts, yang didefinisikan dengan jelas dalam dokumen resmi, oleh karena itu harus berfungsi di setiap versi Python . Pergi cari:

   • "Kamus membandingkan sama jika dan hanya jika mereka memiliki pasangan (kunci, nilai) yang sama." adalah kalimat terakhir di halaman ini
   • "Pemetaan (contoh dikt) dibandingkan jika dan hanya jika mereka memiliki pasangan (kunci, nilai) yang sama. Perbandingan persamaan dari kunci dan elemen memaksakan refleksivitas." di halaman ini

Berikut solusi rekursif umum untuk masalah yang diberikan:

import traceback
import unittest

def is_subset(superset, subset):
    for key, value in subset.items():
        if key not in superset:
            return False

        if isinstance(value, dict):
            if not is_subset(superset[key], value):
                return False

        elif isinstance(value, str):
            if value not in superset[key]:
                return False

        elif isinstance(value, list):
            if not set(value) <= set(superset[key]):
                return False
        elif isinstance(value, set):
            if not value <= superset[key]:
                return False

        else:
            if not value == superset[key]:
                return False

    return True


class Foo(unittest.TestCase):

    def setUp(self):
        self.dct = {
            'a': 'hello world',
            'b': 12345,
            'c': 1.2345,
            'd': [1, 2, 3, 4, 5],
            'e': {1, 2, 3, 4, 5},
            'f': {
                'a': 'hello world',
                'b': 12345,
                'c': 1.2345,
                'd': [1, 2, 3, 4, 5],
                'e': {1, 2, 3, 4, 5},
                'g': False,
                'h': None
            },
            'g': False,
            'h': None,
            'question': 'mcve',
            'metadata': {}
        }

    def tearDown(self):
        pass

    def check_true(self, superset, subset):
        return self.assertEqual(is_subset(superset, subset), True)

    def check_false(self, superset, subset):
        return self.assertEqual(is_subset(superset, subset), False)

    def test_simple_cases(self):
        self.check_true(self.dct, {'a': 'hello world'})
        self.check_true(self.dct, {'b': 12345})
        self.check_true(self.dct, {'c': 1.2345})
        self.check_true(self.dct, {'d': [1, 2, 3, 4, 5]})
        self.check_true(self.dct, {'e': {1, 2, 3, 4, 5}})
        self.check_true(self.dct, {'f': {
            'a': 'hello world',
            'b': 12345,
            'c': 1.2345,
            'd': [1, 2, 3, 4, 5],
            'e': {1, 2, 3, 4, 5},
        }})
        self.check_true(self.dct, {'g': False})
        self.check_true(self.dct, {'h': None})

    def test_tricky_cases(self):
        self.check_true(self.dct, {'a': 'hello'})
        self.check_true(self.dct, {'d': [1, 2, 3]})
        self.check_true(self.dct, {'e': {3, 4}})
        self.check_true(self.dct, {'f': {
            'a': 'hello world',
            'h': None
        }})
        self.check_false(
            self.dct, {'question': 'mcve', 'metadata': {'author': 'BPL'}})
        self.check_true(
            self.dct, {'question': 'mcve', 'metadata': {}})
        self.check_false(
            self.dct, {'question1': 'mcve', 'metadata': {}})

if __name__ == "__main__":
    unittest.main()

CATATAN: Kode asli akan gagal dalam kasus tertentu, kredit untuk perbaikan diberikan ke @ olivier-melançon

Jika Anda tidak keberatan menggunakan pydash ada is_matchada yang tidak tepat:

import pydash

a = {1:2, 3:4, 5:{6:7}}
b = {3:4.0, 5:{6:8}}
c = {3:4.0, 5:{6:7}}

pydash.predicates.is_match(a, b) # False
pydash.predicates.is_match(a, c) # True

Saya tahu pertanyaan ini sudah tua, tetapi inilah solusi saya untuk memeriksa apakah satu kamus bersarang adalah bagian dari kamus bersarang lainnya. Solusinya rekursif.

def compare_dicts(a, b):
    for key, value in a.items():
        if key in b:
            if isinstance(a[key], dict):
                if not compare_dicts(a[key], b[key]):
                    return False
            elif value != b[key]:
                return False
        else:
            return False
    return True

Fungsi ini berfungsi untuk nilai yang tidak dapat dicirikan. Saya juga menganggapnya jelas dan mudah dibaca.

def isSubDict(subDict,dictionary):
    for key in subDict.keys():
        if (not key in dictionary) or (not subDict[key] == dictionary[key]):
            return False
    return True

In [126]: isSubDict({1:2},{3:4})
Out[126]: False

In [127]: isSubDict({1:2},{1:2,3:4})
Out[127]: True

In [128]: isSubDict({1:{2:3}},{1:{2:3},3:4})
Out[128]: True

In [129]: isSubDict({1:{2:3}},{1:{2:4},3:4})
Out[129]: False

Implementasi rekursif singkat yang berfungsi untuk kamus bersarang:

def compare_dicts(a,b):
    if not a: return True
    if isinstance(a, dict):
        key, val = a.popitem()
        return isinstance(b, dict) and key in b and compare_dicts(val, b.pop(key)) and compare_dicts(a, b)
    return a == b

Ini akan memakan penis a dan b. Jika ada yang tahu cara yang baik untuk menghindarinya tanpa menggunakan solusi berulang sebagian seperti dalam jawaban lain, tolong beri tahu saya. Saya akan membutuhkan cara untuk membagi dikt menjadi kepala dan ekor berdasarkan kunci.

Kode ini lebih berguna sebagai latihan pemrograman, dan mungkin jauh lebih lambat daripada solusi lain di sini yang menggabungkan rekursi dan iterasi. Solusi @ Nutcrer cukup bagus untuk kamus bersarang.

Gunakan objek pembungkus ini yang memberikan perbandingan parsial dan perbedaan yang bagus:

class DictMatch(dict):
    """ Partial match of a dictionary to another one """
    def __eq__(self, other: dict):
        assert isinstance(other, dict)
        return all(other[name] == value for name, value in self.items())

actual_name = {'praenomen': 'Gaius', 'nomen': 'Julius', 'cognomen': 'Caesar'}
expected_name = DictMatch({'praenomen': 'Gaius'})  # partial match
assert expected_name == actual_name  # True