Python: ตรวจสอบว่าพจนานุกรมหนึ่งเป็นชุดย่อยของพจนานุกรมอื่นที่ใหญ่กว่าหรือไม่

ฉันกำลังพยายามเขียนวิธีการกรองแบบกำหนดเองที่ใช้จำนวนkwargsโดยพลการและส่งคืนรายการที่มีองค์ประกอบของรายการคล้ายฐานข้อมูลที่มีkwargsเหล่านั้น kwargs

ตัวอย่างเช่นสมมติว่าd1 = {'a':'2', 'b':'3'}และd2= สิ่งเดียวกัน d1 == d2ผลลัพธ์เป็น True แต่สมมติว่าd2= สิ่งเดียวกันบวกสิ่งอื่น ๆ อีกมากมาย วิธีการของฉันต้องสามารถบอกได้ว่าd1 ใน d2หรือไม่ แต่ Python ไม่สามารถทำได้ด้วยพจนานุกรม

บริบท:

ฉันได้เรียน Word และแต่ละวัตถุมีคุณสมบัติชอบword, definition, part_of_speechและอื่น ๆ Word.objects.filter(word='jump', part_of_speech='verb-intransitive')ฉันต้องการที่จะสามารถที่จะเรียกวิธีการกรองในรายการหลักของคำเหล่านี้เช่น ฉันไม่สามารถหาวิธีจัดการคีย์และค่าเหล่านี้ในเวลาเดียวกันได้ แต่อาจมีฟังก์ชันที่ใหญ่กว่านอกบริบทนี้สำหรับคนอื่น

แปลงเป็นคู่รายการและตรวจสอบการกักกัน

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

การเพิ่มประสิทธิภาพถูกปล่อยให้เป็นแบบฝึกหัดสำหรับผู้อ่าน

ใน Python 3 คุณสามารถใช้dict.items()เพื่อรับมุมมองที่เหมือนชุดของรายการ dict จากนั้นคุณสามารถใช้<=โอเปอเรเตอร์เพื่อทดสอบว่ามุมมองหนึ่งเป็น "ส่วนย่อย" ของอีกมุมมองหนึ่งหรือไม่:

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

ใน Python 2.7 ให้ใช้dict.viewitems()เพื่อทำสิ่งเดียวกัน:

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

ใน Python 2.6 และต่ำกว่าคุณจะต้องมีโซลูชันอื่นเช่นใช้all():

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

หมายเหตุสำหรับผู้ที่ต้องการสิ่งนี้สำหรับการทดสอบหน่วย: ยังมีassertDictContainsSubset()วิธีการในTestCaseคลาสของ Python

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

อย่างไรก็ตามมันเลิกใช้แล้วใน 3.2 ไม่แน่ใจว่าทำไมอาจมีการเปลี่ยนแทน

สำหรับคีย์และค่าตรวจสอบใช้: set(d1.items()).issubset(set(d2.items()))

หากคุณต้องการตรวจสอบเฉพาะคีย์: set(d1).issubset(set(d2))

เพื่อความสมบูรณ์คุณสามารถทำได้:

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

อย่างไรก็ตามฉันไม่อ้างสิทธิ์ใด ๆ เกี่ยวกับความเร็ว (หรือขาด) หรือความสามารถในการอ่าน (หรือขาด)

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

บริบท:

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

นี่คือวิธีแก้ปัญหาที่เรียกซ้ำในรายการและชุดที่มีอยู่ในพจนานุกรมอย่างถูกต้อง คุณยังสามารถใช้สิ่งนี้สำหรับรายการที่มีคำสั่ง ฯลฯ ...

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

ฟังก์ชั่นของฉันเพื่อจุดประสงค์เดียวกันโดยทำสิ่งนี้ซ้ำ ๆ :

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

ในตัวอย่างของคุณdictMatch(d1, d2)ควรคืนค่า True แม้ว่า d2 จะมีสิ่งอื่น ๆ อยู่ก็ตามนอกจากนี้ยังใช้กับระดับที่ต่ำกว่า:

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

dictMatch(d1, d2)   # True

หมายเหตุ: อาจมีวิธีแก้ปัญหาที่ดีกว่านี้ซึ่งจะหลีกเลี่ยงif type(pvalue) is dictประโยคและนำไปใช้กับกรณีที่กว้างขึ้น (เช่นรายการแฮชเป็นต้น) นอกจากนี้การเรียกซ้ำไม่ จำกัด ที่นี่ดังนั้นโปรดใช้ความเสี่ยงของคุณเอง ;)

ปัญหาที่ดูเหมือนตรงไปตรงมานี้ทำให้ฉันต้องใช้เวลาสองสามชั่วโมงในการค้นคว้าเพื่อหาวิธีแก้ปัญหาที่เชื่อถือได้ 100% ดังนั้นฉันจึงบันทึกสิ่งที่ฉันพบในคำตอบนี้

