Python: Kiểm tra xem một từ điển có phải là một tập hợp con của một từ điển lớn hơn khác không

Tôi đang cố gắng viết một phương pháp lọc tùy chỉnh lấy một số lượng kwargs tùy ý và trả về một danh sách chứa các phần tử của danh sách giống cơ sở dữ liệu có chứa các kwargs đó .

Ví dụ, giả sử d1 = {'a':'2', 'b':'3'}và d2= giống nhau. d1 == d2kết quả là True. Nhưng giả sử d2= cùng một thứ cộng với một loạt thứ khác. Phương thức của tôi cần phải biết liệu d1 có trong d2 hay không , nhưng Python không thể làm điều đó với từ điển.

Bối cảnh:

Tôi có một lớp Word, và mỗi đối tượng có tính chất giống như word, definition, part_of_speech, và vân vân. Tôi muốn có thể gọi một phương thức lọc trên danh sách chính của những từ này, như Word.objects.filter(word='jump', part_of_speech='verb-intransitive'). Tôi không thể tìm ra cách quản lý các khóa và giá trị này cùng một lúc. Nhưng điều này có thể có chức năng lớn hơn bên ngoài ngữ cảnh này cho những người khác.

Chuyển đổi thành các cặp mục và kiểm tra sự ngăn chặn.

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

Tối ưu hóa còn lại như một bài tập cho người đọc.

Trong Python 3, bạn có thể sử dụng dict.items()để có được dạng xem giống như tập hợp của các mục dict. Sau đó, bạn có thể sử dụng <=toán tử để kiểm tra xem một chế độ xem có phải là "tập hợp con" của chế độ xem kia:

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

Trong Python 2.7, sử dụng dict.viewitems()để làm tương tự:

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

Trong Python 2.6 trở xuống, bạn sẽ cần một giải pháp khác, chẳng hạn như sử dụng all():

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

Lưu ý cho những người cần điều này để kiểm tra đơn vị: cũng có một assertDictContainsSubset()phương thức trong TestCaselớp của Python .

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

Tuy nhiên, nó không được dùng nữa trong 3.2, không rõ tại sao, có thể có một sự thay thế cho nó.

để kiểm tra khóa và giá trị sử dụng: set(d1.items()).issubset(set(d2.items()))

nếu bạn chỉ cần kiểm tra các khóa: set(d1).issubset(set(d2))

Để hoàn thiện, bạn cũng có thể làm điều này:

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

Tuy nhiên, tôi không đưa ra bất kỳ tuyên bố nào liên quan đến tốc độ (hoặc thiếu) hoặc khả năng đọc (hoặc thiếu).

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

bối cảnh:

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

Hàm của tôi cho cùng mục đích, thực hiện điều này một cách đệ quy:

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

Trong ví dụ của bạn, dictMatch(d1, d2)nên trả về True ngay cả khi d2 có nội dung khác trong đó, cộng với nó cũng áp dụng cho các cấp thấp hơn:

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

dictMatch(d1, d2)   # True

Lưu ý: Có thể còn có giải pháp tốt hơn để tránh if type(pvalue) is dictmệnh đề và áp dụng cho nhiều trường hợp hơn nữa (như danh sách các hàm băm, v.v.). Ngoài ra đệ quy không bị giới hạn ở đây vì vậy hãy tự chịu rủi ro khi sử dụng. ;)

Đây là một giải pháp cũng có thể đệ quy đúng cách thành các danh sách và tập hợp có trong từ điển. Bạn cũng có thể sử dụng điều này cho các danh sách có chứa số, v.v.

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

Vấn đề có vẻ đơn giản này khiến tôi mất vài giờ nghiên cứu để tìm ra giải pháp đáng tin cậy 100%, vì vậy tôi đã ghi lại những gì tôi tìm thấy trong câu trả lời này.

