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

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

हम पायथन के इनसाइड को समझना जारी रखते हैं। पिछली बार हमने सीखा कि पायथन एक सरल कार्यक्रम को कैसे पचाता है। आज हम इसकी वस्तु प्रणाली के उपकरण का अध्ययन शुरू करते हैं।

जैसा कि मैंने पिछले एपिसोड में लिखा था (जो संयोगवश सफल हो गया था; हर किसी के लिए धन्यवाद, आपके विचार और टिप्पणियां मुझे सचमुच चलती हैं!) - आज की पोस्ट पाइथन 3.x में वस्तुओं के कार्यान्वयन के लिए समर्पित है। पहले मुझे लगा कि यह एक साधारण विषय है। लेकिन यहां तक ​​कि जब मैं एक पोस्ट लिखने से पहले मेरे द्वारा पढ़े गए सभी कोड पढ़ता हूं, तो मैं शायद ही कह सकता हूं कि पायथन ऑब्जेक्ट सिस्टम ... उम, "सरल" (और मैं निश्चित रूप से यह नहीं कह सकता कि मैंने इसे पूरी तरह से समझा है)। लेकिन मैं और भी आश्वस्त हो गया कि वस्तुओं का कार्यान्वयन एक अच्छा विषय है जिसके साथ शुरू करना है। अगले पोस्ट में हम देखेंगे कि यह कितना महत्वपूर्ण है। उसी समय, मुझे कुछ लोगों पर शक है, यहां तक ​​कि पायथन दिग्गजों के बीच भी, इसे पूरी तरह से समझते हैं। ऑब्जेक्ट्स बाकी सब चीज़ों से जुड़े हुए हैं, जब पायथन (पोस्ट लिखते समय, मैंने थोड़ा सा देखा ./Python और अध्ययन किया ./Objects और ./Include )। वस्तुओं के क्रियान्वयन पर विचार करना मुझे आसान लग रहा था जैसे कि यह सब कुछ के साथ बिल्कुल भी जुड़ा नहीं था। जैसे कि यह सबसिस्टम बनाने के लिए एक सार्वभौमिक सी एपीआई था। शायद इस तरह से सोचना भी आपके लिए आसान होगा: याद रखें, यह सब इन संरचनाओं के प्रबंधन के लिए संरचनाओं और कार्यों का एक सेट है।

पायथन में सब कुछ एक वस्तु है: संख्या, शब्दकोश, कस्टम और अंतर्निहित कक्षाएं, स्टैक फ्रेम और कोड ऑब्जेक्ट। किसी ऑब्जेक्ट को माना जाने वाले मेमोरी स्थान के लिए एक पॉइंटर के लिए, कम से कम दो फ़ील्ड आवश्यक हैं जो संरचना में परिभाषित किए गए हैं ./Include/object.h : PyObject :

 typedef struct _object { Py_ssize_t ob_refcnt; struct _typeobject *ob_type; } PyObject; 

कई ऑब्जेक्ट्स आवश्यक फ़ील्ड को जोड़कर इस संरचना का विस्तार करते हैं, लेकिन ये दो फ़ील्ड किसी भी स्थिति में मौजूद होनी चाहिए: संदर्भ गणना और प्रकार (लिंक को ट्रैक करने के लिए विशेष डीबग बिल्ड में कुछ रहस्यमय फ़ील्ड जोड़े जाते हैं)।

एक संदर्भ काउंटर एक संख्या है जो इंगित करती है कि कितनी बार अन्य ऑब्जेक्ट इस एक को संदर्भित करते हैं। कोड में >>> a = b = c = object() , एक खाली ऑब्जेक्ट को तीन अलग-अलग नामों से शुरू और संबद्ध किया जाता है: a , b और c । प्रत्येक नाम ऑब्जेक्ट के लिए एक नई लिंक बनाता है, लेकिन ऑब्जेक्ट एक बार बनाया जाता है। किसी वस्तु को नए नाम से जोड़ना या वस्तु को सूची में जोड़ना एक नई कड़ी बनाता है, लेकिन एक नई वस्तु नहीं बनाता है! इस विषय पर अभी बहुत कुछ कहा जाना बाकी है, लेकिन यह वस्तु प्रणाली की तुलना में कचरा संग्रहण से अधिक संबंधित है। मैं इस प्रश्न के बारे में यहाँ बताने के बजाय, इसके बारे में एक अलग पोस्ट लिखूंगा। लेकिन, इस विषय को छोड़ने से पहले, मैं कहता हूं कि अब हमारे लिए मैक्रो को समझना आसान हो गया है ./Include/object.h : Py_DECREF , जिसे हम पहले भाग में मिले थे: यह सिर्फ ob_refcnt (और यदि ob_refcnt शून्य मान लेता है) को मुक्त करता है । अभी के लिए, आइए संदर्भ गणना को समाप्त करते हैं।

यह ob_type टाइप करने के लिए बना रहता है, ऑब्जेक्ट के प्रकार के लिए एक संकेतक, पायथन ऑब्जेक्ट मॉडल की केंद्रीय अवधारणा (ध्यान में रखें: तीसरे पायथन में, प्रकार और वर्ग अनिवार्य रूप से समान हैं; ऐतिहासिक कारणों के लिए, इन शब्दों का उपयोग संदर्भ पर निर्भर करता है)। प्रत्येक ऑब्जेक्ट में केवल एक ही प्रकार होता है जो ऑब्जेक्ट के जीवन के दौरान नहीं बदलता है (प्रकार अत्यंत दुर्लभ परिस्थितियों में बदल सकता है। इस कार्य के लिए कोई एपीआई नहीं है, और यदि आप बदलते प्रकारों के साथ वस्तुओं के साथ काम करते हैं तो आप शायद ही इस लेख को पढ़ेंगे)। शायद अधिक महत्वपूर्ण बात, वस्तु का प्रकार (और केवल वस्तु का प्रकार) निर्धारित करता है कि इसके साथ क्या किया जा सकता है (इस पैराग्राफ के बाद स्पॉइलर में एक उदाहरण)। जैसा कि आप पहले भाग से याद करते हैं, जब घटाव ऑपरेशन करते हैं, तो समान फ़ंक्शन को ऑपरेंड के प्रकार की परवाह किए बिना ( PyNumber_Subtract ) कहा जाता है: पूर्णांकों के लिए, पूर्णांक और भिन्नात्मक के लिए, या यहां तक ​​कि पूर्ण अनुपस्थिति के लिए, जैसे कि शब्दकोष से अपवाद को घटाना।


पहली बार में यह अजीब लगता है। एक एकल फ़ंक्शन किसी भी तरह की वस्तुओं को कैसे पारित कर सकता है? यह एक void * सूचक प्राप्त कर सकता है (वास्तव में, यह एक PyObject * सूचक प्राप्त करता है, जो डेटा के संबंध में अपारदर्शी भी है), लेकिन यह कैसे निर्धारित करेगा कि प्राप्त तर्क के साथ क्या करना है? उत्तर वस्तु के प्रकार में निहित है। एक प्रकार भी एक वस्तु है (इसमें एक संदर्भ संख्या और इसका अपना प्रकार है; अधिकांश प्रकार का type ), लेकिन दो मुख्य क्षेत्रों के अलावा, इसमें कई अन्य फ़ील्ड शामिल हैं। यहां इसके खेतों की संरचना की परिभाषा और विवरण का अध्ययन करें । परिभाषा में ही है ./Include/object.h : PyTypeObject । जैसा कि आप लेख पढ़ते हैं, मैं उसे संदर्भित करने की सलाह देता हूं। एक प्रकार की वस्तु के कई क्षेत्रों को स्लॉट्स कहा जाता है और फ़ंक्शन (या संरचनाएं जो संबंधित कार्यों को इंगित करता है) को इंगित करता है जो कि निष्पादित किया जाएगा जब पायथन सी-एपीआई फ़ंक्शन को इस प्रकार की वस्तुओं पर बुलाया जाता है। और यद्यपि यह हमें लगता है कि PyNumber_Subtract विभिन्न प्रकारों के तर्कों के साथ काम करता है, वास्तव में, ऑपरेंड के प्रकारों को निष्क्रिय किया जाता है और इस प्रकार के लिए विशिष्ट घटाव फ़ंक्शन कहा जाता है। इस प्रकार, C-API फ़ंक्शन सार्वभौमिक नहीं हैं। वे विवरणों से प्रकार और सार पर भरोसा करते हैं, और ऐसा लगता है कि वे किसी भी डेटा के साथ काम करते हैं (जबकि TypeError अपवाद को फेंकना भी काम है)।

आइए विवरणों पर एक नज़र डालें। PyNumber_Subtract दो तर्कों का सार्वभौमिक कार्य कहता है ./Objects/abstract.c : binary_op , यह दर्शाता है कि आपको nb_subtract स्लॉट के साथ काम करने की आवश्यकता है (अन्य कार्यों के लिए समान स्लॉट्स हैं, उदाहरण के लिए, अनुक्रम की लंबाई निर्धारित करने के लिए sq_length से sq_length संख्या या sq_length ।) binary_op एक आवरण है जिसमें binary_op1 पर त्रुटि की जांच binary_op1 , एक फ़ंक्शन जो सभी काम करता है। ./Objects/abstract.c : binary_op1 (इस फ़ंक्शन के कोड को पढ़ें - यह आपकी आंखों को कई चीजों के लिए खोलता है) BINARY_SUBTRACT ऑपरेशन के ऑपरेशंस को v और w रूप में स्वीकार करता है, और v->ob_type->tp_as_number , एक संरचना है जो पॉइंटर्स को लागू करने वाले कार्यों के लिए लागू करने का प्रयास करता है। प्रोटोकॉल। binary_op1 1 को tp_as_number->nb_subtract C फ़ंक्शन में खोजने की उम्मीद है जो या तो एक घटाव का प्रदर्शन करेगा या एक विशेष Py_NotImplemented मान Py_NotImplemented यदि यह निर्धारित करता है कि ऑपरेंड एक Py_NotImplemented और घटाए गए एक के रूप में असंगत है (यह एक TypeError अपवाद होगा)।

यदि आप वस्तुओं के व्यवहार को बदलना चाहते हैं, तो आप एक C एक्सटेंशन लिख सकते हैं जो PyTypeObject संरचना को ओवरराइड करेगा और स्लॉट को आपके इच्छित तरीके से भर देगा। जब हम पायथन में नए प्रकार बनाते हैं ( >>> class Foo(list): pass एक नया प्रकार बनाता है, कक्षाएं और प्रकार एक ही चीज हैं), हम मैन्युअल रूप से किसी भी संरचना का वर्णन नहीं करते हैं और किसी भी स्लॉट को नहीं भरते हैं। लेकिन फिर इन प्रकारों में अंतर्निहित लोगों के समान व्यवहार क्यों होता है? यह सही है, विरासत के कारण, जिसमें टाइपिंग की महत्वपूर्ण भूमिका है। पायथन में पहले से ही कुछ अंतर्निहित प्रकार हैं, जैसे list और dict । जैसा कि कहा गया था, इन प्रकारों में कुछ कार्य हैं जो संबंधित स्लॉट्स को भरते हैं, जो वस्तुओं को वांछित व्यवहार देता है: उदाहरण के लिए, मूल्यों के अनुक्रम का म्यूटेशन या मूल्यों की कुंजी की मैपिंग। जब आप पाइथन में एक नया प्रकार बनाते हैं, तो इसके लिए (किसी अन्य ऑब्जेक्ट के लिए) ढेर पर एक नया सी-स्ट्रक्चर गतिशील रूप से निर्धारित किया जाता है और इसके स्लॉट्स विरासत में मिले, बेसिक , टाइप के अनुसार भरे जाते हैं (आप पूछ सकते हैं, कि इनहेरिटिव इनहेरिटेंस के बारे में क्या है? मैं जवाब दूंगा) अन्य प्रकरणों में )। क्योंकि स्लॉट्स कॉपी किए गए हैं, नए मान्यता प्राप्त उपप्रकार और बेसिक में लगभग समान कार्यक्षमता है। पायथन में, किसी भी कार्यक्षमता के बिना एक मूल प्रकार है - object (C में PyBaseObject_Type ), जिसमें लगभग सभी स्लॉट शून्य हैं, और जिसे कुछ भी PyBaseObject_Type किए बिना विस्तारित किया जा सकता है।

इस प्रकार, आप पायथन में एक प्रकार का निर्माण नहीं कर सकते, आप हमेशा कुछ और से विरासत में लेते हैं (यदि आप स्पष्ट उत्तराधिकार के बिना एक वर्ग को परिभाषित करते हैं, तो यह अंतर्निहित रूप से object से विरासत में होगा; पायथन 2.x में, इस मामले में एक "क्लासिक" वर्ग बनाया जाएगा; , हम उन पर विचार नहीं करेंगे)। स्वाभाविक रूप से, आपको लगातार सब कुछ विरासत में नहीं मिलता है। आप सीधे पायथन में बनाए गए एक प्रकार के व्यवहार को बदल सकते हैं, जैसा कि ऊपर दिए गए स्निपेट में दिखाया गया है। Bar वर्ग पर एक विशेष __call__ विधि को परिभाषित करके , हमने इस वर्ग के उदाहरणों को कॉल करने योग्य बनाया।

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

