अंदर से बाहर अजगर। ऑब्जेक्ट्स। पूंछ

1. परिचय
2. वस्तु। सिर
3. वस्तु। पूंछ
4. प्रक्रिया संरचनाएं

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

मैं पायथन के इनसाइड पर हमारे लेखों की श्रृंखला के तीसरे भाग में आपका स्वागत करता हूं (यदि आपने पहले से ऐसा नहीं किया है तो मैं दूसरे भाग को पढ़ने की दृढ़ता से सलाह देता हूं, अन्यथा आप कुछ भी नहीं समझ पाएंगे)। इस कड़ी में, हम एक महत्वपूर्ण अवधारणा के बारे में बात करेंगे, जिसे हम अभी भी विशेषताओं के बारे में नहीं जानते हैं। यदि आपने कभी पायथन में कुछ भी लिखा है, तो आपको उनका उपयोग करना था। किसी वस्तु के गुण इसके साथ जुड़ी हुई अन्य वस्तुएं हैं जो कि संचालक के माध्यम से सुलभ हैं . (अवधि), उदाहरण के लिए: >>> my_object.attribute_name । विशेषताओं का जिक्र करते समय अजगर के व्यवहार का संक्षेप में वर्णन करें। यह व्यवहार विशेषता द्वारा सुलभ वस्तु के प्रकार पर निर्भर करता है (क्या आप पहले से ही समझ चुके हैं कि यह वस्तुओं से संबंधित सभी कार्यों पर लागू होता है?)।

एक प्रकार विशेष विधियों का वर्णन कर सकता है जो इसके उदाहरणों की विशेषताओं तक पहुंच को संशोधित करता है। इन विधियों को यहां वर्णित किया गया है (जैसा कि हम पहले से ही जानते हैं, वे आवश्यक प्रकार के स्लॉट्स के साथ fixup_slot_dispatchers फ़ंक्शन के साथ, जहां प्रकार बनाया गया है ... आप पिछली पोस्ट पढ़ते हैं , ठीक है?)। ये तरीके कुछ भी कर सकते हैं; चाहे आप सी या पायथन में अपने प्रकार का वर्णन करते हैं, आप कुछ अविश्वसनीय भंडार से स्टोर और वापसी विशेषताओं को लिख सकते हैं, यदि आप चाहें, तो आप आईएसएस से रेडियो पर विशेषताओं को भेज और प्राप्त कर सकते हैं या उन्हें रिलेशनल में स्टोर कर सकते हैं। डेटाबेस। लेकिन कम या ज्यादा सामान्य परिस्थितियों में, ये विधियाँ किसी गुण शब्दकोश में गुण-मान युग्म (विशेषता नाम / गुण मान) के रूप में विशेषता को तब सेट करती हैं जब विशेषता सेट की जाती है, और इस शब्दकोष से यह विशेषता वापस लौटाई जाती है जब यह अनुरोध किया जाता है (या अपवाद फेंक दिया जाता है) AttributeError , यदि शब्दकोश में अनुरोधित विशेषता के नाम के अनुरूप कुंजी नहीं है)। यह सब इतना सरल और सुंदर है, आपके ध्यान के लिए धन्यवाद, हम शायद यहाँ समाप्त कर देंगे।

खड़ा होना ! मेरे दोस्तों, fecal जनता ने एक घूर्णन पवन जनरेटर के लिए अपने त्वरित दृष्टिकोण की शुरुआत की है। गायब होने के लिए, इसलिए सभी गायब हो जाते हैं। मैं एक साथ अध्ययन करने का प्रस्ताव करता हूं कि दुभाषिया में क्या हो रहा है और पूछते हैं, जैसा कि हम आमतौर पर करते हैं, कई कष्टप्रद प्रश्न।