1. Nói "Pythonic-ally", small_dict <= big_dictsẽ là cách trực quan nhất, nhưng quá tệ là nó sẽ không hoạt động . {'a': 1} < {'a': 1, 'b': 2}dường như hoạt động trong Python 2, nhưng nó không đáng tin cậy vì tài liệu chính thức gọi nó một cách rõ ràng. Tìm kiếm "Các kết quả khác với bình đẳng được giải quyết nhất quán, nhưng không được định nghĩa khác." trong phần này . Chưa kể, việc so sánh 2 phái trong Python 3 dẫn đến ngoại lệ TypeError.

2. Điều trực quan thứ hai small.viewitems() <= big.viewitems()chỉ dành cho Python 2.7 và small.items() <= big.items()Python 3. Nhưng có một cảnh báo: nó có khả năng bị lỗi . Nếu chương trình của bạn có khả năng được sử dụng trên Python <= 2.6, chương trình của bạn d1.items() <= d2.items()thực sự đang so sánh 2 danh sách các bộ dữ liệu, không có thứ tự cụ thể, vì vậy kết quả cuối cùng sẽ không đáng tin cậy và nó trở thành một lỗi khó chịu trong chương trình của bạn. Tôi không muốn viết thêm một triển khai khác cho Python <= 2.6, nhưng tôi vẫn không cảm thấy thoải mái khi mã của mình có một lỗi đã biết (ngay cả khi nó nằm trên nền tảng không được hỗ trợ). Vì vậy, tôi từ bỏ cách tiếp cận này.

3. Tôi ổn định với câu trả lời của @blubberdiblub (Tín dụng thuộc về anh ấy):

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

   Cần chỉ ra rằng, câu trả lời này dựa trên ==hành vi giữa các phần, được xác định rõ ràng trong tài liệu chính thức, do đó sẽ hoạt động trong mọi phiên bản Python . Đi tìm kiếm:

   • "Các từ điển so sánh bằng nhau nếu và chỉ khi chúng có các cặp (khóa, giá trị) giống nhau." là câu cuối cùng trong trang này
   • "Các ánh xạ (trường hợp của dict) so sánh bằng nhau nếu và chỉ khi chúng có các cặp (khóa, giá trị) bằng nhau. So sánh ngang bằng giữa các khóa và phần tử thực thi tính phản xạ." trong trang này

Đây là một giải pháp đệ quy chung cho vấn đề đã cho:

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

LƯU Ý: Mã gốc sẽ không thành công trong một số trường hợp nhất định, tín dụng cho việc sửa chữa sẽ được chuyển đến @ olivier-melançon

Nếu bạn không phiền khi sử dụng pydash thì is_matchcó nó sẽ thực hiện chính xác điều đó:

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

Tôi biết câu hỏi này đã cũ, nhưng đây là giải pháp của tôi để kiểm tra xem một từ điển lồng nhau có phải là một phần của từ điển lồng nhau khác hay không. Giải pháp là đệ quy.

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

Hàm này hoạt động đối với các giá trị không thể băm. Tôi cũng nghĩ rằng nó rõ ràng và dễ đọc.

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

Một triển khai đệ quy ngắn hoạt động cho các từ điển lồng nhau:

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

Điều này sẽ tiêu thụ các đường a và b. Nếu ai biết cách hay để tránh điều đó mà không cần dùng đến các giải pháp lặp lại một phần như trong các câu trả lời khác, vui lòng cho tôi biết. Tôi sẽ cần một cách để tách một câu lệnh thành phần đầu và phần đuôi dựa trên một khóa.

Mã này hữu ích hơn như một bài tập lập trình và có lẽ chậm hơn rất nhiều so với các giải pháp khác ở đây kết hợp đệ quy và lặp lại. Giải pháp của @ Nutcracker khá tốt cho các từ điển lồng nhau.

Sử dụng đối tượng trình bao bọc này để cung cấp so sánh từng phần và khác biệt tốt:

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