कैसे नामित या गतिशील प्रकार का निर्माण कार्य करता है

हम बुर्का में न केवल लोगों और नंबरों से प्यार करते हैं। हम अपने मूल उपकरण, पायथन भाषा के बारे में अपने ज्ञान में लगातार सुधार कर रहे हैं। जो हमारे साथ सुधार करना चाहते हैं उनके लिए लिंक । इस अनुवाद लेख में, लेखक ने namedtuple डिवाइस को पार्स किया और भाषा की बुनियादी अवधारणाओं में से एक के बारे में बात करता है।

कुछ दिनों पहले मैं सैन फ्रांसिस्को के लिए जा रहा था। विमान में कोई इंटरनेट नहीं था, इसलिए मैंने पायथन 2.7 मानक पुस्तकालय के लिए स्रोत कोड पढ़ा। namedtuple का कार्यान्वयन मेरे लिए विशेष रूप से दिलचस्प लग रहा था, शायद इसलिए कि वास्तव में सब कुछ पहले की तुलना में बहुत सरल है।

यहाँ स्रोत कोड हैं। यदि आप namedtuple कभी भी namedtuple बारे में नहीं जानते थे, तो मेरा सुझाव है कि आप इस सुविधा से खुद को परिचित करें ।

कोड

 ################################################################################ ### namedtuple ################################################################################ 

वाह! प्रभावशाली शीर्षक, सही?

शुरुआत में, जैसा कि अपेक्षित था, एक फ़ंक्शन की परिभाषा, और एक अच्छे सिद्धांत का एक उदाहरण।

 def namedtuple(typename, field_names, verbose=False, rename=False): """      . >>> Point = namedtuple('Point', 'x y') >>> Point.__doc__ #    'Point(x, y)' >>> p = Point(11, y=22) #        >>> p[0] + p[1] #     33 >>> x, y = p #     >>> x, y (11, 22) >>> px + py #     33 >>> d = p._asdict() #    >>> d['x'] 11 >>> Point(**d) #    Point(x=11, y=22) >>> p._replace(x=100) #     Point(x=100, y=22) """ 

फिर तर्कों के साथ प्रदर्शन शुरू होता है। basestring कॉल में basestring के उपयोग पर ध्यान basestring - इस तरह से हम यह निर्धारित करेंगे कि हम स्ट्रिंग के साथ काम करते हैं यदि ऑब्जेक्ट प्रकार unicode या str (यह निश्चित रूप से पायथन <3.0 में काम करता है)।

  #     .    : #      #      . if isinstance(field_names, basestring): field_names = field_names.replace(',', ' ').split() #    /  

यदि rename विशेषता सेट है, तो सभी अमान्य फ़ील्ड नामों को उनके पदों के अनुसार नाम दिया जाएगा।

  field_names = tuple(map(str, field_names)) if rename: names = list(field_names) seen = set() for i, name in enumerate(names): if (not all(c.isalnum() or c=='_' for c in name) or _iskeyword(name) or not name or name[0].isdigit() or name.startswith('_') or name in seen): names[i] = '_%d' % i seen.add(name) field_names = tuple(names) 

all() में लिपटे जनरेटर अभिव्यक्ति को नोटिस करें all() । इस तरह की एक प्रविष्टि, all(bool_expr(x) for x in things) , एक अभिव्यक्ति में वांछित परिणाम का वर्णन करने के लिए एक अत्यंत सुविधाजनक तरीका है।

  for name in (typename,) + field_names: if not all(c.isalnum() or c=='_' for c in name): raise ValueError( 'Type names and field names can only contain alphanumeric characters and underscores: %r' % name ) if _iskeyword(name): raise ValueError('Type names and field names cannot be a keyword: %r' % name) if name[0].isdigit(): raise ValueError('Type names and field names cannot start with a number: %r' % name) 

डुप्लिकेट नामों की जाँच करें:

  seen_names = set() for name in field_names: if name.startswith('_') and not rename: raise ValueError('Field names cannot start with an underscore: %r' % name) if name in seen_names: raise ValueError('Encountered duplicate field name: %r' % name) seen_names.add(name) 

और अब असली मज़ा शुरू होता है। (मुझे यकीन है कि रनटाइम के दौरान डेटा टाइप बनाना मज़ेदार है)। हम कोड टेम्पलेट में एम्बेड करने के लिए अलग-अलग तरीकों से फ़ील्ड नाम तैयार करते हैं। यह एक दिलचस्प है कि एक tuple और स्लाइस संकेतन के पाठ प्रतिनिधित्व का उपयोग argtxt को परिभाषित करने के लिए किया argtxt ।

  #      numfields = len(field_names) argtxt = repr(field_names).replace("'", "")[1:-1] #       reprtxt = ', '.join('%s=%%r' % name for name in field_names) 

और यह वास्तव में namedtuple हूड के तहत चल रहा है। यह रेखा बाद में पायथन कोड में बदल जाएगी।

  template = '''class %(typename)s(tuple): '%(typename)s(%(argtxt)s)' \n __slots__ = () \n _fields = %(field_names)r \n def __new__(_cls, %(argtxt)s): 'Create new instance of %(typename)s(%(argtxt)s)' return _tuple.__new__(_cls, (%(argtxt)s)) \n @classmethod def _make(cls, iterable, new=tuple.__new__, len=len): 'Make a new %(typename)s object from a sequence or iterable' result = new(cls, iterable) if len(result) != %(numfields)d: raise TypeError('Expected %(numfields)d arguments, got %%d' %% len(result)) return result \n def __repr__(self): 'Return a nicely formatted representation string' return '%(typename)s(%(reprtxt)s)' %% self \n def _asdict(self): 'Return a new OrderedDict which maps field names to their values' return OrderedDict(zip(self._fields, self)) \n __dict__ = property(_asdict) \n def _replace(_self, **kwds): 'Return a new %(typename)s object replacing specified fields with new values' result = _self._make(map(kwds.pop, %(field_names)r, _self)) if kwds: raise ValueError('Got unexpected field names: %%r' %% kwds.keys()) return result \n def __getnewargs__(self): 'Return self as a plain tuple. Used by copy and pickle.' return tuple(self) \n\n ''' % locals() 

