🍭 💦 📲 पायथन में प्रोटोकॉल को संभालना और संभालना 🔚 ⛹🏻 👨🏽‍✈️

निम्नलिखित कोड पर विचार करें:

class Foo: def __init__(self): self.bar = 'hello!' foo = Foo() print(foo.bar)

आज हम प्रश्न के उत्तर का विश्लेषण करेंगे: "जब हम foo.bar लिखते हैं तो वास्तव में क्या होता है?"

आप पहले ही जान सकते हैं कि अधिकांश वस्तुओं में एक आंतरिक __dict__ शब्दकोश होता है जिसमें उनकी सभी विशेषताएँ होती हैं। और क्या विशेष रूप से प्रसन्न है कि पायथन में इस तरह के निम्न-स्तरीय विवरणों का अध्ययन करना कितना आसान है:

 >>> foo = Foo() >>> foo.__dict__ {'bar': 'hello!'}

आइए इसकी (अधूरी) परिकल्पना तैयार करने की कोशिश शुरू करें:

foo.bar foo .__ के समान है। हुकुम __ ['बार'] ।

जबकि यह सच लगता है:

 >>> foo = Foo() >>> foo.__dict__['bar'] 'hello!'

अब मान लीजिए कि आप पहले से ही जानते हैं कि गतिशील विशेषताओं को कक्षाओं में घोषित किया जा सकता है :

 >>> class Foo: ... def __init__(self): ... self.bar = 'hello!' ... ... def __getattr__(self, item): ... return 'goodbye!' ... ... foo = Foo() >>> foo.bar 'hello!' >>> foo.baz 'goodbye!' >>> foo.__dict__ {'bar': 'hello!'}

हम्म ... ठीक है। यह देखा जा सकता है कि __getattr__ "नकली" विशेषताओं तक पहुंच का अनुकरण कर सकता है, लेकिन अगर पहले से ही घोषित चर (जैसे foo.bar कि 'हैलो!' और 'अलविदा नहीं ' ) काम नहीं करेगा। लगता है सब कुछ शुरू से ही थोड़ा अधिक जटिल था।

और वास्तव में: एक जादू पद्धति है जिसे कहा जाता है जब भी हम एक विशेषता प्राप्त करने की कोशिश करते हैं, लेकिन, जैसा कि ऊपर दिए गए उदाहरण से पता चलता है, यह __getattr__ नहीं है। इस विधि को __getattribute__ कहा जाता है, और हम यह समझने की कोशिश करेंगे कि विभिन्न स्थितियों को देखकर यह वास्तव में कैसे काम करता है।

अब तक, हम अपनी परिकल्पना को इस प्रकार संशोधित करते हैं:

foo.bar foo .__ getattribute __ ('बार') के बराबर है, जो लगभग इसी तरह काम करता है:
 def __getattribute__(self, item): if item in self.__dict__: return self.__dict__[item] return self.__getattr__(item) 

हम इसे इस विधि को लागू करने (एक अलग नाम के तहत) और इसे सीधे कॉल करके इसका परीक्षण करेंगे:

 >>> class Foo: ... def __init__(self): ... self.bar = 'hello!' ... ... def __getattr__(self, item): ... return 'goodbye!' ... ... def my_getattribute(self, item): ... if item in self.__dict__: ... return self.__dict__[item] ... return self.__getattr__(item) >>> foo = Foo() >>> foo.bar 'hello!' >>> foo.baz 'goodbye!' >>> foo.my_getattribute('bar') 'hello!' >>> foo.my_getattribute('baz') 'goodbye!'

सही लगता है, है ना?

खैर, जो कुछ भी शेष है वह सत्यापित करना है कि चर का कार्य समर्थित है, जिसके बाद आप घर जा सकते हैं ... -

 >>> foo.baz = 1337 >>> foo.baz 1337 >>> foo.my_getattribute('baz') = 'h4x0r' SyntaxError: can't assign to function call

अरे।

my_getattribute किसी ऑब्जेक्ट को लौटाता है। यदि यह परिवर्तनशील है तो हम इसे बदल सकते हैं, लेकिन हम असाइनमेंट ऑपरेटर का उपयोग करके इसे दूसरे के साथ प्रतिस्थापित नहीं कर सकते। क्या करें? आखिरकार, अगर foo.baz किसी फ़ंक्शन को कॉल करने के बराबर है, तो हम सिद्धांत में एक विशेषता को एक नया मान कैसे दे सकते हैं?