हम कोड को ध्यान से पढ़ते हैं या तुरंत पाठ विवरण पर आगे बढ़ते हैं:

 >>> print(object.__dict__) {'__ne__': <slot wrapper '__ne__' of 'object' objects>, ... , '__ge__': <slot wrapper '__ge__' of 'object' objects>} >>> object.__ne__ is object.__dict__['__ne__'] True >>> o = object() >>> o.__class__ <class 'object'> >>> oa = 1 Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: 'object' object has no attribute 'a' >>> o.__dict__ Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: 'object' object has no attribute '__dict__' >>> class C: ... A = 1 ... >>> C.__dict__['A'] 1 >>> CA 1 >>> o2 = C() >>> o2.a = 1 >>> o2.__dict__ {'a': 1} >>> o2.__dict__['a2'] = 2 >>> o2.a2 2 >>> C.__dict__['A2'] = 2 Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: 'dict_proxy' object does not support item assignment >>> C.A2 = 2 >>> C.__dict__['A2'] is C.A2 True >>> type(C.__dict__) is type(o2.__dict__) False >>> type(C.__dict__) <class 'dict_proxy'> >>> type(o2.__dict__) <class 'dict'> 

इसे मानव भाषा में अनुवाद करते हैं: object (यह सबसे सरल निर्मित प्रकार है, अगर आप भूल जाते हैं), जैसा कि हम देखते हैं, एक शब्दकोश है, और जो कुछ हम विशेषताओं के माध्यम से देख सकते हैं, वह उसी चीज़ के समान है जिसे हम object.__dict__ में देखते हैं। object.__dict__ यह हमें आश्चर्यचकित करता है कि टाइप object (उदाहरण के लिए, ऑब्जेक्ट o ) के उदाहरण अतिरिक्त विशेषताओं की परिभाषा का समर्थन नहीं करते हैं और आम तौर पर __dict__ नहीं __dict__ , लेकिन मौजूदा विशेषताओं तक पहुंच का समर्थन करते हैं (प्रयास करें। o.__class__ , o.__hash__ , आदि) ये आदेश कुछ हैं; फिर वापस )। उसके बाद, हमने एक नया C वर्ग बनाया, जो उसे object से विरासत में मिला, A विशेषता को जोड़ा, और यह देखा कि यह CA और C.__dict__['A'] में सुलभ है। C.__dict__['A'] , जैसा कि अपेक्षित था। तब हमने कक्षा C का एक o2 उदाहरण बनाया और देखा कि विशेषता की परिभाषा __dict__ बदल __dict__ , और इसके विपरीत, __dict__ को बदलने से विशेषताएँ प्रभावित होती हैं। बाद में, हमें यह जानकर आश्चर्य हुआ कि __dict__ वर्ग केवल-पढ़ने के लिए है, हालांकि विशेषता परिभाषा ( C.A2 ) ठीक काम करती है । अंत में, हमने देखा कि उदाहरण और वर्ग के __dict__ ऑब्जेक्ट्स के अलग-अलग प्रकार हैं - परिचित dict_proxy और रहस्यमय ढंग से dict_proxy । और अगर यह सब पर्याप्त नहीं है, तो पिछले भाग से पहेली को याद रखें: यदि शुद्ध object के वंशज (उदाहरण के लिए, o ) के पास __dict__ नहीं है, और C बिना किसी महत्वपूर्ण चीज़ को जोड़े बिना object विस्तार करता है , तो __dict__ कक्षा वर्ग ( o2 ) के उदाहरणों से कहाँ प्रकट होता है ?