1. "Pythonic พันธมิตร" พูดsmall_dict <= big_dictจะเป็นวิธีที่ง่ายที่สุด แต่เลวร้ายเกินไปว่ามันจะไม่ทำงาน {'a': 1} < {'a': 1, 'b': 2}ดูเหมือนจะใช้งานได้ใน Python 2 แต่ไม่น่าเชื่อถือเนื่องจากเอกสารอย่างเป็นทางการเรียกมันออกมาอย่างชัดเจน ไปที่การค้นหา "ผลลัพธ์อื่นที่ไม่ใช่ความเท่าเทียมได้รับการแก้ไขอย่างสม่ำเสมอ แต่ไม่ได้กำหนดไว้เป็นอย่างอื่น" ในส่วนนี้ ไม่ต้องพูดถึงการเปรียบเทียบ 2 dicts ใน Python 3 ทำให้เกิดข้อยกเว้น TypeError

2. สิ่งที่สองที่มากที่สุดที่ใช้งานง่ายเป็นsmall.viewitems() <= big.viewitems()สำหรับ Python 2.7 เท่านั้นและsmall.items() <= big.items()สำหรับหลาม 3. แต่มีหนึ่งคำเตือน: มันเป็นที่อาจเกิดขึ้นรถ หากโปรแกรมของคุณสามารถใช้กับ Python <= 2.6 ได้แสดงว่าโปรแกรมของคุณd1.items() <= d2.items()กำลังเปรียบเทียบ 2 รายการของสิ่งที่เพิ่มขึ้นโดยไม่มีลำดับที่เฉพาะเจาะจงดังนั้นผลลัพธ์สุดท้ายจะไม่น่าเชื่อถือและกลายเป็นจุดบกพร่องที่น่ารังเกียจในโปรแกรมของคุณ ฉันไม่กระตือรือร้นที่จะเขียนการนำไปใช้งานอื่นสำหรับ Python <= 2.6 แต่ฉันยังไม่สบายใจที่โค้ดของฉันมาพร้อมกับข้อบกพร่องที่ทราบ (แม้ว่าจะอยู่บนแพลตฟอร์มที่ไม่รองรับก็ตาม) ดังนั้นฉันจึงละทิ้งแนวทางนี้

3. ฉันปักหลักกับคำตอบของ @blubberdiblub (เครดิตไปที่เขา):

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

   เป็นมูลค่าการชี้ให้เห็นว่าคำตอบนี้อาศัยอยู่กับ==พฤติกรรมระหว่าง dicts ซึ่งกำหนดไว้อย่างชัดเจนในเอกสารอย่างเป็นทางการจึงควรจะทำงานในทุกรุ่นหลาม ไปค้นหา:

   • "พจนานุกรมเปรียบเทียบค่าเท่ากันก็ต่อเมื่อมีคู่ (คีย์ค่า) เหมือนกัน" เป็นประโยคสุดท้ายในหน้านี้
   • "การแมป (อินสแตนซ์ของ dict) เปรียบเทียบค่าเท่ากันก็ต่อเมื่อมีคู่ (คีย์ค่า) เท่ากันการเปรียบเทียบคีย์และองค์ประกอบที่เท่าเทียมกันจะทำให้เกิดการสะท้อนกลับ" ในหน้านี้

นี่คือวิธีแก้ปัญหาแบบวนซ้ำทั่วไปสำหรับปัญหาที่ได้รับ:

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

หมายเหตุ: รหัสเดิมจะล้มเหลวในบางกรณีเครดิตสำหรับการแก้ไขจะไปที่@ olivier-melançon

หากคุณไม่ทราบใช้pydash มีis_matchมีที่ไม่ตรงที่:

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

ฉันรู้ว่าคำถามนี้เก่า แต่นี่คือทางออกของฉันในการตรวจสอบว่าพจนานุกรมที่ซ้อนกันเป็นส่วนหนึ่งของพจนานุกรมที่ซ้อนกันอื่นหรือไม่ การแก้ปัญหาเป็นแบบวนซ้ำ

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

ฟังก์ชันนี้ใช้ได้กับค่าที่ไม่สามารถแฮชได้ ฉันยังคิดว่ามันชัดเจนและง่ายต่อการอ่าน

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

การใช้งานแบบเรียกซ้ำสั้น ๆ ที่ใช้ได้กับพจนานุกรมที่ซ้อนกัน:

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

สิ่งนี้จะใช้คำสั่ง a และ b หากใครทราบวิธีที่ดีในการหลีกเลี่ยงโดยไม่ต้องใช้วิธีแก้ปัญหาซ้ำ ๆ บางส่วนเหมือนคำตอบอื่น ๆ โปรดบอกฉัน ฉันต้องการวิธีแยกคำสั่งออกเป็นส่วนหัวและส่วนหางตามคีย์

โค้ดนี้มีประโยชน์มากกว่าแบบฝึกหัดการเขียนโปรแกรมและอาจช้ากว่าโซลูชันอื่น ๆ ในที่นี้ซึ่งผสมผสานการเรียกซ้ำและการวนซ้ำ วิธีแก้ปัญหาของ @ Nutcrackerค่อนข้างดีสำหรับพจนานุกรมที่ซ้อนกัน

ใช้ออบเจ็กต์ Wrapper นี้ที่ให้การเปรียบเทียบบางส่วนและความแตกต่างที่ดี:

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