पायथन कोड जीवन चक्र - सीपीथॉन रनटाइम मॉडल

सभी को नमस्कार! वसंत आ गया है, जिसका अर्थ है कि पायथन डेवलपर कोर्स शुरू होने से पहले एक महीने से भी कम समय रहता है। यह इस पाठ्यक्रम के लिए है कि हमारा आज का प्रकाशन समर्पित होगा।





उद्देश्यों:

- पायथन की आंतरिक संरचना के बारे में जानें;
- एक सार वाक्यविन्यास पेड़ (एएसटी) के निर्माण के सिद्धांतों को समझना;
- समय और मेमोरी में अधिक कुशल कोड लिखें।

प्रारंभिक सिफारिशें:

- दुभाषिया (एएसटी, टोकन, आदि) की बुनियादी समझ।
- अजगर का ज्ञान।
- सी का बुनियादी ज्ञान।

batuhan@arch-pc  ~/blogs/cpython/exec_model  python --version Python 3.7.0 

CPython निष्पादन मॉडल

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

• पार्सिंग और टोकेनाइजेशन:
• एएसटी में परिवर्तन;
• नियंत्रण प्रवाह ग्राफ (सीएफजी);
• बाईटकोड;
• सीपीथॉन वर्चुअल मशीन पर चल रहा है।

पार्सिंग और टोकन।
व्याकरण।

व्याकरण पायथन भाषा के शब्दार्थ को परिभाषित करता है। यह उस तरीके को इंगित करने में भी उपयोगी है जिस तरह से पार्सर को भाषा की व्याख्या करनी चाहिए। पायथन व्याकरण विस्तारित बैकस-नौर रूप के समान सिंटैक्स का उपयोग करता है। स्रोत भाषा से अनुवादक के लिए इसका अपना व्याकरण है। आप निर्देशिका "व्याकरण / व्याकरण / व्याकरण" में व्याकरण फ़ाइल पा सकते हैं।

निम्नलिखित एक व्याकरण का एक उदाहरण है,

 batuhan@arch-pc  ~/cpython/Grammar   master  grep "simple_stmt" Grammar | head -n3 | tail -n1 simple_stmt: small_stmt (';' small_stmt)* [';'] NEWLINE 

सरल अभिव्यक्तियों में छोटे भाव और कोष्ठक होते हैं, और कमांड एक नई पंक्ति के साथ समाप्त होती है। छोटे-छोटे भाव आयात की सूची की तरह दिखते हैं ...
कुछ अन्य भाव :)

 small_stmt: (expr_stmt | del_stmt | pass_stmt | flow_stmt | import_stmt | global_stmt | nonlocal_stmt | assert_stmt) ... del_stmt: 'del' exprlist pass_stmt: 'pass' flow_stmt: break_stmt | continue_stmt | return_stmt | raise_stmt | yield_stmt break_stmt: 'break' continue_stmt: 'continue' 

टोकनाइजेशन (लेक्सिंग)

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

टोकन

एक टोकन एक हेडर फ़ाइल है जिसमें सभी टोकन की परिभाषाएँ हैं। पाइथन में 59 प्रकार के टोकन हैं (शामिल / टोकन .h)।

नीचे उनमें से कुछ का एक उदाहरण है,

 #define NAME 1 #define NUMBER 2 #define STRING 3 #define NEWLINE 4 #define INDENT 5 #define DEDENT 6 

यदि आप कुछ पायथन कोड को टोकन में तोड़ते हैं तो आप उन्हें देखते हैं।

सीएलआई के साथ टोकन

यहाँ परीक्षणों की फ़ाइल है

 def greetings(name: str): print(f"Hello {name}") greetings("Batuhan") 

फिर हम इसे python -m tokenize कमांड का उपयोग करके टोकन करते हैं और निम्नलिखित आउटपुट है:

 batuhan@arch-pc  ~/blogs/cpython/exec_model  python -m tokenize tests.py 0,0-0,0: ENCODING 'utf-8' ... 2,0-2,4: INDENT ' ' 2,4-2,9: NAME 'print' ... 4,0-4,0: DEDENT '' ... 5,0-5,0: ENDMARKER '' 

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