जब हम foo.bar = 1 जैसी अभिव्यक्ति को देखते हैं , तो foo.bar के मान को प्राप्त करने के लिए केवल एक फ़ंक्शन को कॉल करने की तुलना में यह अधिक है। किसी विशेषता के लिए मान निर्दिष्ट करना एक गुण मान प्राप्त करने से मौलिक रूप से भिन्न प्रतीत होता है। और सच्चाई: हम इसे देखने के लिए __setattr__ को लागू कर सकते हैं:

 >>> class Foo: ... def __init__(self): ... self.__dict__['my_dunder_dict'] = {} ... self.bar = 'hello!' ... ... def __setattr__(self, item, value): ... self.my_dunder_dict[item] = value ... ... def __getattr__(self, item): ... return self.my_dunder_dict[item] >>> foo = Foo() >>> foo.bar 'hello!' >>> foo.bar = 'goodbye!' >>> foo.bar 'goodbye!' >>> foo.baz Traceback (most recent call last): File "<pyshell#75>", line 1, in <module> foo.baz File "<pyshell#70>", line 10, in __getattr__ return self.my_dunder_dict[item] KeyError: 'baz' >>> foo.baz = 1337 >>> foo.baz 1337 >>> foo.__dict__ {'my_dunder_dict': {'bar': 'goodbye!', 'baz': 1337}}

इस कोड के बारे में ध्यान देने योग्य बातें:

__setattr__ का __getattribute__ के लिए कोई समकक्ष नहीं है (यानी, जादू __setattribute__ विधि मौजूद नहीं है)।
__setattr__ को __init__ के अंदर कहा जाता है, यही वजह है कि हम स्वयं करने के लिए मजबूर हैं ।__ तानाशाही __ ['my_dunder_dict'] = {} के बजाय self.my_dunder_dict = {} । अन्यथा, हम अनंत पुनरावृत्ति का सामना करेंगे।

लेकिन हमारे पास संपत्ति (और उसके दोस्त) भी हैं। एक डेकोरेटर जो विधियों को विशेषताओं के रूप में कार्य करने की अनुमति देता है।

आइए समझने की कोशिश करें कि यह कैसे होता है।

 >>> class Foo(object): ... def __getattribute__(self, item): ... print('__getattribute__ was called') ... return super().__getattribute__(item) ... ... def __getattr__(self, item): ... print('__getattr__ was called') ... return super().__getattr__(item) ... ... @property ... def bar(self): ... print('bar property was called') ... return 100 >>> f = Foo() >>> f.bar __getattribute__ was called bar property was called

बस मज़े के लिए, हमारे पास f .__ तानाशाही में क्या है?

 >>> f.__dict__ __getattribute__ was called {}

__Dict__ में कोई बार कुंजी नहीं है, लेकिन __getattr__ को किसी कारण से नहीं बुलाया जाता है। WAT?

