डिस्क्रिप्टर गाइड

संक्षिप्त समीक्षा

इस लेख में मैं बात करूंगा कि डिस्क्रिप्टर प्रोटोकॉल के बारे में क्या वर्णनकर्ता हैं, और यह बताएं कि विवरणकर्ता कैसे कहलाते हैं। मैं अपने स्वयं के निर्माण का वर्णन करूंगा और कार्यों, गुणों, स्थिर तरीकों और वर्ग विधियों सहित कई अंतर्निहित वर्णनकर्ताओं का पता लगाऊंगा। एक साधारण एप्लिकेशन का उपयोग करते हुए, मैं दिखाऊंगा कि उनमें से प्रत्येक कैसे काम करता है, मैं शुद्ध अजगर कोड के साथ काम करने के लिए डिस्क्रिप्टर के आंतरिक कार्यान्वयन के समकक्षता दूंगा।

सीखना कि कैसे वर्णनकर्ता काम करते हैं, अधिक काम करने के उपकरण खोलेंगे, आपको बेहतर ढंग से समझने में मदद करेंगे कि अजगर कैसे काम करता है, और इसके डिजाइन की सुंदरता का अनुभव करता है।

परिचय और परिभाषाएँ

आम तौर पर बोलना, एक वर्णनकर्ता संबंधित व्यवहार ( अंग्रेजी बाध्यकारी व्यवहार) के साथ एक वस्तु का एक गुण है, अर्थात्। एक जिसका अभिगम व्यवहार वर्णनकर्ता प्रोटोकॉल विधियों द्वारा ओवरराइड किया जाता है। ये विधियाँ __get__ , __set__ और __delete__ । यदि इनमें से कम से कम एक विधि को किसी वस्तु के लिए परिभाषित किया जाता है, तो यह एक विवरणक बन जाता है।

विशेषताओं तक पहुँचने के दौरान मानक व्यवहार किसी ऑब्जेक्ट के शब्दकोश से एक विशेषता को प्राप्त करना, सेट करना और हटाना है। उदाहरण के लिए, ax में निम्नलिखित विशेषता खोज श्रृंखला होती है: a.__dict__['x'] , फिर type(a).__dict__['x'] करने के लिए type(a).__dict__['x'] , और फिर type(a) के आधार वर्गों तक type(a) मेटाक्लासेस सहित नहीं। यदि वांछित मान एक ऑब्जेक्ट है जिसमें कम से कम एक तरीका है जो डिस्क्रिप्टर को परिभाषित करता है, तो अजगर मानक खोज श्रृंखला को बदल सकता है और डिस्क्रिप्टर विधियों में से एक को कॉल कर सकता है। यह कैसे और कब होता है यह इस बात पर निर्भर करता है कि वस्तु के लिए कौन से वर्णनात्मक तरीके परिभाषित हैं। डिस्क्रिप्टर्स को केवल एक नई शैली की वस्तुओं या वर्गों के लिए कहा जाता है (एक वर्ग एक है यदि यह object या type से विरासत में मिला है)।

डिस्क्रिप्टर एक विस्तृत दायरे के साथ एक शक्तिशाली प्रोटोकॉल है। वे गुण, विधियों, स्थिर विधियों, वर्ग विधियों और super() को कॉल करने के पीछे का तंत्र हैं। अजगर के अंदर, उनकी मदद से, एक नई शैली की कक्षाएं लागू की जाती हैं, जिन्हें संस्करण 2.2 में पेश किया गया था। डिस्क्रिप्टर्स अंतर्निहित सी कोड की समझ को सरल करते हैं, और किसी भी अजगर कार्यक्रम के लिए नए उपकरणों का एक लचीला सेट भी प्रदान करते हैं।

डिस्क्रिप्टर प्रोटोकॉल

 descr.__get__(self, obj, type=None) -->  descr.__set__(self, obj, value) --> None descr.__delete__(self, obj) --> None 

वास्तव में बस इतना ही। इन विधियों में से किसी को परिभाषित करें और ऑब्जेक्ट को एक डिस्क्रिप्टर माना जाएगा, और यदि यह एक विशेषता के रूप में खोजा गया है, तो मानक व्यवहार को ओवरराइड करने में सक्षम होगा।

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

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

केवल-पढ़ने के लिए डेटा डिस्क्रिप्टर बनाने के लिए, __get__ और __set__ दोनों को परिभाषित करें, और __set__ को एक __set__ अपवाद __set__ । __set__ पद्धति को परिभाषित करना और एक अपवाद को फेंकना इस डिस्क्रिप्टर के लिए डेटा डिस्क्रिप्टर __set__ लिए पर्याप्त है।

कॉल डिस्क्रिप्टर

विवरणक को इसकी विधि के माध्यम से सीधे बुलाया जा सकता है। उदाहरण के लिए, d.__get__(obj) ।

हालांकि, किसी विशेषता को एक्सेस करते समय डिस्क्रिप्टर को कॉल करने का सबसे सामान्य संस्करण एक स्वचालित कॉल है। उदाहरण के लिए, obj.d obj शब्दकोश में d की तलाश करता है। यदि d __get__ विधि को परिभाषित करता है, तो d.__get__(obj) कहा जाएगा। नीचे वर्णित नियमों के अनुसार कॉल किया जाएगा।

कॉल विवरण क्या obj से अलग है - एक वस्तु या वर्ग। किसी भी मामले में, वर्णनकर्ता केवल एक नई शैली की वस्तुओं और कक्षाओं के लिए काम करते हैं। एक वर्ग एक नई शैली की कक्षा है यदि यह object वंशज है।

ऑब्जेक्ट के लिए, एल्गोरिथ्म को object.__getattribute__ का उपयोग करके कार्यान्वित किया जाता है, जो bx प्रविष्टि को type(b).__dict__['x'].__get__(b, type(b)) परिवर्तित करता है object.__getattribute__ type(b).__dict__['x'].__get__(b, type(b)) । कार्यान्वयन पूर्ववर्तियों की एक श्रृंखला के माध्यम से काम करता है जिसमें डेटा विवरणक ऑब्जेक्ट चर पर पूर्वता लेते हैं, ऑब्जेक्ट चर गैर-डेटा विवरणक पर वरीयता लेते हैं, और __getattr__ विधि की सबसे कम प्राथमिकता है, यदि परिभाषित किया गया है। एक पूर्ण C कार्यान्वयन PyObject_GenericGetAttr() Objects/object.c में पाया जा सकता है।

कक्षाओं के लिए, एल्गोरिथ्म type.__getattribute__ का उपयोग करके कार्यान्वित किया जाता है, जो Bx प्रविष्टि को B.__dict__['x'].__get__(None, B) परिवर्तित करता है B.__dict__['x'].__get__(None, B) । शुद्ध अजगर में, यह इस तरह दिखता है:

 def __getattribute__(self, key): " type_getattro()  Objects/typeobject.c" v = object.__getattribute__(self, key) if hasattr(v, '__get__'): return v.__get__(None, self) return v 

याद रखने के लिए महत्वपूर्ण भाग:

• वर्णनकर्ताओं को __getattribute__ विधि का उपयोग करके बुलाया जाता है
• ओवरराइडिंग __getattribute__ स्वत: डिस्क्रिप्टर कॉल __getattribute__ रोक __getattribute__
• __getattribute__ केवल नई शैली की कक्षाओं और वस्तुओं के अंदर उपलब्ध है
• object.__getattribute__ और type.__getattribute__ को अलग-अलग कॉल करें
• डेटा डिस्क्रिप्टर हमेशा ऑब्जेक्ट चर पर पूर्वता लेते हैं
• ऑब्जेक्ट चर के कारण कोई डेटा विवरणक लाभ नहीं खो सकता है

super() कॉल करने के बाद लौटी हुई वस्तु का __getattribute__ विधि का अपना कार्यान्वयन भी है, जिसके साथ वह डिस्क्रिप्टर कहता है। super(B, obj).m() कॉल obj.__class__.__mro__ बेस क्लास A obj.__class__.__mro__ दिखता है, इसके बाद B और उसके बाद A.__dict__['m'].__get__(obj, A) । यदि यह डिस्क्रिप्टर नहीं है, तो m अपरिवर्तित वापस आ m । यदि m डिक्शनरी में नहीं है, तो हम object.__getattribute__ माध्यम से खोज पर लौट object.__getattribute__ ।

नोट: python 2.2 में, super(B, obj).m() __get__ कहा जाता है, यदि केवल एक डेटा डिस्क्रिप्टर था। पाइथन 2.3 में, पुरानी शैली की कक्षाओं का उपयोग करने के अलावा कोई डेटा विवरणक भी नहीं कहा जाता है। कार्यान्वयन विवरण super_getattro() Objects/typeobject.c में पाया जा सकता है, और शुद्ध अजगर में समकक्ष गुइडो से मैनुअल में पाया जा सकता है।