टोकन के साथ टोकन

यदि आपको अपने कोड से फ़ाइल को टोकन करने की आवश्यकता है, तो आप stdlib से टोकन मॉड्यूल का उपयोग कर सकते हैं।

 >>> with open('tests.py', 'rb') as f: ... for token in tokenize.tokenize(f.readline): ... print(token) ... TokenInfo(type=57 (ENCODING), string='utf-8', start=(0, 0), end=(0, 0), line='') ... TokenInfo(type=1 (NAME), string='greetings', start=(1, 4), end=(1, 13), line='def greetings(name: str):\n') ... TokenInfo(type=53 (OP), string=':', start=(1, 24), end=(1, 25), line='def greetings(name: str):\n') ... 

टोकन का प्रकार टोकन आईडी में इसकी आईडी है । हेडर फ़ाइल । स्ट्रिंग टोकन का मूल्य है। प्रारंभ और अंत दिखाएँ जहां क्रमशः टोकन शुरू और समाप्त होता है।

अन्य भाषाओं में, ब्लॉक को कोष्ठक या आरंभ / अंत विवरणों द्वारा दर्शाया जाता है, लेकिन पायथन इंडेंट और विभिन्न स्तरों का उपयोग करता है। इंडेंट और डेडेंट टोकन और इंडेंटेशन का संकेत देते हैं। इन टोकनों को संबंधपरक पार्सिंग पेड़ों और / या सार सिंटैक्स पेड़ों के निर्माण की आवश्यकता होती है।

परसर पीढ़ी

पार्सर पीढ़ी - एक प्रक्रिया जो किसी दिए गए व्याकरण के अनुसार एक पार्सर उत्पन्न करती है। पार्सर जनरेटर को पीजीएन के रूप में जाना जाता है। Cpython में दो पार्सर जनरेटर हैं। एक मूल ( Parser/pgen ) है और एक अजगर ( /Lib/lib2to3/pgen2 ) में फिर से लिखा गया है।

"मूल जनरेटर पहला कोड था जिसे मैंने पायथन के लिए लिखा था"
-Guido

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

डीएफए (परिभाषित राज्य मशीन)

पार्सर प्रत्येक नॉनटर्मिनल के लिए एक डीएफए को परिभाषित करता है। प्रत्येक डीएफए को राज्यों की एक सरणी के रूप में परिभाषित किया गया है।

 static dfa dfas[87] = { {256, "single_input", 0, 3, states_0, "\004\050\340\000\002\000\000\000\012\076\011\007\262\004\020\002\000\300\220\050\037\202\000"}, ... {342, "yield_arg", 0, 3, states_86, "\000\040\200\000\002\000\000\000\000\040\010\000\000\000\020\002\000\300\220\050\037\000\000"}, }; 

प्रत्येक डीएफए के लिए, एक स्टार्टर किट होती है जो दिखाती है कि एक विशेष गैर-टर्मिनल टोकन किसके साथ शुरू हो सकता है।

राज्य

प्रत्येक राज्य संक्रमण / किनारों (आर्क्स) की एक सरणी द्वारा परिभाषित किया गया है।

 static state states_86[3] = { {2, arcs_86_0}, {1, arcs_86_1}, {1, arcs_86_2}, }; 

संक्रमण (आर्क्स)

प्रत्येक संक्रमण सरणी में दो नंबर होते हैं। पहला नंबर संक्रमण (आर्क लेबल) का नाम है, यह प्रतीक संख्या को संदर्भित करता है। दूसरा नंबर गंतव्य है।

 static arc arcs_86_0[2] = { {77, 1}, {47, 2}, }; static arc arcs_86_1[1] = { {26, 2}, }; static arc arcs_86_2[1] = { {0, 2}, }; 

नाम (लेबल)

यह एक विशेष तालिका है जो चरित्र के आईडी को संक्रमण के नाम पर मैप करती है।

 static label labels[177] = { {0, "EMPTY"}, {256, 0}, {4, 0}, ... {1, "async"}, {1, "def"}, ... {1, "yield"}, {342, 0}, }; 