बार एक ऐसी विधि है जो स्वयं को एक पैरामीटर के रूप में भी लेती है, केवल यह विधि कक्षा में है, न कि कक्षा के उदाहरण में। और यह देखना आसान है:

 >>> Foo.__dict__ mappingproxy({'__dict__': <attribute '__dict__' of 'Foo' objects>, '__doc__': None, '__getattr__': <function Foo.__getattr__ at 0x038308A0>, '__getattribute__': <function Foo.__getattribute__ at 0x038308E8>, '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'Foo' objects>, 'bar': <property object at 0x0381EC30>})

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

 >>> f.__dict__['bar'] = 'will we see this printed?' __getattribute__ was called >>> f.bar __getattribute__ was called bar property was called 100

यह देखा जा सकता है कि सत्यापन __dict__ वर्ग में पहली चीज़ है, अर्थात उदाहरण के लिए यह प्राथमिकता है।

एक मिनट रुको, हमने बार विधि को कब कहा? मेरा मतलब है, __getattribute__ के लिए हमारा छद्म कोड कभी भी ऑब्जेक्ट नहीं कहता है। क्या चल रहा है?

डिस्क्रिप्टर प्रोटोकॉल से मिलें:

descr .__ get __ (self, obj, type = none) -> मान

descr .__ सेट __ (स्वयं, obj, मूल्य) -> कोई नहीं

descr .__ delete __ (self, obj) -> कोई नहीं

पूरे बिंदु यहाँ है। इन तीन तरीकों में से किसी को भी लागू करें ताकि ऑब्जेक्ट एक डिस्क्रिप्टर बन जाए और एक विशेषता के रूप में व्यवहार किए जाने पर डिफ़ॉल्ट व्यवहार को बदल सके।

यदि कोई वस्तु __get __ () और __set __ () दोनों को घोषित करती है, तो इसे डेटा डिस्क्रिप्टर कहा जाता है। डिस्क्रिप्टर्स जो केवल __get __ () को लागू करते हैं, उन्हें गैर-डेटा विवरणक कहा जाता है।

दोनों प्रकार के वर्णनकर्ता अलग-अलग होते हैं कि वस्तु विशेषता शब्दकोश के तत्व कैसे लिखे जाते हैं। यदि शब्दकोश में डेटा डिस्क्रिप्टर के समान नाम वाली कुंजी है, तो डेटा डिस्क्रिप्टर पूर्वता लेता है (यानी, __set __ () कहा जाता है)। यदि डिक्शनरी में डेटा के बिना डिस्क्रिप्टर के समान नाम के साथ एक कुंजी है, तो डिक्शनरी में प्राथमिकता है (यानी, शब्दकोश तत्व अधिलेखित है)।

रीड-ओनली डेटा डिस्क्रिप्टर बनाने के लिए, __get __ () और __set __ () , जहां __set __ () एट्रिब्यूट एरो कहते हैं , को घोषित करें। डेटा डिस्क्रिप्टर बनाने के लिए इस __set __ () को लागू करना पर्याप्त है।

संक्षेप में, यदि आपने इनमें से कोई भी तरीका __get__ , __set__ या __delete__ घोषित किया है, तो आपने डिस्क्रिप्टर प्रोटोकॉल के लिए समर्थन लागू किया है। और यह वही है जो संपत्ति डेकोरेटर करता है: यह एक रीड-ओनली डिस्क्रिप्टर घोषित करता है जिसे __getattribute__ कहा जाएगा।

हमारे कार्यान्वयन में अंतिम परिवर्तन:

foo.bar foo .__ getattribute __ ('बार') के बराबर है, जो मोटे तौर पर इस तरह काम करता है:
 def __getattribute__(self, item): if item in self.__class__.__dict__: v = self.__class__.__dict__[item] elif item in self.__dict__: v = self.__dict__[item] else: v = self.__getattr__(item) if hasattr(v, '__get__'): v = v.__get__(self, type(self)) return v 

आइए अभ्यास में प्रदर्शित करने का प्रयास करें:

 class Foo: class_attr = "I'm a class attribute!" def __init__(self): self.dict_attr = "I'm in a dict!" @property def property_attr(self): return "I'm a read-only property!" def __getattr__(self, item): return "I'm dynamically returned!" def my_getattribute(self, item): if item in self.__class__.__dict__: print('Retrieving from self.__class__.__dict__') v = self.__class__.__dict__[item] elif item in self.__dict__: print('Retrieving from self.__dict__') v = self.__dict__[item] else: print('Retrieving from self.__getattr__') v = self.__getattr__(item) if hasattr(v, '__get__'): print("Invoking descriptor's __get__") v = v.__get__(self, type(self)) return v

 >>> foo = Foo() ... ... print(foo.class_attr) ... print(foo.dict_attr) ... print(foo.property_attr) ... print(foo.dynamic_attr) ... ... print() ... ... print(foo.my_getattribute('class_attr')) ... print(foo.my_getattribute('dict_attr')) ... print(foo.my_getattribute('property_attr')) ... print(foo.my_getattribute('dynamic_attr')) I'm a class attribute! I'm in a dict! I'm a read-only property! I'm dynamically returned! Retrieving from self.__class__.__dict__ I'm a class attribute! Retrieving from self.__dict__ I'm in a dict! Retrieving from self.__class__.__dict__ Invoking descriptor's __get__ I'm a read-only property! Retrieving from self.__getattr__ I'm dynamically returned!

हमने सिर्फ पायथन में विशेषता कार्यान्वयन की सतह को थोड़ा खरोंच दिया। यद्यपि foo.bar का अनुकरण करने का हमारा अंतिम प्रयास आम तौर पर सही है, लेकिन ध्यान रखें कि हमेशा अलग-अलग लागू किए गए छोटे विवरण हो सकते हैं।

मुझे आशा है कि यह जानने के अलावा कि कैसे विशेषताएँ काम करती हैं, मैं उस भाषा की सुंदरता को व्यक्त करने में कामयाब रहा जो आपको प्रयोग करने के लिए प्रोत्साहित करती है। आज ज्ञान का कुछ कर्ज चुका दो।

पायथन में प्रोटोकॉल को संभालना और संभालना

More articles: