कैसे सही ढंग से उपवर्गों को उप-विभाजित करें और getitem & setitem को ओवरराइड करें

Question 1

मैं कुछ कोड डिबग कर रहा हूं और मैं यह पता लगाना चाहता हूं कि किसी विशेष शब्दकोश को कब एक्सेस किया जाए। खैर, यह वास्तव में एक वर्ग है जो उप- dictअतिरिक्त और कुछ अतिरिक्त सुविधाओं को लागू करता है। वैसे भी, मैं जो करना चाहूंगा वह dictखुद को उप-वर्ग करना और ओवरराइड जोड़ना __getitem__और __setitem__कुछ डिबगिंग आउटपुट का उत्पादन करना है। अभी, मेरे पास है

class DictWatch(dict):
    def __init__(self, *args):
        dict.__init__(self, args)

    def __getitem__(self, key):
        val = dict.__getitem__(self, key)
        log.info("GET %s['%s'] = %s" % str(dict.get(self, 'name_label')), str(key), str(val)))
        return val

    def __setitem__(self, key, val):
        log.info("SET %s['%s'] = %s" % str(dict.get(self, 'name_label')), str(key), str(val)))
        dict.__setitem__(self, key, val)

' name_label'एक कुंजी है जो अंततः सेट हो जाएगी कि मैं आउटपुट की पहचान करने के लिए उपयोग करना चाहता हूं। मैंने तब वर्ग को बदल दिया है जो मैं उपवर्ग के DictWatchबजाय साधन कर रहा हूं dictऔर कॉल को सुपरकंस्ट्रक्टर में बदल दिया। फिर भी कुछ होता नहीं दिख रहा है। मुझे लगा कि मैं चालाक हो रहा हूं, लेकिन मुझे आश्चर्य है कि क्या मुझे एक अलग दिशा में जाना चाहिए।

सहायता के लिए धन्यवाद!

Question 2

आप जो कर रहे हैं वह बिल्कुल काम करना चाहिए। मैंने आपकी कक्षा का परीक्षण किया, और आपके लॉग स्टेटमेंट में एक गुम उद्घाटन कोष्ठक से अलग, यह ठीक काम करता है। केवल दो चीजें हैं जिनके बारे में मैं सोच सकता हूं। पहला, क्या आपके लॉग स्टेटमेंट का आउटपुट सही तरीके से सेट है? आपको logging.basicConfig(level=logging.DEBUG)अपनी स्क्रिप्ट के शीर्ष पर रखने की आवश्यकता हो सकती है ।

दूसरा, __getitem__और __setitem__केवल []एक्सेस के दौरान कहा जाता है । इसलिए सुनिश्चित करें कि आप केवल के बजाय के DictWatchमाध्यम d[key]से d.get()और का उपयोग करते हैंd.set()

Question 3

एक और मुद्दा जब सबक्लासिंग dictहोता है, तो अंतर्निहित __init__कॉल नहीं करता है update, और अंतर्निहित updateकॉल नहीं करता है __setitem__। इसलिए, यदि आप चाहते हैं कि सभी सेटिमिटी ऑपरेशंस आपके __setitem__फंक्शन से गुजरें, तो आपको यह सुनिश्चित करना चाहिए कि यह अपने आप हो जाए:

class DictWatch(dict):
    def __init__(self, *args, **kwargs):
        self.update(*args, **kwargs)

    def __getitem__(self, key):
        val = dict.__getitem__(self, key)
        print 'GET', key
        return val

    def __setitem__(self, key, val):
        print 'SET', key, val
        dict.__setitem__(self, key, val)

    def __repr__(self):
        dictrepr = dict.__repr__(self)
        return '%s(%s)' % (type(self).__name__, dictrepr)

    def update(self, *args, **kwargs):
        print 'update', args, kwargs
        for k, v in dict(*args, **kwargs).iteritems():
            self[k] = v

Question 4

उपवर्ग UserDictया पर विचार करें UserList। इन कक्षाओं जबकि सामान्य subclassed करने जा करना है dictऔर listनहीं हैं, और अनुकूलन होते हैं।

Question 5

यह वास्तव में परिणाम को नहीं बदलना चाहिए (जो कि अच्छे लॉगिंग थ्रेशोल्ड वैल्यू के लिए काम करना चाहिए): आपका इनिट होना चाहिए:

def __init__(self,*args,**kwargs) : dict.__init__(self,*args,**kwargs)

इसके बजाय, क्योंकि यदि आप अपने तरीके को डिक्टवॉच ([1,2), (2,3)]) या डिक्टवॉच (a = 1, b = 2) के साथ कहते हैं तो यह विफल हो जाएगा।

(या, बेहतर है, इसके लिए एक कंस्ट्रक्टर को परिभाषित न करें)

Question 6

आपको बस इतना करना होगा

class BatchCollection(dict):
    def __init__(self, inpt={}):
        super(BatchCollection, self).__init__(inpt)

मेरे व्यक्तिगत उपयोग के लिए एक नमूना उपयोग

### EXAMPLE
class BatchCollection(dict):
    def __init__(self, inpt={}):
        super(BatchCollection, self).__init__(inpt)

    def __setitem__(self, key, item):
        if (isinstance(key, tuple) and len(key) == 2
                and isinstance(item, collections.Iterable)):
            # self.__dict__[key] = item
            super(BatchCollection, self).__setitem__(key, item)
        else:
            raise Exception(
                "Valid key should be a tuple (database_name, table_name) "
                "and value should be iterable")

नोट : केवल अजगर 3 में परीक्षण किया गया

Question 7

पट उत्तर को पूरा करने के लिए, यहाँ एक उदाहरण दिया गया है dictऔर UserDict:

यह सही ढंग से अधिलेखित करने के लिए मुश्किल है:

class MyDict(dict):

  def __setitem__(self, key, value):
    super().__setitem__(key, value * 10)


d = MyDict(a=1, b=2)  # Bad! MyDict.__setitem__ not called
d.update(c=3)  # Bad! MyDict.__setitem__ not called
d['d'] = 4  # Good!
print(d)  # {'a': 1, 'b': 2, 'c': 3, 'd': 40}

UserDictसे वारिस collections.abc.MutableMapping, इसलिए अनुकूलित करना बहुत आसान है:

class MyDict(collections.UserDict):

  def __setitem__(self, key, value):
    super().__setitem__(key, value * 10)


d = MyDict(a=1, b=2)  # Good: MyDict.__setitem__ correctly called
d.update(c=3)  # Good: MyDict.__setitem__ correctly called
d['d'] = 4  # Good
print(d)  # {'a': 10, 'b': 20, 'c': 30, 'd': 40}

इसी तरह, आप केवल लागू करना __getitem__स्वचालित रूप से संगत होने के लिए key in my_dict, my_dict.get...

नोट: UserDictएक उपवर्ग नहीं है dict, इसलिए isinstance(UserDict(), dict)विफल होगा (लेकिन isinstance(UserDict(), collections.abc.MutableMapping)काम करेगा)

कैसे सही ढंग से उपवर्गों को उप-विभाजित करें और __getitem__ & __setitem__ को ओवरराइड करें

कैसे सही ढंग से उपवर्गों को उप-विभाजित करें और getitem & setitem को ओवरराइड करें