नंबर 1 सभी पहचानकर्ताओं से मेल खाता है। इस प्रकार, उनमें से प्रत्येक को अलग-अलग संक्रमण नाम मिलते हैं, भले ही वे सभी एक ही चरित्र आईडी हों।

एक सरल उदाहरण:

मान लीजिए कि हमारे पास एक कोड है जो "हाय" को आउटपुट करता है यदि 1 - सत्य:

 if 1: print('Hi') 

पार्सर इस कोड को single_input मानता है।

 single_input: NEWLINE | simple_stmt | compound_stmt NEWLINE 

तब हमारा पार्सिंग ट्री एक बार के इनपुट के रूट नोड पर शुरू होता है।



और हमारे DFA (single_input) का मान 0 है।

 static dfa dfas[87] = { {256, "single_input", 0, 3, states_0, "\004\050\340\000\002\000\000\000\012\076\011\007\262\004\020\002\000\300\220\050\037\202\000"} ... } 

यह इस तरह दिखेगा:

 static arc arcs_0_0[3] = { {2, 1}, {3, 1}, {4, 2}, }; static arc arcs_0_1[1] = { {0, 1}, }; static arc arcs_0_2[1] = { {2, 1}, }; static state states_0[3] = { {3, arcs_0_0}, {1, arcs_0_1}, {1, 

arcs_0_2},
};

यहाँ arc_0_0 में तीन तत्व हैं। पहला है NEWLINE , दूसरा है simple_stmt , और अंतिम है compound_stmt ।

Simple_stmt के शुरुआती सेट को देखते हुए simple_stmt हम यह निष्कर्ष निकाल सकते हैं कि simple_stmt साथ शुरू नहीं हो सकता है। हालाँकि, भले ही कोई नई लाइन न हो, फिर भी कंपाउंड_स्टेम if शुरू हो if । इस प्रकार, हम अंतिम arc ({4;2}) और पार्सिंग ट्री में कंपाउंड_स्टेम नोड जोड़ते हैं और नंबर 2 पर जाने से पहले, हम नए डीएफए पर स्विच करते हैं। हमें एक अद्यतन पार्सिंग पेड़ मिलता है:



नया DFA यौगिक कथनों को पार्स करता है।

 compound_stmt: if_stmt | while_stmt | for_stmt | try_stmt | with_stmt | funcdef | classdef | decorated | async_stmt 

और हम निम्नलिखित प्राप्त करते हैं:

 static arc arcs_39_0[9] = { {91, 1}, {92, 1}, {93, 1}, {94, 1}, {95, 1}, {19, 1}, {18, 1}, {17, 1}, {96, 1}, }; static arc arcs_39_1[1] = { {0, 1}, }; static state states_39[2] = { {9, arcs_39_0}, {1, arcs_39_1}, }; 

केवल पहली छलांग शुरू हो सकती है if । हमें एक अद्यतन पार्सिंग पेड़ मिलता है।



फिर हम फिर से DFA और अगले DFA ifs को बदलते हैं।

 if_stmt: 'if' test ':' suite ('elif' test ':' suite)* ['else' ':' suite] 

नतीजतन, हम पदनाम 97 के साथ एकमात्र संक्रमण प्राप्त करते हैं। यह टोकन के साथ मेल खाता है।

 static arc arcs_41_0[1] = { {97, 1}, }; static arc arcs_41_1[1] = { {26, 2}, }; static arc arcs_41_2[1] = { {27, 3}, }; static arc arcs_41_3[1] = { {28, 4}, }; static arc arcs_41_4[3] = { {98, 1}, {99, 5}, {0, 4}, }; static arc arcs_41_5[1] = { {27, 6}, }; static arc arcs_41_6[1] = { {28, 7}, }; ... 

जब हम अगले राज्य में जाते हैं, उसी DFA में शेष रहते हैं, तो अगले arcs_41_1 में केवल एक संक्रमण होता है। यह परीक्षण टर्मिनल के लिए सही है। यह एक संख्या (उदाहरण के लिए, 1) से शुरू होना चाहिए।



Arc_41_2 में केवल एक संक्रमण है जो कोलन टोकन प्राप्त करता है (:)।



