python - मैं पायथन में सार बेस क्लास के साथ एक शब्द कैसे लागू करूं?




dictionary abc (4)

इस सवाल का पहले से ही उत्तर दिया गया है:

मैंने सार बेस क्लास, म्यूटेबलमैपिंग का उपयोग करके पायथन में मैपिंग को लागू करने का प्रयास किया, लेकिन मुझे तत्काल पर एक त्रुटि मिली। मैं इस शब्दकोश के कार्य संस्करण को कैसे बनाऊँगा जो अंतर्निहित तत्व वर्ग का अनुकरण करेगा, संभव के रूप में कई तरीकों से, सार बेस क्लास के साथ स्पष्ट होना चाहिए?

>>> class D(collections.MutableMapping):
...     pass
... 
>>> d = D()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Can't instantiate abstract class D with abstract methods __delitem__, __getitem__, __iter__, __len__, __setitem__

एक अच्छा जवाब इस काम को कैसे प्रदर्शित करेगा, विशेष रूप से बिना उप-वर्गीकृत dict ( एक अवधारणा जिसे मैं काफी परिचित हूँ ) के बिना dict


MutableMapping को बेस क्लास के रूप में आपको इस पद्धति को अपने वर्ग में बनाना चाहिए: __delitem__, __getitem__, __iter__, __len__, __setitem__

कस्टम डायस क्लास बनाने के लिए आप इसे डिक्ट से प्राप्त कर सकते हैं:

>>> class D(dict):
...     pass
... 
>>> d = D()
>>> d
{}

कम से कम

आपको अपने उपवर्ग में कार्यान्वित करने की आवश्यकता है, सभी अमूर्त विधियों जो आप उत्परिवर्तनशील मैसेजिंग से प्राप्त करते हैं

class D(MutableMapping):
    def __delitem__(self):
        '''
         Your Implementation for deleting the Item goes here
        '''
        raise NotImplementedError("del needs to be implemented")
    def __getitem__(self):
        '''
         Your Implementation for subscripting the Item goes here
        '''
        raise NotImplementedError("obj[index] needs to be implemented")
    def __iter__(self):
        '''
         Your Implementation for iterating the dictionary goes here
        '''
        raise NotImplementedError("Iterating the collection needs to be implemented")
    def __len__(self):
        '''
         Your Implementation for determing the size goes here
        '''
        raise NotImplementedError("len(obj) determination needs to be implemented")
    def __setitem__(self):
        '''
         Your Implementation for determing the size goes here
        '''
        raise NotImplementedError("obj[index] = item,  needs to be implemented")


>>> D()
<__main__.D object at 0x0258CD50>

अतिरिक्त

आपको अपने मैपिंग (हैश, एवीएल, रेड ब्लैक) को स्टोर करने के लिए एक डाटा स्ट्रक्चर प्रदान करने की आवश्यकता है, और अपने शब्दकोश का निर्माण करने का एक तरीका


मैं सार बेस कक्षाओं के साथ एक शब्द कैसे लागू होगा?

एक अच्छा जवाब इस काम को कैसे प्रदर्शित करेगा, विशेष रूप से बिना उपवर्ती शब्दकोष के

यहाँ त्रुटि संदेश है: TypeError: Can't instantiate abstract class D with abstract methods __delitem__, __getitem__, __iter__, __len__, __setitem__

यह पता चला है कि MutableMapping बेस क्लास (एबीसी), MutableMapping का इस्तेमाल करने के लिए उन्हें लागू करना होगा।

कार्यान्वयन

इसलिए मैं मानचित्रण के लिए ऑब्जेक्ट के विशेषता संदर्भ का उपयोग करता है, जो मैपिंग का उपयोग करता है। (प्रतिनिधिमंडल विरासत के समान नहीं है, इसलिए हम सिर्फ उदाहरण __dict__ को प्रतिनिधि करेंगे, हम किसी अन्य विज्ञापन-हॉक मानचित्रण का उपयोग कर सकते हैं, लेकिन आप कार्यान्वयन के उस हिस्से की देखभाल नहीं करते हैं। यह करने के लिए समझ में आता है यह पायथन 2 में यह तरीका है, क्योंकि MutableMapping में पायथन 2 में __slots__ नहीं है, इसलिए आप एक __dict__ या तो कोई रास्ता बना रहे हैं। पायथन 3 में, आप __slots__ को सेट करके पूरी तरह से __slots__ ।)

import collections

class D(collections.MutableMapping):
    '''
    Mapping that works like both a dict and a mutable object, i.e.
    d = D(foo='bar')
    and 
    d.foo returns 'bar'
    '''
    # ``__init__`` method required to create instance from class.
    def __init__(self, *args, **kwargs):
        '''Use the object dict'''
        self.__dict__.update(*args, **kwargs)
    # The next five methods are requirements of the ABC.
    def __setitem__(self, key, value):
        self.__dict__[key] = value
    def __getitem__(self, key):
        return self.__dict__[key]
    def __delitem__(self, key):
        del self.__dict__[key]
    def __iter__(self):
        return iter(self.__dict__)
    def __len__(self):
        return len(self.__dict__)
    # The final two methods aren't required, but nice for demo purposes:
    def __str__(self):
        '''returns simple dict representation of the mapping'''
        return str(self.__dict__)
    def __repr__(self):
        '''echoes class, id, & reproducible representation in the REPL'''
        return '{}, D({})'.format(super(D, self).__repr__(), 
                                  self.__dict__)

प्रदर्शन

और उपयोग को प्रदर्शित करने के लिए:

>>> d = D((e, i) for i, e in enumerate('abc'))
>>> d
<__main__.D object at 0x7f75eb242e50>, D({'b': 1, 'c': 2, 'a': 0})
>>> d.a
0
>>> d.get('b')
1
>>> d.setdefault('d', []).append(3)
>>> d.foo = 'bar'
>>> print(d)
{'b': 1, 'c': 2, 'a': 0, 'foo': 'bar', 'd': [3]}

और डिक्ट एपीआई को सुनिश्चित करने के लिए, यह सबक सीखा है कि आप हमेशा collections.MutableMapping लिए जांच कर सकते हैं। चुने हुए मैपिंग:

>>> isinstance(d, collections.MutableMapping)
True
>>> isinstance(dict(), collections.MutableMapping)
True

और जब कोई संग्रह संग्रह के आयात पर पंजीकरण के कारण एक अनुक्रमिक मैपिंग का एक उदाहरण है, तो रिवर्स हमेशा सच नहीं होता है:

>>> isinstance(d, dict)
False
>>> isinstance(d, (dict, collections.MutableMapping))
True

इस अभ्यास के बाद, यह मुझे स्पष्ट है कि सार बेस क्लास का उपयोग केवल कक्षा के उपयोगकर्ताओं के लिए मानक एपीआई की गारंटी प्रदान करता है। इस स्थिति में, उपयोगकर्ताओं को एक MutableMapping ऑब्जेक्ट मानते हुए पायथन के मानक एपीआई की गारंटी दी जाएगी।

चेतावनियां:

fromkeys क्लास कन्स्ट्रक्टर विधि लागू नहीं की गई है।

>>> dict.fromkeys('abc')
{'b': None, 'c': None, 'a': None}
>>> D.fromkeys('abc')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: type object 'D' has no attribute 'fromkeys'

एक setdefault या सेट setdefault जैसी अंतर्निहित सिद्धांतों को ढंक कर सकता है

>>> d['get'] = 'baz'
>>> d.get('get')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object is not callable

इसे फिर से उतारना काफी आसान है:

>>> del d['get']
>>> d.get('get', 'Not there, but working')
'Not there, but working'

लेकिन मैं उत्पादन में इस कोड का उपयोग नहीं करेगा।

एक डिक्ट के बिना प्रदर्शन, पायथन 3:

>>> class MM(MutableMapping):
...   __delitem__, __getitem__, __iter__, __len__, __setitem__ = (None,) *5
...   __slots__ = ()
...
>>> MM().__dict__
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'MM' object has no attribute '__dict__'

एक सार बेस क्लास का पूरा विचार यह है कि इसमें कुछ सदस्य हैं, (C ++ पदों में शुद्ध आभासी सदस्य), जो आपके कोड को देना है - C ++ में ये शुद्ध वर्चुअल सदस्य हैं और अन्य वर्चुअल सदस्य हैं जो आप ओवरराइड कर सकते हैं।

पायथन सी ++ से भिन्न होता है जिसमें सभी वर्गों के सभी सदस्य आभासी होते हैं और ओवरराइड किए जा सकते हैं, (और आप सभी वर्गों और उदाहरणों में सदस्यों को जोड़ सकते हैं), लेकिन सार बेस कक्षाओं में कुछ आवश्यक गायब वर्ग हैं जो ये सी ++ शुद्ध आभासी के समान हैं।

जिस तरह से आपको अपने व्युत्पन्न वर्ग का एक उदाहरण बनाने में सक्षम होने के लिए केवल लापता सदस्यों की आपूर्ति करने की जरूरत है, इसे प्राप्त करने के बाद।

इस प्रकार की एक चीज के उदाहरण के लिए जिसे आप स्वीकार्य जवाब को देखने की कोशिश कर रहे हैं लेकिन क्लास के भीतर एक शब्द का उपयोग करने के बजाय आपको उन तरीकों को प्रदान करना होगा जो यह स्वयं प्रदान करता है







abc