एक और __call__ बिंदु: __call__ विधि की परिभाषा एक प्रकार में कैसे __call__ इसे बनाने के बाद इस प्रकार के उदाहरणों को __call__ करने योग्य बनाया जाता है, भले ही वे विधि की परिभाषा से पहले __call__ थे? आसान और सरल, मेरे दोस्त। जैसा कि आप याद करते हैं, एक प्रकार एक वस्तु है, और एक प्रकार है (यदि आपको सिरदर्द है, तो >>> class Foo(list): pass ; type(Foo) )। इसलिए, जब हम कक्षा के साथ कुछ करते हैं (हम वर्ग के बजाय शब्द प्रकार भी लिख सकते हैं, लेकिन चूंकि हम एक अलग संदर्भ में "प्रकार" का उपयोग करते हैं, तो हमारे प्रकार को थोड़ी देर के लिए कॉल करें), उदाहरण के लिए, कॉल, घटाना या हम एक विशेषता को परिभाषित करते हैं, ob_type वस्तु का ob_type क्षेत्र को ob_type जाता है, और यह पता चलता है कि वर्ग type । फिर, विशेषता सेट करने के लिए type->tp_setattro स्लॉट का उपयोग किया जाता है। यही है, एक वर्ग में एक अलग विशेषता सेटिंग फ़ंक्शन हो सकता है। और इस तरह के एक विशिष्ट कार्य (यदि आप इसे फेसबुक पर फ्रीज करना चाहते हैं, तो यहां इसका पृष्ठ है --/ ./Objects/typeobject.c / type_setattro : type_setattro ) एक ही फ़ंक्शन ( update_one_slot ) को fixup_slot_dispatchers करता है जो एक नई विशेषता को परिभाषित करने के बाद सभी समस्याओं को हल करने के लिए fixup_slot_dispatchers का उपयोग करता है। नया खुलासा हुआ!

यह संभवतः पायथन वस्तुओं के लिए परिचय को समाप्त करने का स्थान है। मुझे आशा है कि आपने यात्रा का आनंद लिया है और आप अभी भी मेरे साथ हैं। मुझे यह स्वीकार करना चाहिए कि इस पोस्ट को लिखना मेरी अपेक्षा से अधिक कठिन हो गया (और #python-dev पर रात में देर रात एंटोनी पिट्र्यू और मार्क डिकिन्स की मदद के बिना मैं सबसे अधिक संभावना छोड़ दूंगा!)। हमारे पास अभी भी बहुत सारी दिलचस्प चीजें हैं: बाइनरी ऑपरेशन में कौन सा ऑपरेंड स्लॉट इस्तेमाल किया जाता है? एकाधिक वंशानुक्रम के साथ क्या होता है, और उन खौफनाक सबसे नन्हा विवरणों के बारे में क्या है? मेटाक्लासेस के बारे में क्या? और __slots__ और कमजोर लिंक ? एम्बेडेड ऑब्जेक्ट्स में क्या हो रहा है? शब्दकोश , सूची , सेट और उनके चचेरे भाई कैसे काम करते हैं? और अंत में, इस चमत्कार के बारे में क्या?

 >>> a = object() >>> class C(object): pass ... >>> b = C() >>> a.foo = 5 Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: 'object' object has no attribute 'foo' >>> b.foo = 5 >>> 

आप वर्ग से एक मनमाना गुण कैसे जोड़ सकते हैं, वर्ग C का एक उदाहरण जो object से विरासत में मिला object , और आप a ही, एक ही object का एक उदाहरण के साथ नहीं कर सकते हैं? जो जानते हैं वे कह सकते हैं: b में __dict__ , लेकिन ऐसा नहीं है। हाँ यह है लेकिन यह नया (और पूरी तरह से गैर-तुच्छ!) कार्यक्षमता कहां से आई है, अगर हम इसे विरासत में नहीं लेते हैं?

हा! मैं ऐसे सवालों से बेहद खुश हूँ! उत्तर होंगे , लेकिन अगले एपिसोड में।

---

जिज्ञासुओं के लिए साहित्य की एक छोटी सूची:

• डेटा मॉडल (बल के खिला पक्ष) पर प्रलेखन;
• अमूर्त और विशिष्ट वस्तु (पावर साइड) पर सी-एपीआई प्रलेखन;
• descrintro , या पायथन 2.2 में प्रकारों और वर्गों का एकीकरण , एक लंबा, मस्तिष्क-असर और अत्यंत महत्वपूर्ण पुरातात्विक खोज है (मुझे लगता है कि इसे ईस्टर अंडे के रूप में दुभाषिया में जोड़ा जाना चाहिए, मेरा सुझाव है कि >>> import THAT )
• लेकिन सबसे पहले यह फाइल है ./Objects/typeobject.c । इसे बार-बार पढ़ें, जब तक कि आँसू में आप बिस्तर पर न गिर जाएं।

अच्छा सपना देखा।

---

याद रखें! हम हमेशा इच्छुक लोगों के साथ मिलकर खुश होते हैं ।