तो हमें एक सेट मिलता है जो प्रिंट मूल्य के साथ शुरू हो सकता है। अंत में, arcs_41_4 पर जाएं। सेट में पहला संक्रमण एक एलीफ अभिव्यक्ति है, दूसरा एक और है, और तीसरा अंतिम स्थिति के लिए है। और हमें पार्सिंग ट्री का अंतिम दृश्य मिलता है।



पार्सर के लिए पायथन इंटरफ़ेस।


पायथन आपको पार्सर नामक एक मॉड्यूल का उपयोग करके भावों के लिए पार्सिंग पेड़ को संपादित करने की अनुमति देता है।

 >>> import parser >>> code = "if 1: print('Hi')" 

आप parser.suite का उपयोग करके एक विशिष्ट सिंटैक्स ट्री (कंक्रीट सिंटैक्स ट्री, सीएसटी) उत्पन्न कर सकते हैं।

 >>> parser.suite(code).tolist() [257, [269, [295, [297, [1, 'if'], [305, [309, [310, [311, [312, [315, [316, [317, [318, [319, [320, [321, [322, [323, [324, [2, '1']]]]]]]]]]]]]]]], [11, ':'], [304, [270, [271, [272, [274, [305, [309, [310, [311, [312, [315, [316, [317, [318, [319, [320, [321, [322, [323, [324, [1, 'print']], [326, [7, '('], [334, [335, [305, [309, [310, [311, [312, [315, [316, [317, [318, [319, [320, [321, [322, [323, [324, [3, "'Hi'"]]]]]]]]]]]]]]]]]], [8, ')']]]]]]]]]]]]]]]]]]], [4, '']]]]]], [4, ''], [0, '']] 

आउटपुट मान एक नेस्टेड सूची होगी। संरचना में प्रत्येक सूची में 2 तत्व हैं। पहला चरित्र की आईडी है (0-256 - टर्मिनल, 256+ - गैर-टर्मिनल) और दूसरा टर्मिनल के लिए टोकन का स्ट्रिंग है।

सार सिंटेक्स ट्री

वास्तव में, एक सार सिंटैक्स ट्री (एएसटी) एक पेड़ के रूप में स्रोत कोड का एक संरचनात्मक प्रतिनिधित्व है, जहां प्रत्येक शीर्ष भाषा के विभिन्न प्रकारों (अभिव्यक्ति, चर, ऑपरेटर, आदि) को दर्शाता है।

एक पेड़ क्या है?

एक पेड़ एक डेटा संरचना है जिसमें एक प्रारंभिक बिंदु के रूप में जड़ शीर्ष है। रूट वर्टेक्स अन्य शाखाओं के नीचे शाखाओं (संक्रमण) द्वारा कम किया जाता है। जड़ को छोड़कर प्रत्येक शीर्ष पर, एक अद्वितीय मूल शीर्ष है।

अमूर्त सिंटैक्स ट्री और पार्सिंग ट्री के बीच एक निश्चित अंतर है।



दाईं ओर अभिव्यक्ति 2 * 7 + 3 के लिए एक परसिंग ट्री है। यह वस्तुतः एक पेड़ के रूप में स्रोत कोड की एक-से-एक छवि है। इस पर सभी भाव, शब्द और मूल्य दिखाई देते हैं। हालांकि, इस तरह की छवि कोड के एक साधारण टुकड़े के लिए बहुत जटिल है, इसलिए हम केवल उन सभी वाक्यात्मक अभिव्यक्तियों को हटा सकते हैं जिन्हें हमें गणना के लिए कोड में परिभाषित करना था।

इस तरह के एक सरलीकृत पेड़ को अमूर्त सिंटैक्स ट्री (एएसटी) कहा जाता है। चित्र में बाईं ओर यह उसी कोड के लिए दिखाया गया है। आसानी से समझने के लिए सभी वाक्यविन्यास अभिव्यक्तियों को छोड़ दिया गया है, लेकिन याद रखें कि कुछ जानकारी खो गई है।

उदाहरण

पायथन, एएसटी के साथ काम करने के लिए एक अंतर्निहित एएसटी मॉड्यूल प्रदान करता है। एएसटी पेड़ों से कोड उत्पन्न करने के लिए, आप तीसरे पक्ष के मॉड्यूल का उपयोग कर सकते हैं, उदाहरण के लिए एस्टोर ।

