পাইথন: একটি অভিধান অন্য বৃহত অভিধানের উপসেট কিনা তা পরীক্ষা করুন

Question 1

আমি একটি কাস্টম ফিল্টার পদ্ধতি লেখার চেষ্টা করছি যা একটি স্বতন্ত্র সংখ্যক কাওয়ার্গ গ্রহণ করে এবং সেই ডাটাবেসের মতো তালিকার উপাদানগুলির সাথে একটি তালিকা ফেরত দেয় যা সেই কাওয়ার্গগুলি ধারণ করে ।

উদাহরণস্বরূপ, ধরুন d1 = {'a':'2', 'b':'3'}এবং d2= একই জিনিস। d1 == d2সত্য ফলাফল। তবে ধরা যাক d2= একই জিনিসটি এবং অন্যান্য জিনিসের একগুচ্ছ। আমার পদ্ধতিটি d2-তে d1 কিনা তা বলতে সক্ষম হওয়া দরকার তবে পাইথন অভিধানগুলি দিয়ে এটি করতে পারে না।

প্রসঙ্গ:

আমি একটি শব্দ বর্গ আছে, এবং প্রতিটি বস্তুর মত বৈশিষ্ট্য আছে word, definition, part_of_speech, ইত্যাদি। আমি এই শব্দগুলির মূল তালিকায় একটি ফিল্টার পদ্ধতিতে কল করতে সক্ষম হতে চাই, যেমন Word.objects.filter(word='jump', part_of_speech='verb-intransitive')। এই কীগুলি এবং মানগুলি একই সাথে কীভাবে পরিচালনা করবেন তা আমি বুঝতে পারি না। তবে অন্যান্য ব্যক্তির ক্ষেত্রে এর প্রেক্ষাপটের বাইরে এর বৃহত্তর কার্যকারিতা থাকতে পারে।

Question 2

আইটেম জোড়ায় রূপান্তর করুন এবং সংরক্ষণের জন্য পরীক্ষা করুন।

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

অপ্টিমাইজেশন পাঠকের জন্য অনুশীলন হিসাবে ছেড়ে গেছে।

Question 3

পাইথন 3 এ, আপনি dict.items()ডিক আইটেমগুলির একটি সেট-মত দর্শন পেতে ব্যবহার করতে পারেন । তারপরে আপনি <=অপারেটরটি পরীক্ষার জন্য ব্যবহার করতে পারেন যদি একটি ভিউ অন্যটির "উপসেট" হয়:

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

পাইথন ২.7-এ, dict.viewitems()একই কাজটি করতে ব্যবহার করুন :

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

পাইথন ২.6 এবং এর নীচে আপনার একটি পৃথক সমাধানের প্রয়োজন হবে যেমন ব্যবহার করে all():

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

Question 4

ইউনিট পরীক্ষার জন্য যাদের প্রয়োজন তাদের জন্য দ্রষ্টব্য: assertDictContainsSubset()পাইথনের TestCaseক্লাসে একটি পদ্ধতি রয়েছে ।

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

তবে এটি ৩.২-এ অবচয় করা হয়েছে, কেন তা নিশ্চিত নয়, সম্ভবত এর কোনও প্রতিস্থাপন রয়েছে।

Question 5

কী এবং মানগুলির পরীক্ষার জন্য: set(d1.items()).issubset(set(d2.items()))

আপনার যদি কেবল কীগুলি পরীক্ষা করতে হয়: set(d1).issubset(set(d2))

Question 6

সম্পূর্ণতার জন্য, আপনি এটিও করতে পারেন:

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

তবে, আমি গতির (বা এর অভাব) বা পঠনযোগ্যতা (বা এর অভাব) সম্পর্কিত কোনও দাবি করি না।

Question 7

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

Question 8

এখানে একটি সমাধান রয়েছে যা অভিধানের মধ্যে থাকা তালিকা এবং সেটগুলিতে যথাযথভাবে পুনরাবৃত্তি করে। আপনি এটি ডিক্টস ইত্যাদির তালিকাগুলির জন্যও ব্যবহার করতে পারেন ...

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

Question 9

একই উদ্দেশ্যে আমার ক্রিয়াকলাপ, এটি পুনরাবৃত্তি করে:

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)ডি 2 এর মধ্যে অন্য জিনিস থাকলেও সত্যটি ফিরে আসা উচিত, এবং এটি নিম্ন স্তরের ক্ষেত্রেও প্রযোজ্য:

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ধারাটি এড়িয়ে যায় এবং এমনকি বিস্তৃত ক্ষেত্রে (হ্যাশগুলির তালিকা ইত্যাদির ক্ষেত্রেও প্রযোজ্য)। এছাড়াও এখানে পুনরাবৃত্তি সীমাবদ্ধ নয় তাই আপনার নিজের ঝুঁকিতে ব্যবহার করুন। ;)

Question 10

এই আপাতদৃষ্টিতে সহজবোধ্য ইস্যুতে আমার 100% নির্ভরযোগ্য সমাধান খুঁজতে গবেষণায় কয়েক ঘন্টা ব্যয় হয়, তাই আমি এই উত্তরে যা পেয়েছি তা নথিভুক্ত করেছি।

"পাইথোনিক-মিত্র" কথা বলা, small_dict <= big_dictসবচেয়ে স্বজ্ঞাত উপায় হতে পারে তবে খুব খারাপ যে এটি কাজ করবে না । {'a': 1} < {'a': 1, 'b': 2}আপাতদৃষ্টিতে পাইথন 2 এ কাজ করে তবে এটি নির্ভরযোগ্য নয় কারণ সরকারী ডকুমেন্টেশন এটিকে স্পষ্ট করে বলেছে। যান অনুসন্ধান "সাম্যতা ব্যতীত ফলাফলগুলি ধারাবাহিকভাবে সমাধান করা হয়, তবে অন্যথায় সংজ্ঞায়িত হয় না।" মধ্যে এই বিভাগে । উল্লেখ করার মতো নয়, পাইথন 3-তে 2 ডিক্টের তুলনা করলে টাইপআরর ব্যতিক্রম হয়।
দ্বিতীয় অতি স্বজ্ঞাত জিনিসটি small.viewitems() <= big.viewitems()পাইথন কেবল ২.7 এর জন্য এবং small.items() <= big.items()পাইথন ৩ এর জন্য But তবে একটি সতর্কতা রয়েছে: এটি সম্ভাব্য বগী । যদি আপনার প্রোগ্রামটি সম্ভাব্যভাবে পাইথন <= 2.6 এ ব্যবহার করা যেতে পারে তবে এটি d1.items() <= d2.items()আসলে নির্দিষ্ট অর্ডার ছাড়াই 2 টি তালিকার তালিকার তুলনা করছে, সুতরাং চূড়ান্ত ফলাফলটি অবিশ্বাস্য হবে এবং এটি আপনার প্রোগ্রামে একটি বাজে বাগ হিসাবে পরিণত হবে। আমি পাইথন <= 2.6 এর জন্য আর একটি বাস্তবায়ন লেখার জন্য আগ্রহী নই, তবে আমি এখনও স্বাচ্ছন্দ্য বোধ করি না যে আমার কোডটি একটি পরিচিত বাগ সহ এসেছে (এমনকি এটি কোনও অসমর্থিত প্ল্যাটফর্মে থাকলেও)। সুতরাং আমি এই পদ্ধতির ত্যাগ।
আমি @ ব্লুবার্ডিব্লুব এর উত্তর (ক্রেডিট তার কাছে যায়) দিয়ে স্থায়ী হয়েছি :

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

এটি উল্লেখ করার মতো যে, এই উত্তরটি ==ডিক্টসের মধ্যে আচরণের উপর নির্ভর করে , যা সরকারী নথিতে স্পষ্টভাবে সংজ্ঞায়িত হয়েছে, তাই প্রতিটি পাইথন সংস্করণে কাজ করা উচিত । যান অনুসন্ধান:
- "অভিধানগুলি সমান তুলনা করে এবং যদি তাদের একই (কী, মান) জোড়া থাকে তবে"। এই পৃষ্ঠার শেষ বাক্য
- "ম্যাপিংস (ডিকের উদাহরণগুলি) সমান তুলনা করে এবং যদি তাদের সমান (কী, মান) জোড় থাকে। কী এবং উপাদানগুলির সমতার তুলনা প্রতিফলনকে কার্যকর করে।" মধ্যে এই পৃষ্ঠার

Question 11

প্রদত্ত সমস্যার জন্য এখানে একটি সাধারণ পুনরাবৃত্ত সমাধান রয়েছে:

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

উল্লেখ্য: মূল কোড নির্দিষ্ট ক্ষেত্রে ব্যর্থ হবে, জন্য ক্রেডিট ফিক্সিং যায় @ অলিভিয়ের-melançon

Question 12

আপনি যদি 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

Question 13

আমি জানি এই প্রশ্নটি পুরানো, তবে একটি নেস্টেড ডিকশনারিটি অন্য নেস্টেড ডিকশনারির একটি অংশ কিনা তা পরীক্ষা করার জন্য আমার সমাধান এখানে। সমাধান পুনরাবৃত্ত হয়।

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

Question 14

এই ফাংশনটি হ্যাশযোগ্য মানগুলির জন্য কাজ করে। আমি এটিও পরিষ্কার এবং সহজেই পড়তে পারি বলে মনে করি।

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

Question 15

একটি সংক্ষিপ্ত পুনরাবৃত্তিমূলক বাস্তবায়ন যা নেস্টেড অভিধানগুলির জন্য কাজ করে:

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 dicts গ্রাস করবে। অন্য উত্তরের মতো আংশিক পুনরাবৃত্তি সমাধানগুলি অবলম্বন না করে যদি কেউ এড়াতে ভাল উপায় সম্পর্কে জানেন তবে দয়া করে আমাকে বলুন। আমি একটি কি এর উপর ভিত্তি করে একটি ডিককে মাথা এবং লেজে বিভক্ত করার একটি উপায় প্রয়োজন।

প্রোগ্রামিং অনুশীলন হিসাবে এই কোডটি বেশি উপযোগী এবং সম্ভবত এখানে অন্যান্য সমাধানগুলির তুলনায় অনেক ধীর গতিযুক্ত যা পুনরাবৃত্তি এবং পুনরাবৃত্তি মিশ্রিত করে। @ নীটক্র্যাকারের সমাধান নেস্টেড ডিকশনারিগুলির জন্য বেশ ভাল।

Question 16

আংশিক তুলনা এবং চমৎকার পার্থক্য সরবরাহ করে এমন এই মোড়কের জিনিসটি ব্যবহার করুন:


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