हाँ, यह अजीब और अजीब है! लेकिन चिंता मत करो, सब कुछ अपने समय है। सबसे पहले, __dict__ प्रकार के कार्यान्वयन पर विचार करें। यदि आप PyTypeObject की परिभाषा को PyTypeObject (मैं दृढ़ता से इसे पढ़ने की सलाह देता हूं!), तो आप tp_dict स्लॉट देख सकते हैं, जो एक शब्दकोश में सूचक को स्वीकार करने के लिए तैयार है। यह स्लॉट सभी प्रकार के लिए होना चाहिए। जब आप कॉल करते हैं तो शब्दकोश को वहां रखा जाता है ./Objects/typeobject.c : PyType_Ready , जो या तो तब होता है जब दुभाषिया को इनिशियलाइज़ किया जाता है ( Py_Initialize याद Py_Initialize ! यह फ़ंक्शन _Py_ReadyTypes कॉल _Py_ReadyTypes , जो सभी ज्ञात प्रकारों के लिए PyType_Ready को कॉल PyType_Ready , या जब उपयोगकर्ता डायनामिक रूप से नया गतिशील रूप से बनाता है) प्रत्येक नवजात शिशु के लिए उसकी वापसी से पहले)। वास्तव में, एक class कथन में आपके द्वारा परिभाषित प्रत्येक नाम __dict__ नए प्रकार के __dict__ में दिखाई देता है (पंक्ति ./Objects/typeobject.c : type_new : type->tp_dict = dict = PyDict_Copy(dict); यह मत भूलो कि प्रकार भी ऑब्जेक्ट हैं, अर्थात्। उनके पास एक प्रकार - type , जिसमें फ़ंक्शन के साथ स्लॉट हैं जो सही तरीके से विशेषताओं तक पहुंच प्रदान करते हैं। ये फ़ंक्शन उस शब्दकोश का उपयोग करते हैं, जिसमें प्रत्येक प्रकार के पास हैं और tp_dict अंक को स्टोर / एक्सेस करने के लिए अंक। इस प्रकार, टाइप करने के लिए एक प्रकार की विशेषता है, वास्तव में, टाइप type उदाहरण के निजी शब्दकोश के लिए एक कॉल है, जो टाइप संरचना द्वारा इंगित किया गया है।

 class Foo: bar = "baz" print(Foo.bar) 

इस उदाहरण में, अंतिम पंक्ति एक प्रकार की विशेषता को कॉल दिखाती है। इस स्थिति में, bar विशेषता को खोजने के लिए, Foo वर्ग ( tp_getattro द्वारा tp_getattro ) का विशेषता एक्सेस फ़ंक्शन कहा जाएगा। मोटे तौर पर यही बात तब होती है जब विशेषताओं को परिभाषित करना और हटाना (दुभाषिया के लिए, वैसे, "हटाना" केवल मान सेट करना NULL )। मुझे उम्मीद है कि अब तक सब कुछ स्पष्ट हो चुका है, लेकिन इस बीच हमने विशेषताओं के उपयोग पर चर्चा की है।

इंस्टेंस विशेषताओं पर विचार करने से पहले, मैं आपको एक अल्पज्ञात (लेकिन बहुत महत्वपूर्ण!) अवधारणा के बारे में बताता हूं: एक विवरणक । उदाहरण विशेषताएँ एक्सेस करते समय डिस्क्रिप्टर्स एक विशेष भूमिका निभाते हैं, और मुझे स्पष्ट करना चाहिए कि यह क्या है। एक ऑब्जेक्ट को एक डिस्क्रिप्टर माना जाता है यदि इसके प्रकार के एक या दो स्लॉट ( tp_descr_get और / या tp_descr_set ) tp_descr_set मानों से भरे होते हैं। ये स्लॉट विशेष विधियों __get__ , __set__ और __delete__ (उदाहरण के लिए, यदि आप __get__ विधि के साथ एक वर्ग को परिभाषित करते हैं जो tp_descr_get स्लॉट से संपर्क करेगा और इस वर्ग का एक ऑब्जेक्ट बनाएगा, तो यह ऑब्जेक्ट डिस्क्रिप्टर होगा)। अंत में, किसी ऑब्जेक्ट को डेटा डिस्क्रिप्टर माना जाता है यदि tp_descr_set स्लॉट tp_descr_set मान से भरा हो। जैसा कि हम देखेंगे, वर्णनकर्ता विशेषताओं तक पहुँचने में महत्वपूर्ण भूमिका निभाते हैं, और मैं आवश्यक प्रलेखन के लिए कुछ और स्पष्टीकरण और लिंक दूंगा।

इसलिए, हमने यह पता लगाया कि वर्णनकर्ता क्या हैं और महसूस किया कि प्रकार की विशेषताओं तक कैसे पहुँच होती है। लेकिन अधिकांश वस्तुएं प्रकार नहीं हैं, अर्थात्। उनका प्रकार टाइप नहीं है, लेकिन कुछ और अधिक सामान्य है, उदाहरण के लिए, int , dict या एक कस्टम वर्ग। वे सभी उन विशेषताओं तक पहुंचने के लिए सार्वभौमिक कार्यों पर भरोसा करते हैं जो या तो प्रकार में परिभाषित होते हैं या जब इसे बनाया गया था, तो यह उस प्रकार का मूल जनक से विरासत में मिला है (यह विषय, स्लॉट की विरासत, हमने " हेड " में चर्चा की है)। अभिगम विशेषताओं के सार्वभौमिक कार्य का एल्गोरिथ्म ( PyObject_GenericGetAttr ) इस तरह दिखता है:

1. उदाहरण प्रकार शब्दकोश में और सभी प्रकार के माता-पिता के शब्दकोश में खोजें। यदि कोई डेटा डिस्क्रिप्टर पाया जाता है, तो उसके tp_descr_get फ़ंक्शन को कॉल करें और परिणाम लौटाएं। यदि कुछ और पाया जाता है, तो इसे केवल मामले में याद रखें (उदाहरण के लिए, एक्स नाम के तहत)।
2. ऑब्जेक्ट के शब्दकोश में खोजें और परिणाम मिलने पर वापस कर दें।
3. यदि ऑब्जेक्ट के शब्दकोश में कुछ भी नहीं मिला था, तो इसे स्थापित करने पर एक्स की जांच करें; यदि X डिस्क्रिप्टर है, तो उसके tp_descr_get फ़ंक्शन को कॉल करें और परिणाम लौटाएं। यदि X एक सामान्य वस्तु है, तो उसे वापस कर दें।
4. अंत में, अगर कुछ भी नहीं मिला, तो एक AttributeError अपवाद को फेंक दें।

अब हमने महसूस किया कि विवरणकर्ता गुण के रूप में एक्सेस किए जाने पर कोड निष्पादित कर सकते हैं (यानी जब आप foo = oa या oa = foo लिखते हैं, तो कोड निष्पादित करता है)। शक्तिशाली कार्यक्षमता जो पायथन के कुछ "जादू" सुविधाओं को लागू करने के लिए उपयोग की जाती है। डेटा डिस्क्रिप्टर और भी अधिक शक्तिशाली होते हैं क्योंकि वे इंस्टेंस विशेषताओं पर वरीयता लेते हैं (यदि आपके पास क्लास C o ऑब्जेक्ट o C , क्लास C में डेटा डिस्क्रिप्टर foo , और o में एक विशेषता foo , तो जब o.foo निष्पादित किया जाता है o.foo परिणाम एक विवरणक लौटाएगा)। वर्णनकर्ता क्या हैं और कैसे पढ़ें। मैं विशेष रूप से पहले लिंक ("क्या") की सलाह देता हूं - इस तथ्य के बावजूद कि पहले तो लेखन हतोत्साहित कर रहा है, सावधान और विचारशील पढ़ने के बाद आपको एहसास होगा कि यह मेरी बात से बहुत सरल और छोटा है। आपको रेमंड हेटिंगर के भयानक लेख को भी पढ़ना चाहिए जो पायथन 2.x में वर्णनकर्ताओं का वर्णन करता है ; असंबंधित तरीकों को हटाने के अलावा, लेख अभी भी संस्करण 3.x के लिए प्रासंगिक है और पढ़ने के लिए अनुशंसित है। डिस्क्रिप्टर्स एक बहुत महत्वपूर्ण अवधारणा है, और मैं आपको सलाह देता हूं कि सूचीबद्ध संसाधनों का अध्ययन करने के लिए उन्हें समझने और विचार से प्रेरित होने के लिए कुछ समय समर्पित करें। यहाँ, संक्षिप्तता के लिए, मैं अब विवरण में नहीं जाऊंगा, लेकिन मैं दुभाषिया में उनके व्यवहार का एक उदाहरण ( बहुत सरल) दूंगा:

 >>> class ShoutingInteger(int): ... # __get__   tp_descr_get ... def __get__(self, instance, owner): ... print('I was gotten from %s (instance of %s)' ... % (instance, owner)) ... return self ... >>> class Foo: ... Shouting42 = ShoutingInteger(42) ... >>> foo = Foo() >>> 100 - foo.Shouting42 I was gotten from <__main__.Foo object at 0xb7583c8c> (instance of <class __main__.'foo'>) 58 # :     ! >>> foo.Silent666 = ShoutingInteger(666) >>> 100 - foo.Silent666 -566 >>> 

मैं ध्यान देता हूं कि हमने पायथन में ऑब्जेक्ट-ओरिएंटेड इनहेरिटेंस की पूरी समझ हासिल की है: विशेषताओं की खोज वस्तु के प्रकार से शुरू होती है, और फिर सभी माता-पिता में, हम समझते हैं कि कक्षा C1 A ऑब्जेक्ट O विशेषता A तक पहुँचना, जो C2 से विरासत में मिला है, जो बदले में C3 से विरासत में मिला है, O और C1 दोनों से A वापस कर सकता है, और C2 और C3 , जो विधि संकल्प के एक निश्चित क्रम से निर्धारित होता है, जिसे यहां अच्छी तरह से वर्णित किया गया है । स्लॉट इनहेरिटेंस के साथ विशेषताओं को हल करने का यह तरीका पायथन में अधिकांश वंशागत कार्यक्षमता की व्याख्या करने के लिए पर्याप्त है (हालांकि, शैतान हमेशा की तरह, विवरण में है)।

हमने आज बहुत कुछ सीखा, लेकिन यह अभी भी स्पष्ट नहीं है कि ऑब्जेक्ट शब्दकोशों के लिंक कहां संग्रहीत हैं। हमने पहले ही PyObject की परिभाषा देखी है, और निश्चित रूप से एक समान शब्दकोश के लिए कोई संकेतक नहीं है। अगर नहीं है, तो कहाँ? उत्तर अप्रत्याशित है। यदि आप ध्यान से PyTypeObject को PyTypeObject (यह एक अच्छा शगल है! दैनिक पढ़ें!), आपको एक क्षेत्र दिखाई देगा जिसे tp_dictoffset कहा जाता है। यह क्षेत्र प्रकार के उदाहरणों के लिए आवंटित सी-संरचनाओं में बाइट ऑफसेट को परिभाषित करता है; इस ऑफसेट पर एक नियमित पायथन शब्दकोश के लिए एक सूचक है। सामान्य परिस्थितियों में, एक नया प्रकार बनाते समय, प्रकार के उदाहरणों के लिए आवश्यक स्मृति के टुकड़ों के आकार की गणना की जाएगी, और यह आकार शुद्ध PyObject तुलना में बड़ा होगा। एक शब्दकोश के लिए एक पॉइंटर को स्टोर करने के लिए अतिरिक्त (आमतौर पर अन्य चीजों के बीच) का उपयोग किया जाता है (यह सब इसमें होता है। ./Objects/typeobject.c : type_new , लाइन से पढ़े जा सकते हैं may_add_dict = base->tp_dictoffset == 0; )। gdb का उपयोग करके , हम आसानी से इस स्थान को तोड़ सकते हैं और ऑब्जेक्ट के निजी शब्दकोश को देख सकते हैं:

 >>> class C: pass ... >>> o = C() >>> o.foo = 'bar' >>> o <__main__.C object at 0x846b06c> >>> #   GDB Program received signal SIGTRAP, Trace/breakpoint trap. 0x0012d422 in __kernel_vsyscall () (gdb) p ((PyObject *)(0x846b06c))->ob_type->tp_dictoffset $1 = 16 (gdb) p *((PyObject **)(((char *)0x846b06c)+16)) $3 = {u'foo': u'bar'} (gdb) 

हमने एक नया वर्ग, एक ऑब्जेक्ट बनाया और इसकी विशेषता ( o.foo = 'bar' ) निर्धारित की, gdb प्रवेश किया, ऑब्जेक्ट प्रकार ( C ) को dereferenced और इसे tp_dictoffset (16) पाया, और फिर जाँच की कि इस ऑफसेट में क्या है वस्तु की सी-संरचना। आश्चर्य की बात नहीं है, हमने एक प्रमुख foo साथ एक वस्तु शब्दकोश पाया, जो bar के मूल्य को दर्शाता है। स्वाभाविक रूप से, अगर हम tp_dictoffset प्रकार के tp_dictoffset जांच करते हैं, tp_dictoffset नहीं है, उदाहरण के लिए, object , हम वहां शून्य पाते हैं। Goosebumps, हुह?

तथ्य यह है कि प्रकार और उदाहरण के शब्दकोश समान हैं, लेकिन उनके कार्यान्वयन बहुत भिन्न होते हैं, भ्रामक हो सकते हैं। कुछ और रहस्य बने हुए हैं। आइए संक्षेप करें और निर्धारित करें कि हम क्या चूक गए: हम एक खाली वर्ग C को परिभाषित करते हैं जो object से विरासत में मिला है, इस वर्ग o एक ऑब्जेक्ट o बनाएं, अतिरिक्त मेमोरी को ऑफसेट tp_dictoffset द्वारा डिक्शनरी के लिए आवंटित किया जाता है (स्थान बहुत शुरुआत से आवंटित किया गया है, लेकिन शब्दकोश केवल पहले (किसी भी) में आवंटित किया गया है संभालना, यहाँ बदमाश हैं ...)। तब हम o.__dict__ में निष्पादित o.__dict__ , LOAD_ATTR को LOAD_ATTR कमांड के साथ संकलित किया जाता है, जो PyObject_GetAttr फ़ंक्शन को कॉल करता है, जो ऑब्जेक्ट प्रकार o dereferens करता है और tp_getattro स्लॉट को ढूँढता है, जो ऊपर वर्णित मानक विशेषता खोज प्रक्रिया शुरू करता है और PyObject_GenericGetAttr । नतीजतन, यह सब होने के बाद, हमारी वस्तु का शब्दकोश क्या है? हम जानते हैं कि डिक्शनरी कहाँ संग्रहीत है, लेकिन आप देख सकते हैं कि __dict__ यह नहीं है, इसलिए चिकन और अंडे की समस्या उत्पन्न होती है: जब हम डिक्शनरी में नहीं आते हैं तो डिक्शनरी हमारे पास वापस कैसे __dict__ है?

किसी वस्तु के शब्दकोश पर पूर्वता बरतने वाली चीज एक संभाल है। देखें:

 >>> class C: pass ... >>> o = C() >>> o.__dict__ {} >>> C.__dict__['__dict__'] <attribute '__dict__' of 'C' objects> >>> type(C.__dict__['__dict__']) <class 'getset_descriptor'> >>> C.__dict__['__dict__'].__get__(o, C) {} >>> C.__dict__['__dict__'].__get__(o, C) is o.__dict__ True >>> 

वाह! यह देखा जा सकता है कि getset_descriptor (file ./Objects/typeobject.c ) नामक कुछ कार्य, फ़ंक्शन के एक निश्चित समूह है जो डिस्क्रिप्टर प्रोटोकॉल को लागू करता है, और जो __dict__ ऑब्जेक्ट में होना चाहिए। यह डिस्क्रिप्टर इस प्रकार के o.__dict__ वस्तुओं तक पहुंचने के सभी प्रयासों को रोक देगा और वह सब कुछ वापस करेगा जो वह चाहता है, हमारे मामले में, यह o में ऑफसेट tp_dictoffset द्वारा डिक्शनरी का सूचक होगा। इससे यह भी पता dict_proxy कि हमने थोड़ी देर पहले dict_proxy क्यों की। यदि tp_dict में एक सरल शब्दकोश के लिए एक सूचक है, तो हम इसे किसी ऐसी वस्तु में क्यों tp_dict हैं जिसमें कुछ भी लिखना असंभव है? यह __dict__ प्रकार के हैंडल को बनाता है।

 >>> type(C) <class 'type'> >>> type(C).__dict__['__dict__'] <attribute '__dict__' of 'type' objects> >>> type(C).__dict__['__dict__'].__get__(C, type) <dict_proxy object at 0xb767e494> 

यह हैंडल एक फ़ंक्शन है जो एक शब्दकोश को एक साधारण वस्तु के साथ लपेटता है जो एक नियमित शब्दकोश के व्यवहार को अनुकरण करता है सिवाय इसके कि यह केवल पढ़ने के लिए है। __dict__ प्रकार में उपयोगकर्ता के हस्तक्षेप को रोकना इतना महत्वपूर्ण क्यों है? क्योंकि प्रकार नामस्थान में विशेष विधियाँ हो सकती हैं, उदाहरण के लिए __sub__ । जब हम विशेष विधियों के साथ एक प्रकार बनाते हैं, या जब हम उन्हें विशेषताओं के माध्यम से प्रकार पर परिभाषित करते हैं, तो update_one_slot फ़ंक्शन update_one_slot , जो इन विधियों को प्रकार स्लॉट के साथ जोड़ देगा, उदाहरण के लिए, जैसा कि पिछले पोस्ट में घटाव ऑपरेशन के साथ हुआ था। यदि हम इन विधियों को सीधे __dict__ प्रकार में जोड़ सकते हैं, तो वे स्लॉट्स के साथ संबद्ध नहीं होंगे, और हमें एक प्रकार मिलेगा जो हमें चाहिए (उदाहरण के लिए, इसके शब्दकोश में __sub__ है), लेकिन जो अलग तरह से व्यवहार करता है ।

हमने लंबे समय तक 2000 शब्दों की रेखा पार कर ली है, जिसके आगे पाठक का ध्यान तेजी से मर रहा है, और मैंने अभी भी __slots__ बारे में बात नहीं की है। कैसे अपने दम पर पढ़ने के बारे में, साहसी? आपके निपटान में उनके साथ अकेले निपटने के लिए सब कुछ है! निर्दिष्ट लिंक पर दस्तावेज़ पढ़ें, दुभाषिया में __slots__ साथ थोड़ा __slots__ , स्रोतों को देखें और उन्हें gdb माध्यम से देखें। मजा आ गया। अगली श्रृंखला में, मुझे लगता है कि हम कुछ समय के लिए वस्तुओं को छोड़ देंगे और दुभाषिया की स्थिति और धारा की स्थिति के बारे में बात करेंगे। मुझे उम्मीद है कि यह दिलचस्प होगा। लेकिन अगर वह नहीं करता है, तब भी आपको यह जानना होगा। मैं निश्चित रूप से कह सकता हूं कि लड़कियां उन लोगों को बहुत पसंद करती हैं जो ऐसे मामलों में पारंगत हैं।

जानते हो क्या? सिर्फ लड़कियां ही नहीं। हम भी इन लोगों को पसंद करते हैं। आओ और साथ में मस्ती करो।