PyObject के साथ सवालों के जवाब। भाग २

सभी को नमस्कार।
यह साइट pyobject.ru से पायथन पर प्रश्नों और कार्यों के जवाबों की एक निरंतरता है।


अस्वीकरण :

प्रस्तावित उत्तरों को सबसे सही नहीं माना जाना चाहिए। इसके अलावा, मुझे आशा है कि अधिक अनुभवी लोग त्रुटियों, अशुद्धियों और बुरे स्थानों को इंगित करेंगे। जिसके लिए वे आपको अग्रिम धन्यवाद देते हैं।

कक्षाएं

1. आधार वर्ग का अवलोकन करें, जो उत्तराधिकारियों को अनुमति देगा:
एक। जब ** kwargs संचारित कर रहे हैं, विशेषताओं के रूप में संबंधित मान दर्ज करें
ख। सभी सार्वजनिक विशेषताओं का प्रिंट प्रदर्शन करें

विशेषता तक पहुँचने पर, निम्नलिखित होता है (यहाँ वह झूठ बोल सकता है):
1. इसमें एक विशेषता की उपस्थिति के लिए वस्तु को स्वयं जांचा जाता है। कस्टम विशेषताएँ ऑब्जेक्ट के __dict__ विशेषता में संग्रहीत की जाती हैं।
2. वस्तु के प्रकार __dict__ को वस्तु के __class __.__ के माध्यम से जाँचता है
3. माता-पिता चेक किए गए प्रकार हैं
4. नई कक्षाओं के लिए __getattribute__ विधि निष्पादित की गई है
5. __getattr__ विधि निष्पादित की गई है

विशेषताओं के रूप में उपलब्ध मूल्यों के लिए, यह __dict__ ऑब्जेक्ट की विशेषता को अद्यतन करने के लिए पर्याप्त है, जो कि __init__ विधि में होता है।
__Str__ विधि का उपयोग किसी वस्तु की "सूचनात्मक प्रस्तुति" को प्रदर्शित करने के लिए किया जाता है। इस मामले में, हम ऑब्जेक्ट और उनके मूल्यों की सभी सार्वजनिक विशेषताओं को प्रदर्शित करते हैं।

class Observable(object): """ Base class for attributes from dict. >>> class X(Observable): ... pass >>> x = X(foo=1, bar="Test", _barr='hidden', baz=(5, 6)) >>> print x X(bar=Test, foo=1, baz=(5, 6)) >>> print x.foo 1 >>> print x.bar Test >>> print x._barr hidden >>> print x.baz (5, 6) """ def __init__(self, **kwargs): self.__dict__.update(kwargs) def __str__(self): return '%s(%s)' % (self.__class__.__name__,\ (', '.join('%s=%s' % (key, val) for (key, val)\ in self.__dict__.iteritems() if not key.startswith('_')))) 

2. एक ऐसा वर्ग लिखें जो सभी बाहरी संकेतों द्वारा एक शब्दकोश हो, लेकिन विशेषताओं के रूप में कुंजी तक पहुंच की अनुमति दें।
वर्ग के लिए सभी बाहरी संकेतों द्वारा एक शब्दकोश होने के लिए, हम इसे इस शब्दकोश से विरासत में लेंगे। और इसलिए कि चाबियों को विशेषताओं के रूप में एक्सेस किया जा सकता है, वर्ग में हम __getattr__ विधि को परिभाषित करते हैं, जिसे तब कहा जाता है जब विशेषता वस्तु, उसके प्रकार और माता-पिता के शब्दकोश में नहीं मिलती है।

  class DictAttr(dict): """ Base class for JS-style dict. >>> x = DictAttr([('one', 1), ('two', 2), ('three', 3)]) >>> print x {'three': 3, 'two': 2, 'one': 1} >>> print x['three'] 3 >>> print x.get('two') 2 >>> print x.one 1 >>> print x.test Traceback (most recent call last): ... AttributeError """ def __getattr__(self, name): try: return self[name] except KeyError: raise AttributeError 

3. बिंदु 2 जटिलता के साथ: मूल वर्ग XDictAttr लिखें ताकि उत्तराधिकारी get_KEY विधि की उपस्थिति से गतिशील रूप से निर्धारित हो।
मैंने इस कार्य के लिए बहुत समय बिताया, क्योंकि मैं इसे फैशनेबल, स्टाइलिश, युवा नहीं बना सकता और न ही बैसाखी। जो हुआ वो आपके ऊपर है

संक्षेप में, यह कैसे काम करता है:
1. __getitem__ विधि आपको [के माध्यम से कॉल को इंटरसेप्ट करने की अनुमति देता है]
जब हम विधि में हो जाते हैं, तो शुरुआत में, हम केवल मूल __getemem__ पर कॉल करके शब्दकोश को एक्सेस करके मूल्य प्राप्त करने का प्रयास करते हैं। यदि तत्व शब्दकोश में नहीं मिला था, तो हम __getattr__ विधि का उपयोग करके मान प्राप्त करने का प्रयास करते हैं, जिसके तर्क के रूप में हम get_KEY का उपयोग करते हैं
2. प्राप्त () विधि मानक प्राप्त () प्रकार के व्यवहार के अधिभाव को पार कर जाती है। हम पहले __getattr__ और get_KEY तर्क का उपयोग करके विशेषता प्राप्त करने का प्रयास करते हैं। और केवल विफलता के मामले में हम माता-पिता को प्राप्त करने की विधि कहते हैं, जो अपरिभाषित __getitem__ को कॉल करेगा और शब्दकोश में तर्क की उपस्थिति की जांच करेगा।
3. __getattr__ विधि आपको अन्य सभी स्थितियों को संभालने की अनुमति देती है। सबसे पहले, हम पैरेंट __getitem__ को कॉल के माध्यम से मान प्राप्त करने का प्रयास करते हैं। और यहां, विफलता के मामले में, एक गंदा हैक खेल में आता है। मैं अभी भी यह पता नहीं लगा सकता कि कैसे पुनरावृत्ति की संभावना को बाहर रखा जाए, क्योंकि आपको get_KEY विशेषता की जांच करनी है, जो __getattr__ ऑब्जेक्ट पर कॉल के माध्यम से होती है। खैर, आपको बात समझ में आ गई। अंत में, मेरे पास get_get_get_get_get_get_foo जैसी लाइन थी।

इस कार्यान्वयन का नुकसान यह है कि get_ के साथ शुरू होने वाले गुण एक गुण को बढ़ाएंगे। यह सिद्धांत के लिए मैप किया गया है।

  class XDictAttr(dict): """ >>> class X(XDictAttr): ... def get_foo(self): ... return 5 ... def get_bar(self): ... return 12 ... def get_get_z(self): ... return 42 >>> x = X({'one': 1, 'two': 2, 'three': 3}) >>> x {'one': 1, 'three': 3, 'two': 2} >>> x['one'] 1 >>> x.three 3 >>> x.bar 12 >>> x['foo'] 5 >>> x.get('foo', 'missing') 5 >>> x.get('bzz', 'missing') 'missing' >>> x.get_bar() 12 >>> x.get_foz() Traceback (most recent call last): ... AttributeError >>> x.get_get_z() 42 >>> x.get('get_z') 42 >>> x.get_z Traceback (most recent call last): ... AttributeError """ def __getattr__(self, name): try: return super(XDictAttr, self).__getitem__(name) except KeyError: if not name.startswith('get_'): return getattr(self, 'get_%s' % name)() else: raise AttributeError def __getitem__(self, key): try: return super(XDictAttr, self).__getitem__(key) except KeyError: return getattr(self, 'get_%s' % key)() def get(self, key, default=None): try: return getattr(self, 'get_%s' % key)() except AttributeError: return super(XDictAttr, self).get(key, default) 

4. एक वर्ग लिखें जो अपने उदाहरणों को पंजीकृत करता है और उनके लिए एक पुनरावृत्ति इंटरफ़ेस प्रदान करता है
मैं समझता हूं कि मैं पायथन में ज्यादा नहीं जानता, लेकिन मेरे लिए इस कार्य को निम्नलिखित कारणों से मेटाक्लासेस के लिए जिम्मेदार ठहराया जाना चाहिए:

  >>> for i in Reg: ... print i <Reg instance at 0x98b6ecc> <Reg instance at 0x98b6fec> <Reg instance at 0x98ba02c> 