दरअसल, यह हमारे नए वर्ग का खाका है।

स्ट्रिंग प्रक्षेप के लिए locals() का उपयोग करना मेरे लिए बहुत सुविधाजनक लगता है। पायथन में स्थानीय चरों के सरल प्रक्षेप का अभाव है। उदाहरण के लिए, ग्रूवी और कॉफ़ीस्क्रिप्ट में, आप "{name} is {some_value}" जैसे कुछ लिख सकते हैं । लेकिन मुझे लगता है कि यह पायथन संस्करण ठीक काम करेगा: "{name} is {some_value}".format(**locals()) ।

आपने शायद देखा कि __slots__ को एक खाली टपल के रूप में परिभाषित किया गया है। इस मामले में पायथन उदाहरणों के रूप में उदाहरणों के लिए शब्दकोशों का उपयोग नहीं करता है, जो संसाधनों को थोड़ा बचाता है। अभिभावक वर्ग ( tuple ), और नई विशेषताओं को जोड़ने की अक्षमता (क्योंकि __slots__ = () ) के कारण होने वाली अपरिवर्तनीयता के कारण, __slots__ = () प्रकार के उदाहरण मूल्य ऑब्जेक्ट हैं ।

चलिए आगे बढ़ते हैं। प्रत्येक नाम के लिए एक रीड-ओनली प्रॉपर्टी बनाई जाती है। _itemgetter operator मॉड्यूल का एक itemgetter है जो एकल तर्क का एक फ़ंक्शन देता है, जो संपत्ति के लिए सही है।

  for i, name in enumerate(field_names): template += " %s = _property(_itemgetter(%d), doc='Alias for field number %d')\n" % (name, i, i) if verbose: print template 

तो, हमारे पास एक पालतू कोड के साथ एक भव्य रेखा है। उसका क्या करें? एक सीमित नामस्थान में चलना उचित लगता है। देखें कि कैसे exec ... in किया जाता exec ... in उपयोग यहां किया जाता है:

  #       . #     ,   # frame.f_globals['__name__'] namespace = dict(_itemgetter=_itemgetter, __name__='namedtuple_%s' % typename, OrderedDict=OrderedDict, _property=property, _tuple=tuple) try: exec template in namespace except SyntaxError, e: raise SyntaxError(e.message + ':\n' + template) result = namespace[typename] 

बहुत चालाक! एक पृथक नाम स्थान में कोड की एक पंक्ति को निष्पादित करने और फिर उसमें से एक नए प्रकार को खींचने का विचार मेरे लिए असामान्य है। exec बारे में विवरण के लिए exec आर्मिन रौनाकर के पद पर जाएं ।

नेक्स्ट क्लास के __module__ को मॉड्यूल के रूप में परिभाषित करने के लिए अगला जादू है, जिसे namedtuple कहा जाता है:

  try: result.__module__ = _sys._getframe(1).f_globals.get('__name__', '__main__') except (AttributeError, ValueError): pass 

और यह बात है!

  return result 

सरल, सही?

कार्यान्वयन पर विचार

ऊपर वर्णित कोड के लिए सबसे दिलचस्प विवरण नेमस्पेस में कोड की एक पंक्ति का गतिशील निष्पादन था, जो विशेष रूप से इस एक निष्पादन के लिए बनाया गया है। यह कदम पायथन डेटा मॉडल की सादगी पर जोर देता है: मॉड्यूल और कक्षाएं सहित सभी नामस्थान, अनिवार्य रूप से शब्दकोष हैं। namedtuple के namedtuple का अध्ययन एक बार फिर इस तरह की सरलता की शक्ति साबित करता है।
इस तकनीक का उपयोग करके, हम फ़ील्ड नामों के सत्यापन को सरल बना सकते हैं, और इसके बजाय

 for name in (typename,) + field_names: if not all(c.isalnum() or c=='_' for c in name): raise ValueError('Type names and field names can only contain alphanumeric characters and underscores: %r' % name) if _iskeyword(name): raise ValueError('Type names and field names cannot be a keyword: %r' % name) if name[0].isdigit(): raise ValueError('Type names and field names cannot start with a number: %r' % name) 

लिख सकता था

 for name in (typename,) + field_names: try: exec ("%s = True" % name) in {} except (SyntaxError, NameError): raise ValueError('Invalid field name: %r' % name) 

सीधे और संक्षेप में पहचानकर्ता की वैधता का परीक्षण करें। लेकिन इस मामले में, हम एक त्रुटि होने पर समस्या के वर्णन में सटीकता खो देंगे। और चूंकि यह एक मानक पुस्तकालय है, इसलिए स्पष्ट त्रुटि संदेश वर्तमान कार्यान्वयन को बेहतर विकल्प बनाते हैं।

हमारे बीच ही find

हम बहुत भाग्यशाली हैं कि पायथन मानक पुस्तकालय को पढ़ना इतना आसान है। इसके बारे में मत भूलो, अंतर्निहित मॉड्यूल के स्रोत कोड को पढ़ें जो आप उपयोग करते हैं - यह सरल और उपयोगी है!

और सामान्य तौर पर। आपके द्वारा उपयोग किए जाने वाले टूल की संभावनाओं का अन्वेषण करें, साइकिल चलाने में संलग्न न हों!