लेखों की यह श्रृंखला उन लोगों के लिए डिज़ाइन की गई है जो सामान्य रूप से अजगर में लिख सकते हैं, लेकिन इस भाषा के अंदर से इस भाषा को कैसे व्यवस्थित किया जाता है, इसका अंदाजा खराब है। दरअसल, तीन महीने पहले मेरी तरह।

छोटा अस्वीकरण: मैं अजगर 2.7 दुभाषिया के उदाहरण का उपयोग करके अपनी कहानी का नेतृत्व करूंगा। बाद में चर्चा की जाने वाली सब कुछ अजगर 3.x पर दोहराया जा सकता है, कुछ कार्यों के वाक्यविन्यास और नामकरण में अंतर के लिए समायोजित किया जा सकता है।

तो चलिए शुरू करते हैं।

भाग I. पायथन को सुनें, और आपके अंदर क्या है?

आइए थोड़ा (वास्तव में, एक मजबूत) उच्च स्तर के साथ शुरू करें जो हमारे प्यारे साँप के बारे में है। जब आप इंटरएक्टिव दुभाषिया में इस तरह की एक पंक्ति टाइप करते हैं तो क्या होता है?

>>> a = "hello" 

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

मैं शाब्दिक विश्लेषण, पार्सिंग और संकलन के विषयों में तल्लीन नहीं करूंगा, मुख्यतः क्योंकि मुझे खुद उनके बारे में कोई पता नहीं है। इसके बजाय, आइए बेहतर कल्पना करें कि स्मार्ट लोगों ने सबकुछ सही किया और ये कदम पायथन दुभाषिया में त्रुटियों के बिना काम करते हैं। प्रस्तुत? हम आगे बढ़ते हैं।

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

इस प्रकार,

फंक्शन ऑब्जेक्ट्स या फ़ंक्शंस, ऑब्जेक्ट्स की तरह

यदि यह अजगर प्रोग्रामिंग पर आपका पहला लेख नहीं है, तो आपको कुछ "फ़ंक्शन ऑब्जेक्ट" के बारे में पता होना चाहिए। यह उनके बारे में ठीक है कि एक स्मार्ट दिमाग वाले लोग " प्रथम श्रेणी की वस्तुओं के रूप में कार्य" और "अजगर में प्रथम श्रेणी के कार्यों की उपस्थिति" के बारे में बात करते हैं। निम्नलिखित उदाहरण पर विचार करें:

 >>> def foo(a): ... x = 3 ... return x + a ... >>> foo <function foo at 0x107ef7aa0> 