उदाहरण के लिए, पहले जैसा ही कोड देखें।

 >>> import ast >>> code = "if 1: print('Hi')" 

एएसटी प्राप्त करने के लिए, हम ast.parse विधि का उपयोग करते हैं।

 >>> tree = ast.parse(code) >>> tree <_ast.Module object at 0x7f37651d76d8> 

अधिक पठनीय सार वाक्यविन्यास ट्री प्राप्त करने के लिए ast.dump विधि का उपयोग करने का प्रयास करें।

 >>> ast.dump(tree) "Module(body=[If(test=Num(n=1), body=[Expr(value=Call(func=Name(id='print', ctx=Load()), args=[Str(s='Hi')], keywords=[]))], orelse=[])])" 

एएसटी को आमतौर पर पार्सिंग ट्री की तुलना में अधिक दृश्य और समझने में आसान माना जाता है।

नियंत्रण प्रवाह ग्राफ (सीएफजी)

नियंत्रण प्रवाह रेखांकन दिशात्मक रेखांकन हैं जो आधार ब्लॉक का उपयोग करके एक कार्यक्रम के प्रवाह को मॉडल करते हैं जिसमें एक मध्यवर्ती प्रतिनिधित्व होता है।

आमतौर पर, आउटपुट कोड मान प्राप्त करने से पहले CFG पिछला चरण होता है। कोड सीधे आधार ब्लॉक से उत्पन्न होता है, जो सबसे ऊपर से शुरू होकर CFG में बैकवर्ड डेप्थ सर्च का उपयोग करता है।

बाईटकोड

पायथन बायटेकोड निर्देशों का एक मध्यवर्ती सेट है जो पायथन वर्चुअल मशीन में काम करता है। जब आप स्रोत कोड चलाते हैं, तो पायथन __pycache__ नामक एक निर्देशिका बनाता है। यह संकलन को फिर से शुरू करने के मामले में समय बचाने के लिए संकलित कोड को संग्रहीत करता है।

Func.py में एक साधारण पायथन फ़ंक्शन पर विचार करें।

 def say_hello(name: str): print("Hello", name) print(f"How are you {name}?") 

 >>> from func import say_hello >>> say_hello("Batuhan") Hello Batuhan How are you Batuhan? 

say_hello ऑब्जेक्ट say_hello एक फ़ंक्शन है।

 >>> type(say_hello) <class 'function'> 

इसमें __code__ विशेषता है।

 >>> say_hello.__code__ <code object say_hello at 0x7f13777d9150, file "/home/batuhan/blogs/cpython/exec_model/func.py", line 1> 

कोड ऑब्जेक्ट

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

 >>> import ast >>> code = """ ... def say_hello(name: str): ... print("Hello", name) ... print(f"How are you {name}?") ... say_hello("Batuhan") ... """ >>> tree = ast.parse(code, mode='exec') >>> code = compile(tree, '<string>', mode='exec') >>> type(code) <class 'code'> 

प्रत्येक कोड ऑब्जेक्ट में ऐसी विशेषताएँ होती हैं जिनमें कुछ जानकारी होती है (co_ के साथ उपसर्ग)। यहाँ हम उनमें से केवल कुछ का उल्लेख करते हैं।

co_name

एक शुरुआत के लिए - एक नाम। यदि कोई फ़ंक्शन मौजूद है, तो उसके पास क्रमशः एक नाम होना चाहिए, यह नाम फ़ंक्शन का नाम होगा, कक्षा के साथ एक समान स्थिति। एएसटी उदाहरण में, हम मॉड्यूल का उपयोग करते हैं, और हम संकलक को बता सकते हैं कि हम उन्हें क्या नाम देना चाहते हैं। उन्हें सिर्फ एक module होने दें।

 >>> code.co_name '<module>' >>> say_hello.__code__.co_name 'say_hello' 

co_varnames

यह एक टपल है जिसमें तर्कों सहित सभी स्थानीय चर शामिल हैं।

 >>> say_hello.__code__.co_varnames ('name',) 

co_conts

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

 >>> say_hello.__code__.co_consts (None, 'Hello', 'How are you ', '?') 

बाइटकोड (co_code)

निम्नलिखित हमारे कार्य का बायटेकोड है।

 >>> bytecode = say_hello.__code__.co_code >>> bytecode b't\x00d\x01|\x00\x83\x02\x01\x00t\x00d\x02|\x00\x9b\x00d\x03\x9d\x03\x83\x01\x01\x00d\x00S\x00' 

यह एक स्ट्रिंग नहीं है, यह एक बाइट ऑब्जेक्ट है, अर्थात् बाइट्स का एक क्रम है।

 >>> type(bytecode) <class 'bytes'> 

मुद्रित पहला वर्ण "t" है। यदि हम इसका संख्यात्मक मूल्य पूछते हैं, तो हमें निम्नलिखित मिलते हैं।

 >>> ord('t') 116 

116 बाइटकोड [0] के समान है।

 >>> assert bytecode[0] == ord('t') 

हमारे लिए, 116 का मान कुछ भी नहीं है। सौभाग्य से, पायथन एक मानक पुस्तकालय प्रदान करता है जिसे डिस (विचलन से) कहा जाता है। यह opname सूची के साथ काम करते समय उपयोगी है। यह सभी बायोटेक निर्देशों की एक सूची है, जहां प्रत्येक सूचकांक निर्देश का नाम है।

 >>> dis.opname[ord('t')] 'LOAD_GLOBAL' 

आइए एक और अधिक जटिल फ़ंक्शन बनाएं।

 >>> def multiple_it(a: int): ... if a % 2 == 0: ... return 0 ... return a * 2 ... >>> multiple_it(6) 0 >>> multiple_it(7) 14 >>> bytecode = multiple_it.__code__.co_code 

और हम बाइटकोड में पहले निर्देश का पता लगाते हैं।

 >>> dis.opname[bytecode[0]] 'LOAD_FAST 

LOAD_FAST स्टेटमेंट में दो तत्व होते हैं।

 >>> dis.opname[bytecode[0]] + ' ' + dis.opname[bytecode[1]] 'LOAD_FAST <0>' 

लोडफुट 0 निर्देश एक टुपल में चर नामों की खोज करने के लिए होता है और निष्पादन स्टैक में शून्य इंडेक्स के साथ एक तत्व को एक ट्यूपल में धकेलता है।

 >>> multiple_it.__code__.co_varnames[bytecode[1]] 'a' 

हमारे कोड को dis.dis का उपयोग करके अलग किया जा सकता है और बायोटकोड को एक परिचित दृश्य में बदल सकता है। यहां नंबर (2,3,4) लाइन नंबर हैं। पायथन में कोड की प्रत्येक पंक्ति को निर्देशों के एक सेट के रूप में विस्तारित किया गया है।

 >>> dis.dis(multiple_it) 2 0 LOAD_FAST 0 (a) 2 LOAD_CONST 1 (2) 4 BINARY_MODULO 6 LOAD_CONST 2 (0) 8 COMPARE_OP 2 (==) 10 POP_JUMP_IF_FALSE 16 3 12 LOAD_CONST 2 (0) 14 RETURN_VALUE 4 >> 16 LOAD_FAST 0 (a) 18 LOAD_CONST 1 (2) 20 BINARY_MULTIPLY 22 RETURN_VALUE 

लीड समय

सीपीथॉन एक स्टैक-ओरिएंटेड वर्चुअल मशीन है, न कि रजिस्टरों का संग्रह। इसका मतलब यह है कि पायथन कोड एक स्टैक आर्किटेक्चर के साथ एक वर्चुअल मशीन के लिए संकलित है।

एक फ़ंक्शन को कॉल करते समय, पायथन एक साथ दो ढेर का उपयोग करता है। पहला निष्पादन स्टैक है, और दूसरा ब्लॉक स्टैक है। अधिकांश कॉल निष्पादन स्टैक पर होते हैं; ब्लॉक स्टैक इस बात पर नज़र रखता है कि वर्तमान में कितने ब्लॉक सक्रिय हैं, साथ ही ब्लॉक और स्कोप से संबंधित अन्य पैरामीटर भी हैं।

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