ऊपर दिए गए विवरण बताते हैं कि __getattribute__() आह्वान एल्गोरिथ्म object , type और super लिए __getattribute__() पद्धति का उपयोग करके कार्यान्वित किया जाता है। जब वे object से विरासत में मिलते हैं या यदि उनके पास ऐसी कार्यप्रणाली होती है, जो इसी तरह की कार्यक्षमता को लागू करती है, तो इस एल्गोरिथ्म को कक्षाएं विरासत में मिली हैं। इस तरह, यदि वे __getattribute__() ओवरराइड करते हैं, तो कक्षाएं डिस्क्रिप्टर कॉल को बंद कर सकती हैं।

उदाहरण संभालें

निम्न कोड एक वर्ग बनाता है जिसकी वस्तुएं डेटा डिस्क्रिप्टर हैं और वे सभी करते हैं हर कॉल या set कॉल के लिए एक संदेश प्रिंट करते हैं। __getattribute__ एक वैकल्पिक दृष्टिकोण है जिसके साथ हम प्रत्येक विशेषता के लिए ऐसा कर सकते हैं। लेकिन अगर हम केवल व्यक्तिगत विशेषताओं का निरीक्षण करना चाहते हैं, तो यह एक विवरणक के साथ करना आसान है।

 class RevealAccess(object): """ ,     ,     ,     . """ def __init__(self, initval=None, name='var'): self.val = initval self.name = name def __get__(self, obj, objtype): print '', self.name return self.val def __set__(self, obj, val): print '' , self.name self.val = val >>> class MyClass(object): x = RevealAccess(10, 'var "x"') y = 5 >>> m = MyClass() >>> mx  var "x" 10 >>> mx = 20  var "x" >>> mx  var "x" 20 >>> my 5 

यह सरल प्रोटोकॉल रोमांचक संभावनाएं प्रदान करता है। उनमें से कुछ तो अक्सर उपयोग किए जाते हैं कि उन्हें अलग-अलग कार्यों में जोड़ा गया था। गुण, संबंधित और असंबंधित विधियाँ, स्थिर विधियाँ और वर्ग विधियाँ इस प्रोटोकॉल पर आधारित हैं।

गुण

property() को कॉल करने के लिए property() को कॉल करना पर्याप्त है जो विशेषता को एक्सेस करते समय आवश्यक फ़ंक्शन को कॉल करता है। यहाँ उसका हस्ताक्षर है:

 property(fget=None, fset=None, fdel=None, doc=None) --> ,   

दस्तावेज़ एक प्रबंधित विशेषता x बनाने के लिए property() का विशिष्ट उपयोग property() दिखाता है:

 class C(object): def getx(self): return self.__x def setx(self, value): self.__x = value def delx(self): del self.__x x = property(getx, setx, delx, "  'x'.") 

यहां शुद्ध अजगर पर property के बराबर है ताकि यह स्पष्ट हो कि कैसे विवरणक प्रोटोकॉल का उपयोग करके property() लागू की जाती है:

 class Property(object): " PyProperty_Type()  Objects/descrobject.c" def __init__(self, fget=None, fset=None, fdel=None, doc=None): self.fget = fget self.fset = fset self.fdel = fdel self.__doc__ = doc def __get__(self, obj, objtype=None): if obj is None: return self if self.fget is None: raise AttributeError, " " return self.fget(obj) def __set__(self, obj, value): if self.fset is None: raise AttributeError, "   " self.fset(obj, value) def __delete__(self, obj): if self.fdel is None: raise AttributeError, "   " self.fdel(obj) 

अंतर्निहित property() कार्यान्वयन property() मदद मिल सकती है जब विशेषता तक पहुंचने के लिए एक इंटरफ़ेस था और कुछ परिवर्तन हुए, जिसके परिणामस्वरूप विधि के हस्तक्षेप की आवश्यकता थी।

उदाहरण के लिए, एक स्प्रेडशीट वर्ग Cell('b10').value माध्यम से Cell('b10').value मान तक पहुंच प्रदान कर सकता है। कार्यक्रम में बाद के परिवर्तनों के परिणामस्वरूप, यह सुनिश्चित करना आवश्यक था कि सेल के एक्सेस होने पर यह मान हर बार पुनर्गणना हो, हालांकि, प्रोग्रामर क्लाइंट कोड को बदलना नहीं चाहता है जो सीधे विशेषता तक पहुंचता है। property() का उपयोग करके बनाए जाने वाले डेटा विवरणक का उपयोग करके value विशेषता को लपेटकर इस समस्या को हल किया जा सकता है:

 class Cell(object): . . . def getvalue(self, obj): "     " self.recalc() return obj._value value = property(getvalue) 