अभिव्यक्ति "फ़ंक्शंस प्रथम श्रेणी की वस्तुएँ हैं" का अर्थ है कि फ़ंक्शंस प्रथम श्रेणी की वस्तुएँ हैं, इस अर्थ में कि कौन-सी वस्तुएँ ऑब्जेक्ट हैं और MyObject क्लास का एक उदाहरण ऑब्जेक्ट है। और चूंकि फू एक वस्तु है, यह अपने आप में महत्व रखता है, चाहे इसे कैसे भी कहा जाए, जैसे कि कार्य (अर्थात, foo और foo() दो अलग-अलग चीजें हैं। हम एक तर्क के रूप में किसी अन्य फ़ंक्शन के लिए foo पास कर सकते हैं, हम इसे एक नए नाम ( other_function = foo ) को पुन: असाइन कर सकते हैं। प्रथम श्रेणी के कार्यों के साथ, आप कुछ भी कर सकते हैं और वे सब कुछ सहन करेंगे।

भाग II ऑब्जेक्ट मॉड्यूल

इस बिंदु पर, हमें यह पता लगाने के लिए गहराई से जाने की आवश्यकता है कि बदले में फ़ंक्शन ऑब्जेक्ट में कोड ऑब्जेक्ट है:

 >>> def foo(a): ... x = 3 ... return x + a ... >>> foo <function foo at 0x107ef7aa0> >>> foo.func_code <code object foo at 0x107eeccb0, file "<stdin>", line 1> 

जैसा कि लिस्टिंग से देखा जा सकता है, ऑब्जेक्ट मॉड्यूल फ़ंक्शन ऑब्जेक्ट की एक विशेषता है (जिसमें कई अन्य विशेषताएं हैं, लेकिन इस मामले में वे foo की सादगी के कारण विशेष रुचि के नहीं हैं)।

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

 >>> dir(foo.func_code) ['__class__', '__cmp__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'co_argcount', 'co_cellvars', 'co_code', 'co_consts', 'co_filename', 'co_firstlineno', 'co_flags', 'co_freevars', 'co_lnotab', 'co_name', 'co_names', 'co_nlocals', 'co_stacksize', 'co_varnames'] 

जैसा कि आप देखते हैं, उनमें से बहुत सारे हैं, इसलिए हम सब कुछ पर विचार नहीं करेंगे, उदाहरण के लिए हम तीन सबसे समझ में आने वाले पर ध्यान केंद्रित करेंगे:

 >>> foo.func_code.co_varnames ('a', 'x') >>> foo.func_code.co_consts (None, 3) >>> foo.func_code.co_argcount 1 

विशेषताएँ बहुत सहज दिखती हैं:
co_varnames - चर नाम
co_consts - मानों के बारे में फ़ंक्शन जानता है
co_argcount - फ़ंक्शन के तर्कों की संख्या

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

 >>> foo.func_code.co_code 'd\x01\x00}\x01\x00|\x01\x00|\x00\x00\x17S' 

आप किस तरह के अज्ञात बाइट कचरे को पूछते हैं?

भाग III बाईटकोड

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

यह बायोटेक क्या है? जैसा कि नाम से पता चलता है, यह सिर्फ बाइट्स का एक क्रम है। कंसोल को आउटपुट करते समय, यह पागल दिखता है, तो चलो इसे ord से गुजरते हुए एक संख्यात्मक अनुक्रम में लाते हैं:

 >>> [ord(b) for b in foo.func_code.co_code] [100, 1, 0, 125, 1, 0, 124, 1, 0, 124, 0, 0, 23, 83] 

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

आप CPython दुभाषिया फ़ाइल (ceval.c) खोलकर बाईटेकोड को समझने की कोशिश कर सकते हैं, लेकिन हम ऐसा नहीं करेंगे। अधिक ठीक है, लेकिन बाद में। अब चलो आसान रास्ता तय करते हैं और मानक पुस्तकालय से dis मॉड्यूल का उपयोग करते हैं।

इसे अलग कर लें

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

तो, आइए लागू करें और हमारे ऑब्जेक्ट मॉड्यूल से बुर्का हटा दें। ऐसा करने के लिए, dis.dis फ़ंक्शन का उपयोग करें:

 >>> def foo(a): ... x = 3 ... return x + a ... >>> import dis >>> dis.dis(foo.func_code) 2 0 LOAD_CONST 1 (3) 3 STORE_FAST 1 (x) 3 6 LOAD_FAST 1 (x) 9 LOAD_FAST 0 (a) 12 BINARY_ADD 13 RETURN_VALUE 

पहले कॉलम में संख्या विश्लेषण किए गए स्रोतों की लाइन संख्या हैं। दूसरा कॉलम बाइटकोड में टीमों की ऑफसेट दिखाता है: LOAD_CONST "0" स्थिति पर STORE_FAST , STORE_FAST स्थिति "3", आदि पर है। तीसरा कॉलम बाइट निर्देशों को मानव-पठनीय नाम देता है। इन नामों की आवश्यकता केवल दयनीय छोटे लोगों द्वारा होती है, वे दुभाषिया में उपयोग नहीं किए जाते हैं।

अंतिम दो कॉलमों में इस कमांड के तर्कों के बारे में विवरण है, यदि कोई हो। चौथा स्तंभ ऑब्जेक्ट मॉड्यूल की विशेषता में तर्क की स्थिति को दर्शाता है। हमारे उदाहरण में, LOAD_CONST निर्देश LOAD_CONST co_consts सूची विशेषता के पहले स्थान पर है, STORE_FAST तर्क co_varnames की पहली स्थिति में है। अंत में, पांचवें कॉलम में, dis संबंधित चर के मूल्य या नाम को दर्शाता है। अभ्यास में सुनिश्चित करें:

 >>> foo.func_code.co_consts[1] 3 >>> foo.func_code.co_varnames[1] 'x' 

यह भी बताता है कि क्यों STORE_FAST बाइटकोड में तीसरे स्थान पर है: यदि STORE_FAST में कहीं एक तर्क है, तो अगले दो बाइट्स उस तर्क का प्रतिनिधित्व करेंगे। ऐसी स्थितियों की सही हैंडलिंग दुभाषिया के साथ भी रहती है।



LOAD_CONST बाइट्स (उदा। 100) को सार्थक नामों (उदा। LOAD_CONST ) और इसके विपरीत में कैसे अनुवाद करता है? इस बारे में सोचें कि आप स्वयं इस तरह की व्यवस्था का आयोजन कैसे करेंगे? यदि आपके पास कोई विचार है, जैसे कि "ठीक है, तो शायद बाइट्स की अनुक्रमिक परिभाषा के साथ कुछ सूची है" या फिर "कुंजी और बाइट्स के रूप में मान के रूप में निर्देश नाम के साथ एक शब्दकोश", बधाई - आप बिल्कुल सही हैं। ठीक इसी तरह से यह काम करता है। Opcode.py फ़ाइल में परिभाषाएँ स्वयं होती हैं (आप opcode.h हेडर फ़ाइल भी देख सकते हैं), जहाँ आप ~ डेढ़ सौ ऐसी लाइनें देख सकते हैं:

 def_op('LOAD_CONST', 100) # Index in const list def_op('BUILD_TUPLE', 102) # Number of tuple items def_op('BUILD_LIST', 103) # Number of list items def_op('BUILD_SET', 104) # Number of set items 

(कुछ टिप्पणीकार ने निर्देशों के लिए सावधानीपूर्वक स्पष्टीकरण छोड़ दिया है।)

अब हमारे पास कुछ विचार है कि क्या (और क्या नहीं है) बायटेकोड और इसका विश्लेषण करने के लिए dis का उपयोग कैसे करें। निम्नलिखित भागों में, हम देखेंगे कि एक गतिशील पीएल शेष रहते हुए, पायथन बाइटकोड में कैसे संकलित कर सकता है।