इस उदाहरण का तात्पर्य है कि हम एक प्रकार से एक इट्रेटर लेते हैं, एक वर्ग की वस्तु नहीं। और अजगर दुभाषिया एक समान त्रुटि जब मैंने __iter__ को एक वर्गमिथोड या स्टेटमिथोड में लपेटने की कोशिश की थी।
इसलिए, मेरा कार्यान्वयन इस प्रकार है:

  class RegBase(type): def __iter__(cls): return iter(cls._instances) class Reg(object): """ >>> x = Reg() >>> x # doctest: +ELLIPSIS <__main__.Reg object at 0x...> >>> y = Reg() >>> y # doctest: +ELLIPSIS <__main__.Reg object at 0x...> >>> z = Reg() >>> z # doctest: +ELLIPSIS <__main__.Reg object at 0x...> >>> for i in Reg: # doctest: +ELLIPSIS ... print i <__main__.Reg object at 0x...> <__main__.Reg object at 0x...> <__main__.Reg object at 0x...> """ __metaclass__ = RegBase _instances = [] def __init__(self): self._instances.append(self) 

PS हाँ, और रेग उदाहरण उदाहरण में, मेरे पास एक Reg ऑब्जेक्ट है। शायद मेरा जाम्ब यहाँ है?

मेटाक्लासेस और डिस्क्रिप्टर्स

संभवतः सबसे विवादास्पद खंड, क्योंकि मेरे पास व्यावहारिक रूप से इस कारण से मेटाक्लासेस का कोई लेना-देना नहीं था: "यदि आपको नहीं पता कि आपको मेटाक्लस की आवश्यकता है, तो आपको इसकी आवश्यकता नहीं है।" लेकिन फिर भी कोशिश करते हैं।

सवाल:
मैं प्रलेखन (डेटा मॉडल) को उद्धृत नहीं करूंगा। इसके अलावा, मैं लिखूंगा: विशेष रूप से सामान्य रूप में ऑब्जेक्ट संरचना और मेटाक्लासेस के बारे में हैबे पर अच्छे लेख हैं। इधर और उधर । उनके लेखकों को धन्यवाद।

कार्य:
1. वर्णनकर्ता को लागू करें जो विशेषता के प्रकार को ठीक करेगा।
दो शब्दों में, एक विवरणक एक विशिष्ट व्यवहार के साथ एक नए तरह के वर्ग का एक गुण है।
विवरणकर्ताओं पर एक लेख यहाँ है।

  class Property(object): """ >>> class Image(object): ... height = Property(0) ... width = Property(0) ... path = Property('/tmp/') ... size = Property(0) >>> img = Image() >>> img.height = 340 >>> img.height 340 >>> img.path = '/tmp/x00.jpeg' >>> img.path '/tmp/x00.jpeg' >>> img.path = 320 Traceback (most recent call last): ... TypeError """ def __init__(self, value): self.__value = value self.__value_type = type(value) def __get__(self, obj, objtype=None): return self.__value def __set__(self, obj, value): if type(value) == self.__value_type: self.__value = value else: raise TypeError 

2. बेस क्लास (मेटाक्लास का उपयोग करके) को लागू करें जो विशेषता प्रकार को ठीक करेगा।
यहाँ मुझे एक समस्या थी - मैं इस कार्य को बिलकुल नहीं समझता था। लेखक के उदाहरण के बाद, विशेषताएँ ऊंचाई, पथ वर्ग हैं। क्या इसका मतलब यह था कि मेटाक्लास को किसी वस्तु को हस्तांतरित और हस्तांतरित करना चाहिए या केवल यह स्पष्ट नहीं है। मैंने दूसरा लागू किया।

संपत्ति वर्ग कार्य 1 के उत्तर के समान है।
हमें केवल उस संपत्ति की सार्वजनिक विशेषताओं को लपेटने की आवश्यकता है जिसे हम संपत्ति में बना रहे हैं। चूंकि मेटाक्लास को क्लास विशेषताओं के साथ एक शब्दकोश प्राप्त होता है, इसलिए यह कोई समस्या नहीं है।
इसके अतिरिक्त, उन्होंने जाँच की कि क्या विशेषता सार्वजनिक है या विधि द्वारा।

  class ImageMeta(type): def __new__(mcs, name, bases, dct): for key, val in dct.iteritems(): if not key.startswith('_') and not hasattr(val, '__call__'): dct[key] = Property(val) return type.__new__(mcs, name, bases, dct) class ImageBase(object): """ >>> class Image(ImageBase): ... height = 0 ... path = 'tmp' ... ... def foo(self): ... return 'bar' >>> img = Image() >>> img.height = 340 >>> img.height 340 >>> img.path = '/tmp/x00.jpeg' >>> img.path '/tmp/x00.jpeg' >>> img.path = 320 Traceback (most recent call last): ... TypeError >>> hasattr(img.foo '__call__') True """ __metaclass__ = ImageMeta 

3. बेस क्लास (मेटाक्लास का उपयोग करके) और डिस्क्रिप्टर को लागू करें जो क्लास के आधार पर मॉडल के लिए SQL-स्कीमा (ANSI SQL) बनाएंगे।
कृपया इस विधि पर टिप्पणी करें, क्योंकि यह मुझे लगता है कि कोई इसे और अधिक सुंदर बना सकता है।
कार्यान्वयन के लिए किए गए थे:
1. बेसिक प्रॉपर्टी डिस्क्रिप्टर एक क्लास काउंटर के साथ जो आपको उस क्रम में विशेषताओं को क्रमबद्ध करने की अनुमति देता है जिसमें वे बनाए गए थे।
2. अपने स्वयं के __str__ के साथ इंटेगर और स्ट्रर डिस्क्रिप्टर, जो मॉडल के एसक्यूएल प्रतिनिधित्व को बनाते समय उपयोग किए जाते हैं।
3. मेटाक्लास टेबलमेटा, जो मॉडल फ़ील्ड की एक सूची प्राप्त करता है और मॉडल का एक SQL प्रतिनिधित्व बनाता है।
4. आधार वर्ग तालिका, जो एक वर्ग विधि प्रदान करती है जो मॉडल के एसक्यूएल प्रतिनिधित्व को वापस करती है।

  class Property(object): """ >>> class Image(object): ... size = Property(int) ... name = Property(basestring) >>> img = Image() >>> img.size = 0 >>> img.size 0 >>> img.name = '/tmp/img' >>> img.name '/tmp/img' >>> img.size = '~' Traceback (most recent call last): ... TypeError >>> img.name = ['/tmp/', 'img'] Traceback (most recent call last): ... TypeError >>> img.__class__.__dict__['size'].counter 0 >>> img.__class__.__dict__['name'].counter 1 """ counter = 0 def __init__(self, value_type): self.__value = None self.__value_type = value_type self.counter = Property.counter Property.counter += 1 def __get__(self, obj, objtype=None): return self.__value def __set__(self, obj, value): if isinstance(value, self.__value_type): self.__value = value else: raise TypeError class Integer(Property): def __init__(self): super(Integer, self).__init__(int) def __str__(self): return self.__class__.__name__.upper() class Str(Property): def __init__(self, size): super(Str, self).__init__(basestring) self.__size = size def __str__(self): return '{0}({1})'.format('varchar', self.__size).upper() class TableMeta(type): def __new__(mcs, name, bases, dct): fields = [(attr_name, val) for (attr_name, val) in dct.items()\ if isinstance(val, Property)] fields.sort(key=lambda x: x[1].counter) sql = ',\n'.join('\t{0} {1}'.format(attr_name, val)\ for (attr_name, val) in fields) dct['__sql'] = u'CREATE TABLE {0} (\n{1}\n)'.format(name, sql) return type.__new__(mcs, name, bases, dct) class Table(object): """ >>> class Image(Table): ... height = Integer() ... width = Integer() ... path = Str(128) >>> print Image.sql() # doctest: +NORMALIZE_WHITESPACE CREATE TABLE Image ( height INTEGER, width INTEGER, path VARCHAR(128) ) """ __metaclass__ = TableMeta @classmethod def sql(cls): return cls.__dict__['__sql'] 

वह सब है। टिप्पणियों और आलोचना के लिए धन्यवाद।