कार्य और तरीके

अजगर में, सभी वस्तु-उन्मुख विशेषताएं एक कार्यात्मक दृष्टिकोण का उपयोग करके कार्यान्वित की जाती हैं। यह गैर-डेटा विवरणकों का उपयोग करके पूरी तरह से अदृश्य रूप से किया जाता है।

क्लास डिक्शनरी मेथड को फंक्शन के तौर पर स्टोर करती है। किसी कक्षा को परिभाषित करते समय, def और lambda का उपयोग करते हुए विधियां लिखी जाती हैं, जो कार्य बनाने के लिए मानक उपकरण हैं। इन कार्यों और सामान्य लोगों के बीच एकमात्र अंतर यह है कि पहला तर्क ऑब्जेक्ट उदाहरण के लिए आरक्षित है। इस तर्क को आमतौर पर self कहा जाता है, लेकिन this या कोई अन्य शब्द कहा जा सकता है जिसका उपयोग चर नाम करने के लिए किया जा सकता है।

विधि कॉल का समर्थन करने के लिए, फ़ंक्शन में __get__ विधि शामिल __get__ है, जो विशेषताओं की खोज करते समय स्वचालित रूप से उन्हें गैर-डेटा विवरणक बनाती है। इस विवरणकर्ता के माध्यम से क्या कहा जाता है, इसके आधार पर फ़ंक्शंस बाध्य या असंबंधित तरीके से लौटते हैं।

 class Function(object): . . . def __get__(self, obj, objtype=None): " func_descr_get()  Objects/funcobject.c" return types.MethodType(self, obj, objtype) 

दुभाषिया का उपयोग करके, हम देख सकते हैं कि फ़ंक्शन डिस्क्रिप्टर वास्तव में कैसे काम करता है:

 >>> class D(object): def f(self, x): return x >>> d = D() >>> D.__dict__['f'] #     <function f at 0x00C45070> >>> Df #       <unbound method Df> >>> df #        <bound method Df of <__main__.D object at 0x00B18C90>> 

दुभाषिया का निष्कर्ष हमें बताता है कि संबंधित और असंबद्ध तरीके दो अलग-अलग प्रकार के हैं। भले ही वे इस तरह से लागू किए जा सकते हैं, वास्तव में, Objects/classobject.c में PyMethod_Type कार्यान्वयन में दो अलग-अलग मैपिंग के साथ एक एकल ऑब्जेक्ट होता है, जो केवल इस बात पर निर्भर करता है कि क्या im_self फ़ील्ड im_self मान है या यह NULL (C समतुल्य है) मान नह) ं।

इस प्रकार, एक विधि कॉल का प्रभाव im_self फ़ील्ड पर निर्भर करता है। यदि इसे स्थापित किया गया है (अर्थात विधि जुड़ा हुआ है), तो मूल फ़ंक्शन ( im_func फ़ील्ड में संग्रहीत) को कहा जाता है, जैसा कि हम उम्मीद करते हैं, ऑब्जेक्ट उदाहरण के मान पर सेट पहले तर्क के साथ। यदि यह जुड़ा नहीं है, तो सभी तर्क मूल फ़ंक्शन को बदलने के बिना पारित किए जाते हैं। instancemethod_call() वास्तविक C कार्यान्वयन थोड़ा अधिक जटिल है क्योंकि इसमें कुछ प्रकार के चेक और जैसे शामिल हैं।

स्थैतिक विधियाँ और वर्ग विधियाँ

कोई भी डेटा डिस्क्रिप्टर विधियों के लिए बाध्यकारी कार्यों के लिए विभिन्न विकल्पों के लिए एक सरल तंत्र प्रदान नहीं करता है।

फिर से दोहराएं। फ़ंक्शंस में __get__ विधि होती है, जिसके साथ वे विशेषताओं की खोज करते समय विधियाँ बन जाती हैं और स्वचालित रूप से डिस्क्रिप्टर को कॉल करती हैं। कोई भी डेटा डिस्क्रिप्टर कॉल करने के लिए obj.f(*args) को कॉल को f(obj, *args) नहीं klass.f(*args) , और klass.f(*args) को कॉल klass.f(*args) हो जाता है।

यह तालिका बंधन और दो सबसे लोकप्रिय विकल्पों को दिखाती है:

परिवर्तन		ऑब्जेक्ट के माध्यम से कहा जाता है	एक वर्ग के माध्यम से बुलाया
वर्णनकर्ता	समारोह	f (obj, * args)	f (* args)
	staticmethod	f (* args)	f (* args)
	classmethod	f (प्रकार (obj), * args)	च (क्लैश, * आर्ग्स)

स्टेटिक तरीके एक फ़ंक्शन को अपरिवर्तित लौटाते हैं। Cf या Cf object.__getattribute__(c, "f") लिए कॉल के बराबर Cf object.__getattribute__(c, "f") या object.__getattribute__(C, "f") । नतीजतन, फ़ंक्शन ऑब्जेक्ट और क्लास दोनों से समान रूप से सुलभ है।

स्थिर तरीकों के लिए अच्छे उम्मीदवार वे विधियां हैं जिनके लिए self चर के संदर्भ की आवश्यकता नहीं है।

उदाहरण के लिए, एक सांख्यिकी पैकेज में प्रायोगिक डेटा के लिए एक वर्ग शामिल हो सकता है। वर्ग औसत, अपेक्षा, मंझला और अन्य आंकड़ों की गणना के लिए सामान्य तरीके प्रदान करता है, जो डेटा पर निर्भर करता है। हालांकि, ऐसे अन्य कार्य भी हो सकते हैं जो वैचारिक रूप से संबंधित हों, लेकिन डेटा पर निर्भर न हों। उदाहरण के लिए, erf(x) एक साधारण रूपांतरण फ़ंक्शन है, जो आंकड़ों में आवश्यक है, लेकिन इस वर्ग में निर्धारित विशिष्ट डेटा पर निर्भर नहीं करता है। इसे एक वस्तु से और एक वर्ग से दोनों कहा जा सकता है: s.erf(1.5) --> 0.9332 या Sample.erf(1.5) --> 0.9332 ।

चूंकि staticmethod() अपरिवर्तित फ़ंक्शन को लौटाता है, यह उदाहरण आश्चर्यजनक नहीं है:

 >>> class E(object): def f(x): print x f = staticmethod(f) >>> print Ef(3) 3 >>> print E().f(3) 3 

यदि आप गैर-डेटा डिस्क्रिप्टर प्रोटोकॉल का उपयोग करते हैं, तो एक शुद्ध अजगर staticmethod() इस तरह दिखेगा:

 class StaticMethod(object): " PyStaticMethod_Type()  Objects/funcobject.c" def __init__(self, f): self.f = f def __get__(self, obj, objtype=None): return self.f 

स्टैटिक मेथड्स के विपरीत, फंक्शन कॉल की शुरुआत में क्लास मेथड एक क्लास रेफरेंस का विकल्प देता है। कॉल का प्रारूप हमेशा समान होता है, और यह इस बात पर निर्भर नहीं करता है कि हम किसी वस्तु के माध्यम से या किसी कक्षा के माध्यम से विधि को कहते हैं।

 >>> class E(object): def f(klass, x): return klass.__name__, x f = classmethod(f) >>> print Ef(3) ('E', 3) >>> print E().f(3) ('E', 3) 

यह व्यवहार सुविधाजनक है जब हमारे फ़ंक्शन को हमेशा कक्षा के संदर्भ की आवश्यकता होती है और इसे डेटा की आवश्यकता नहीं होती है। classmethod() का उपयोग करने का एक तरीका वैकल्पिक वर्ग निर्माणकर्ता बनाना है। पाइथन 2.3 में, क्लास मेथड dict.fromkeys() चाबियों की सूची से एक नया शब्दकोश बनाता है। शुद्ध अजगर पर बराबर होगा:

 class Dict: . . . def fromkeys(klass, iterable, value=None): " dict_fromkeys()  Objects/dictobject.c" d = klass() for key in iterable: d[key] = value return d fromkeys = classmethod(fromkeys) 

अब अद्वितीय कुंजियों का एक नया शब्दकोश इस तरह बनाया जा सकता है:

 >>> Dict.fromkeys('abracadabra') {'a': None, 'r': None, 'b': None, 'c': None, 'd': None} 

यदि आप गैर-डेटा डिस्क्रिप्टर प्रोटोकॉल का उपयोग करते हैं, तो शुद्ध पायथन classmethod() इस तरह दिखेगा:

 class ClassMethod(object): " PyClassMethod_Type()  Objects/funcobject.c" def __init__(self, f): self.f = f def __get__(self, obj, klass=None): if klass is None: klass = type(obj) def newfunc(*args): return self.f(klass, *args) return newfunc