पायथन में संकेत: क्या बात है?

यदि आपने कभी C या C ++ जैसी निम्न-स्तरीय भाषाओं के साथ काम किया है, तो आपने शायद बिंदुओं के बारे में सुना है। वे आपको कोड के विभिन्न टुकड़ों की प्रभावशीलता को बढ़ाने की अनुमति देते हैं। लेकिन वे नौसिखियों को भ्रमित भी कर सकते हैं - और यहां तक ​​कि अनुभवी डेवलपर्स - और स्मृति प्रबंधन बगों को जन्म देते हैं। क्या पायथन में संकेत हैं, क्या मैं किसी तरह उनका अनुकरण कर सकता हूं?

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

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

इस लेख के साथ, आप:

• जानें कि पायथन में संकेत क्यों नहीं हैं।
• पायथन में सी चर और नामों के बीच अंतर जानें।
• पायथन में पॉइंटर्स का अनुकरण करना सीखें।
• वास्तविक ctypes साथ प्रयोग ctypes उपयोग करें।

नोट : यहाँ, शब्द "पायथन" को C में पायथन कार्यान्वयन के लिए लागू किया गया है, जिसे CPython के रूप में जाना जाता है। भाषा उपकरण की सभी चर्चाएँ CPython 3.7 के लिए मान्य हैं, लेकिन बाद के पुनरावृत्तियों के अनुरूप नहीं हो सकती हैं।

पायथन में संकेत क्यों नहीं हैं?

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

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

पायथन में संकेत समझने के लिए, आइए संक्षेप में भाषा कार्यान्वयन की विशेषताओं पर जाएं। विशेष रूप से, आपको समझने की आवश्यकता है:

1. परस्पर और अपरिवर्तनीय वस्तुएँ क्या हैं।
2. पाइथन में चर / नाम कैसे व्यवस्थित होते हैं।

अपने स्मृति पतों को पकड़ो, चलो चलें!

पायथन में वस्तुएँ

अजगर में सब कुछ एक वस्तु है। उदाहरण के लिए, REPL खोलें और देखें कि किस isinstance() :

 >>> isinstance(1, object) True >>> isinstance(list(), object) True >>> isinstance(True, object) True >>> def foo(): ... pass ... >>> isinstance(foo, object) True 

यह कोड दर्शाता है कि पायथन में सब कुछ वास्तव में एक वस्तु है। प्रत्येक ऑब्जेक्ट में कम से कम तीन प्रकार के डेटा होते हैं:

• संदर्भ काउंटर।
  
• टाइप करें।
  
• मान।
  

मेमोरी को प्रबंधित करने के लिए एक संदर्भ काउंटर का उपयोग किया जाता है। इस प्रबंधन के बारे में विवरण पायथन में मेमोरी प्रबंधन में लिखे गए हैं। रनटाइम के दौरान टाइप सुरक्षा प्रदान करने के लिए टाइप का उपयोग CPython स्तर पर किया जाता है। और मान वस्तु से जुड़ा वास्तविक मूल्य है।

लेकिन सभी वस्तुएं समान नहीं हैं। एक महत्वपूर्ण अंतर है: ऑब्जेक्ट परस्पर और अपरिवर्तनीय हैं। वस्तुओं के प्रकारों के बीच इस अंतर को समझना आपको प्याज की पहली परत को समझने में मदद करेगा जिसे "पायथन में संकेत" कहा जाता है।

उत्परिवर्तनीय और अपरिवर्तनीय वस्तुएँ

पायथन में दो प्रकार की वस्तुएँ हैं:

1. अपरिवर्तनीय वस्तुएं (बदली नहीं जा सकती);
   
2. परिवर्तनशील वस्तुएँ (परिवर्तन के अधीन)।
   

इस अंतर को पहचानना पायथन में पॉइंटर्स की दुनिया के माध्यम से यात्रा करने की पहली कुंजी है। यहाँ कुछ लोकप्रिय प्रकारों की अपरिहार्यता विशेषता है:


जैसा कि आप देख सकते हैं, आमतौर पर उपयोग किए जाने वाले कई आदिम प्रकार अपरिवर्तनीय हैं। आप कुछ पायथन कोड लिखकर इसे सत्यापित कर सकते हैं। आपको मानक पुस्तकालय से दो उपकरणों की आवश्यकता होगी:

1. id() ऑब्जेक्ट का मेमोरी एड्रेस लौटाता है;
   
2. यदि रिटर्न True है और केवल अगर दो वस्तुओं में समान मेमोरी पता है।
   

आप इस कोड को REPL वातावरण में चला सकते हैं:

 >>> x = 5 >>> id(x) 94529957049376 

यहां हम चर x को 5 सेट करते हैं। यदि आप इसके अतिरिक्त मूल्य का उपयोग करने का प्रयास करते हैं, तो आपको एक नई वस्तु मिलेगी:

 >>> x += 1 >>> x 6 >>> id(x) 94529957049408 

यद्यपि ऐसा लग सकता है कि यह कोड केवल x का मान बदलता है, वास्तव में आपको उत्तर के रूप में एक नई वस्तु मिल रही है।

str प्रकार भी अपरिवर्तनीय है:

 >>> s = "real_python" >>> id(s) 140637819584048 >>> s += "_rocks" >>> s 'real_python_rocks' >>> id(s) 140637819609424 

और इस मामले में, ऑपरेशन के बाद s += को एक अलग मेमोरी एड्रेस मिलता है।

बोनस : += ऑपरेटर विभिन्न विधि कॉलों में अनुवाद करता है।

कुछ वस्तुओं के लिए, जैसे कि एक सूची, += __iadd__() (स्थानीय परिशिष्ट) में परिवर्तित होती है। यह खुद ही बदल जाएगा और उसी आईडी को वापस करेगा। हालाँकि, str और int में ये विधियाँ नहीं हैं, और परिणामस्वरूप __add__() बजाय __add__() कहा जाएगा।

अधिक जानकारी के लिए पायथन डेटा मॉडल प्रलेखन देखें ।

जब हम सीधे s के स्ट्रिंग मान को बदलने का प्रयास करते हैं s तो हमें एक त्रुटि मिलती है:

 >>> s[0] = "R" 

बैक ट्रेस (सबसे हालिया कॉल अंतिम प्रदर्शित होती हैं):

  File "<stdin>", line 1, in <mdule> TypeError: 'str' object does not support item assignment 

उपरोक्त कोड क्रैश और पायथन रिपोर्ट करता है कि str इस परिवर्तन का समर्थन नहीं करता है, जो प्रकार str की अपरिवर्तनीयता की परिभाषा से मेल खाता है।

एक उदाहरण के साथ, एक उत्परिवर्तित वस्तु के साथ तुलना करें:

 >>> my_list = [1, 2, 3] >>> id(my_list) 140637819575368 >>> my_list.append(4) >>> my_list [1, 2, 3, 4] >>> id(my_list) 140637819575368 

यह कोड दो प्रकार की वस्तुओं के बीच मुख्य अंतर को प्रदर्शित करता है। प्रारंभ में, my_list पास एक आईडी है। सूची में 4 जोड़ने के बाद भी, my_list अभी भी समान आईडी है। कारण यह है कि टाइप list परस्पर है।

यहां असाइनमेंट का उपयोग करके सूची में परिवर्तनशीलता का एक और प्रदर्शन है:

 >>> my_list[0] = 0 >>> my_list [0, 2, 3, 4] >>> id(my_list) 140637819575368 

इस कोड में, हमने my_list बदल दिया और इसे पहले तत्व के रूप में 0 सेट किया। हालाँकि, इस ऑपरेशन के बाद सूची ने उसी आईडी को बनाए रखा। पायथन सीखने के हमारे मार्ग पर अगला कदम इसके पारिस्थितिकी तंत्र की खोज करना होगा।

हम चर से निपटते हैं

पायथन में चर C और C ++ में चर से मूलभूत रूप से भिन्न हैं। अनिवार्य रूप से, वे सिर्फ पायथन में मौजूद नहीं हैं। चरों की जगह नाम हैं ।

यह पांडित्य लग सकता है, और अधिकांश भाग के लिए यह है। सबसे अधिक बार, आप पायथन में चर के रूप में नाम ले सकते हैं, लेकिन आपको अंतर को समझने की आवश्यकता है। यह विशेष रूप से महत्वपूर्ण है जब आप ऐसे कठिन विषय का अध्ययन करते हैं जैसे कि संकेत।

आपके लिए इसे समझना आसान बनाने के लिए, आइए देखें कि सी में चर कैसे काम करते हैं, वे क्या प्रतिनिधित्व करते हैं, और फिर पायथन में नामों के काम के साथ तुलना करें।

चर में सी

चर x को परिभाषित करने वाला कोड लें:

 int x = 2337; 

इस छोटी रेखा का निष्पादन कई अलग-अलग चरणों में होता है:

1. एक नंबर के लिए पर्याप्त मेमोरी आवंटित करना।
   
2. इस स्मृति स्थान को 2337 का असाइनमेंट।
   
3. मैपिंग जो x इस मान को इंगित करता है।
   

एक सरलीकृत स्मृति इस तरह दिख सकती है:



यहां, चर x में 0x7f1 का नकली पता और 2337 मान है। यदि आप बाद में x का मान बदलना चाहते हैं, तो आप ऐसा कर सकते हैं:

 x = 2338; 

यह कोड चर x 2338 नए मान पर सेट करता है, जिससे पिछले मान को अधिलेखित किया जाता है। इसका मतलब है कि चर x परस्पर है । नए मान के लिए अद्यतित स्मृति योजना:



कृपया ध्यान दें कि x स्थान नहीं बदला है, केवल मूल्य ही है। यह महत्वपूर्ण है। यह हमें बताता है कि x स्मृति में एक जगह है , और केवल एक नाम नहीं है।

आप स्वामित्व की अवधारणा के भीतर भी इस मुद्दे पर विचार कर सकते हैं। एक तरफ, x स्मृति में एक स्थान का मालिक है। सबसे पहले, x एक खाली बॉक्स है जिसमें केवल एक पूर्णांक हो सकता है, जिसमें पूर्णांक मान संग्रहीत किए जा सकते हैं।

जब आप x कुछ मान देते हैं, तो आप मान को एक बॉक्स में रखते हैं जो x । यदि आप एक नया चर y शुरू करना चाहते हैं, तो आप इस लाइन को जोड़ सकते हैं:

 int y = x; 

यह कोड y नामक एक नया बॉक्स बनाता है और इसमें x से वैल्यू को कॉपी करता है। अब मेमोरी सर्किट इस तरह दिखता है:



नए स्थान पर ध्यान दें y - 0x7f5 । यद्यपि मान x को x कॉपी किया गया था, लेकिन चर y स्मृति में एक नया पता है। इसलिए, आप x को प्रभावित किए बिना y के मूल्य को ओवरराइट कर सकते हैं:

 y = 2339; 

अब मेमोरी सर्किट इस तरह दिखता है:



मैं दोहराता हूं: आपने y का मान बदल दिया है, लेकिन स्थान नहीं। इसके अलावा, आपने मूल चर x को प्रभावित नहीं किया।

पायथन में नामों के साथ, स्थिति पूरी तरह से अलग है।

पायथन में नाम

पाइथन में कोई चर नहीं हैं, इसके बजाय नाम हैं। आप अपने विवेकानुसार "चर" शब्द का उपयोग कर सकते हैं, हालांकि चर और नामों के बीच अंतर जानना महत्वपूर्ण है।

आइए उपरोक्त C उदाहरण से समान कोड लें और इसे Python में लिखें:

 >>> x = 2337 

सी में के रूप में, कोड इस के निष्पादन के दौरान कई अलग-अलग चरणों से गुजरता है:

1. PyObject बनाया गया है।
   
2. PyObject के लिए नंबर को एक टाइपबॉक्स सौंपा गया है।
   
3. 2337 PyObject के लिए एक मान दिया गया है।
   
4. x नाम बनाया गया है।
5. x नए PyObject की ओर इशारा करता है।
6. PyObject की संदर्भ गणना 1 से बढ़ाई गई है।
   

नोट : PyObject Python में ऑब्जेक्ट के समान नहीं है, यह इकाई CPython के लिए विशिष्ट है और सभी Python ऑब्जेक्ट्स की मूल संरचना का प्रतिनिधित्व करता है।

PyObject को एक C- संरचना के रूप में परिभाषित किया गया है, इसलिए यदि आप आश्चर्य करते हैं कि आप सीधे टाइपबॉक्स या संदर्भ काउंटर को कॉल क्यों नहीं कर सकते हैं, तो इसका कारण यह है कि आपके पास संरचनाओं तक सीधी पहुंच नहीं है। Sys.getrefcount () जैसी कॉलिंग पद्धतियाँ कुछ प्रकार के आंतरिक सामान प्राप्त करने में मदद कर सकती हैं।

यदि हम स्मृति के बारे में बात करते हैं, तो यह इस तरह दिख सकता है:



यहाँ, ऊपर दिखाए गए C में सर्किट से मेमोरी सर्किट बहुत अलग है। 2337 मान को संग्रहीत करने वाले स्मृति का एक खंड होने के बजाय, एक नया बनाया गया पायथन ऑब्जेक्ट स्मृति का स्वामी है जो 2337 रहता है। पायथन नाम x स्मृति में सीधे किसी भी पते का मालिक नहीं है, जैसे कि एक सी वैरिएबल एक स्थिर सेल का मालिक है।

यदि आप x नया मान देना चाहते हैं, तो इस कोड को आज़माएँ:

 >>> x = 2338 

सिस्टम का व्यवहार सी में क्या होता है, उससे अलग होगा, लेकिन यह पायथन में मूल बाँध से बहुत अलग नहीं होगा।

इस कोड में:

• एक नया PyObject बनाया गया है।
  
• PyObject के लिए नंबर को एक टाइपबॉक्स सौंपा गया है।
  
• 2 PyObject के लिए एक मान दिया गया है।
  
• x नए PyObject की ओर इशारा करता है।
  
• नए PyObject की संदर्भ गणना 1 से बढ़ाई गई है।
  
• पुराने PyObject की संदर्भ संख्या 1 से कम हो गई है।
  

अब मेमोरी सर्किट इस तरह दिखता है:



यह चित्रण दर्शाता है कि x किसी वस्तु के संदर्भ में इंगित करता है और पहले की तरह स्मृति क्षेत्र का मालिक नहीं है। आप यह भी देखते हैं कि कमांड x = 2338 एक असाइनमेंट नहीं है, बल्कि लिंक के नाम x का बाइंडिंग है।

इसके अलावा, पिछली ऑब्जेक्ट (मान 2337 युक्त) अब 0 की संदर्भ संख्या के साथ मेमोरी में है, और कचरा कलेक्टर द्वारा हटा दिया जाएगा।

आप एक नया नाम y दर्ज कर सकते हैं, जैसा कि C उदाहरण में:

 >>> y = x 

एक नया नाम स्मृति में दिखाई देगा, लेकिन जरूरी नहीं कि एक नई वस्तु:



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

 >>> y is x True 

यह कोड दिखाता है कि x और y एक वस्तु हैं। लेकिन कोई गलती न करें: y अभी भी अपरिवर्तनीय है। उदाहरण के लिए, आप y साथ एक अतिरिक्त ऑपरेशन कर सकते हैं:

 >>> y += 1 >>> y is x False 

इसके अलावा कहा जाता है, आप एक नया पायथन ऑब्जेक्ट वापस कर देंगे। अब स्मृति इस तरह दिखती है:



एक नई वस्तु बनाई गई है, और y अब इसे इंगित करता है। यह उत्सुक है कि अगर हम सीधे सीधे y से 2339 तो हमें वही अंतिम स्थिति मिलेगी।

 >>> y = 2339 

इस अभिव्यक्ति के बाद, हम स्मृति की ऐसी अंतिम स्थिति प्राप्त करते हैं, जैसे कि अतिरिक्त संचालन में। आपको याद दिला दूं कि पायथन में आप वैरिएबल असाइन नहीं करते हैं, लेकिन नामों को लिंक से बांधते हैं।

पायथन में इंटर्न के बारे में

अब आप समझते हैं कि पायथन में नई वस्तुएं कैसे बनाई जाती हैं और उनसे कैसे नाम जुड़े होते हैं। यह आंतरिक वस्तुओं के बारे में बात करने का समय है।

हमारे पास यह पायथन कोड है:

 >>> x = 1000 >>> y = 1000 >>> x is y True 

पहले की तरह, x और y समान पायथन ऑब्जेक्ट की ओर इशारा करने वाले नाम हैं। लेकिन 1000 मान वाले इस ऑब्जेक्ट में हमेशा एक ही मेमोरी एड्रेस नहीं हो सकता है। उदाहरण के लिए, यदि आप दो नंबर जोड़ते हैं और 1000 प्राप्त करते हैं, तो आपको एक और पता मिलेगा:

 >>> x = 1000 >>> y = 499 + 501 >>> x is y False 

इस बार, स्ट्रिंग x is y रिटर्न False । अगर आप शर्मिंदा हैं, तो चिंता न करें। इस कोड के निष्पादित होने पर क्या होता है:

1. एक पायथन ऑब्जेक्ट बनाया जाता है ( 1000 )।
   
2. इसे x नाम दिया गया है।
   
3. एक पायथन ऑब्जेक्ट बनाया गया है ( 499 )।
   
4. एक पायथन ऑब्जेक्ट बनाया गया है ( 501 )।
   
5. इन दो वस्तुओं को जोड़ते हैं।
   
6. एक नया पायथन ऑब्जेक्ट बनाया गया है ( 1000 )।
   
7. उसे y नाम दिया गया है।
   

तकनीकी स्पष्टीकरण : वर्णित चरण केवल तभी होते हैं जब इस कोड को आरईपीएल के अंदर निष्पादित किया जाता है। यदि आप उपरोक्त उदाहरण लेते हैं, तो इसे फ़ाइल में पेस्ट करें और इसे चलाएं, फिर लाइन x is y , True वापस आ जाएगी।

इसका कारण सीपीथॉन कंपाइलर की त्वरित बुद्धि है, जो कि पीपलहोल्ड ऑप्टिमाइज़ेशन करने की कोशिश करता है जो कोड निष्पादन चरणों को यथासंभव बचाने में मदद करता है। विवरण पाॅफोल ऑप्टिमाइजर सीपीथॉन के स्रोत कोड में पाया जा सकता है।

लेकिन वह बेकार नहीं है? ठीक है, हाँ, लेकिन आप पायथन के सभी महान लाभों के लिए इस कीमत का भुगतान करते हैं। आपको ऐसी मध्यवर्ती वस्तुओं को हटाने के बारे में सोचने की आवश्यकता नहीं है, और आपको उनके अस्तित्व के बारे में जानने की भी आवश्यकता नहीं है! मज़ाक यह है कि ये ऑपरेशन अपेक्षाकृत जल्दी किए जाते हैं, और आप उस पल के बारे में नहीं जानते होंगे।

पायथन के रचनाकारों ने समझदारी से इस ओवरहेड को देखा और कई अनुकूलन करने का फैसला किया। उनका परिणाम व्यवहार है जो शुरुआती लोगों को आश्चर्यचकित कर सकता है:

 >>> x = 20 >>> y = 19 + 1 >>> x is y True 

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

पायथन कार्यान्वयन किन वस्तुओं पर निर्भर करता है? CPython 3.7 में, प्रशिक्षु हैं:

1. -5 से 256 तक के 256 ।
   
2. केवल ASCII अक्षर, संख्या या अंडरस्कोर वाले स्ट्रिंग्स।
   

ऐसा इसलिए है क्योंकि ये चर कई कार्यक्रमों में अक्सर उपयोग किए जाते हैं। इंटर्निंग करके, पायथन लगातार वस्तुओं के लिए स्मृति आवंटन को रोकता है।

आकार में 20 से कम वर्णों वाली लाइनें और ASCII अक्षर, संख्या या अंडरस्कोर शामिल हैं, क्योंकि उन्हें पहचानकर्ता के रूप में उपयोग किया जाना चाहिए:

 >>> s1 = "realpython" >>> id(s1) 140696485006960 >>> s2 = "realpython" >>> id(s2) 140696485006960 >>> s1 is s2 True 

यहाँ s1 और s2 स्मृति में समान पते की ओर इशारा करते हैं। यदि हम एक ASCII पत्र, संख्या या अंडरस्कोर नहीं डालते हैं, तो हमें एक अलग परिणाम मिलेगा:

 >>> s1 = "Real Python!" >>> s2 = "Real Python!" >>> s1 is s2 False 

यह उदाहरण एक विस्मयादिबोधक बिंदु का उपयोग करता है, इसलिए तार को नजरबंद नहीं किया जाता है और स्मृति में विभिन्न ऑब्जेक्ट होते हैं।

बोनस : यदि आप चाहते हैं कि ये वस्तुएं उसी आंतरिक वस्तु को देखें, तो आप sys.intern() उपयोग कर सकते हैं। इस सुविधा का उपयोग करने का एक तरीका प्रलेखन में वर्णित है:

शब्दकोश खोज प्रदर्शन में थोड़ी वृद्धि के लिए स्ट्रिंग इंटर्निंग उपयोगी है: यदि शब्दकोश में कुंजी और खोज की जाने वाली कुंजी को नजरबंद किया जाता है, तो कुंजी तुलना (हैशिंग के बाद) तार के बजाय बिंदुओं की तुलना करके की जा सकती है। ( स्रोत )

प्रशिक्षक अक्सर प्रोग्रामर को भ्रमित करते हैं। बस याद रखें कि यदि आप संदेह करना शुरू करते हैं, तो आप हमेशा id() उपयोग कर सकते हैं और वस्तुओं की समानता का निर्धारण कर सकते हैं।

पायथन पॉइंटर इम्यूलेशन

तथ्य यह है कि पायथन में मूल रूप से अनुपस्थित बिंदुओं का मतलब यह नहीं है कि आप पॉइंटर्स का लाभ नहीं उठा सकते हैं। वास्तव में पायथन में इंगित करने के कई तरीके हैं। यहाँ हम उनमें से दो को देखते हैं:

1. पॉइंटर्स के रूप में परिवर्तनशील प्रकारों का उपयोग करें।
   
2. विशेष रूप से तैयार पायथन वस्तुओं का उपयोग करना।
   

म्यूटेबल टाइप पॉइंटर्स के रूप में उपयोग करें

आप पहले से ही जानते हैं कि क्या परिवर्तनशील प्रकार हैं। यह उनकी परिवर्तनशीलता के लिए धन्यवाद है कि हम संकेत के व्यवहार का अनुकरण कर सकते हैं। मान लें कि आपको इस कोड को दोहराने की आवश्यकता है:

 void add_one(int *x) { *x += 1; } 

यह कोड एक पॉइंटर को एक संख्या ( *x ) तक ले जाता है और 1 से मूल्य बढ़ाता है। यहाँ कोड निष्पादित करने का मुख्य कार्य है:

 #include <stdi.h> int main(void) { int y = 2337; printf("y = %d\n", y); add_one(&y); printf("y = %d\n", y); return 0; } 

उपरोक्त खंड में, हमने y को 2337 असाइन किया, वर्तमान मान प्रदर्शित किया, इसे 1 से बढ़ाया, और फिर एक नया मान प्रदर्शित किया। निम्नलिखित स्क्रीन पर दिखाई देता है:

 y = 2337 y = 2338 

पायथन में इस व्यवहार को दोहराने का एक तरीका है एक परस्पर प्रकार का उपयोग करना। उदाहरण के लिए, एक सूची लागू करें और पहला तत्व बदलें:

 >>> def add_one(x): ... x[0] += 1 ... >>> y = [2337] >>> add_one(y) >>> y[0] 2338 

यहाँ add_one(x) पहले तत्व को संदर्भित करता है और 1 से इसके मूल्य को बढ़ाता है। सूची का उपयोग करने का अर्थ है कि परिणामस्वरूप हमें परिवर्तित मूल्य मिलता है। तो पायथन में संकेत हैं? नहीं। वर्णित व्यवहार संभव हो गया क्योंकि सूची एक उत्परिवर्ती प्रकार है। यदि आप एक टपल का उपयोग करने का प्रयास करते हैं, तो आपको एक त्रुटि मिलती है:

 >>> z = (2337,) >>> add_one(z) 

बैक ट्रेस (सबसे हालिया कॉल अंतिम चलते हैं):

  File "<stdin>", line 1, in <module> File "<stdin>", line 2, in add_one TypeError: 'tuple' object does not support item assignment 

यह कोड टपल की अपरिहार्यता को प्रदर्शित करता है, इसलिए यह तत्व असाइनमेंट का समर्थन नहीं करता है।

list केवल उत्परिवर्तनीय प्रकार नहीं है, हिस्सा सूचक भी तानाशाह का उपयोग करके अनुकरण किया जाता है।

मान लीजिए कि आपके पास एक एप्लिकेशन है जो दिलचस्प घटनाओं की घटना को ट्रैक करना चाहिए। यह एक शब्दकोश बनाने और काउंटर के रूप में इसके तत्वों में से एक का उपयोग करके किया जा सकता है:

 >>> counters = {"func_calls": 0} >>> def bar(): ... counters["func_calls"] += 1 ... >>> def foo(): ... counters["func_calls"] += 1 ... bar() ... >>> foo() >>> counters["func_calls"] 2 

इस उदाहरण में, फ़ंक्शन फ़ंक्शन कॉल की संख्या को ट्रैक करने के लिए शब्दकोश काउंटरों का उपयोग करता है। foo() कॉल करने के बाद foo() काउंटर में उम्मीद के foo() 2 की वृद्धि हुई। और सभी dict लिए धन्यवाद।

मत भूलो, यह केवल सूचक व्यवहार का एक अनुकरण है, इसका सी और सी ++ में वास्तविक संकेत से कोई लेना-देना नहीं है। हम कह सकते हैं कि इन ऑपरेशनों की तुलना में अधिक महंगा है अगर वे सी या सी ++ में प्रदर्शन किए गए थे।

पायथन ऑब्जेक्ट्स का उपयोग करना

पाइथन में पॉइंटर्स का अनुकरण करने के लिए dict एक शानदार तरीका है, लेकिन कभी-कभी यह याद रखना कठिन होता है कि आपने किस प्रमुख नाम का उपयोग किया है। खासकर यदि आप एप्लिकेशन के विभिन्न हिस्सों में शब्दकोश का उपयोग करते हैं। एक कस्टम पायथन वर्ग यहां मदद कर सकता है।

मान लीजिए कि आपको किसी एप्लिकेशन में मीट्रिक ट्रैक करने की आवश्यकता है। कष्टप्रद विवरणों को अनदेखा करने का एक शानदार तरीका एक वर्ग बनाना है:

 class Metrics(object): def __init__(self): self._metrics = { "func_calls": 0, "cat_pictures_served": 0, } 

यह कोड Metrics वर्ग को परिभाषित करता है। यह अभी भी अप-टू-डेट डेटा संग्रहीत करने के लिए शब्दकोश का उपयोग करता है जो कि _metrics सदस्य _metrics में निहित है। यह आपको आवश्यक परिवर्तनशीलता प्रदान करेगा। अब आपको केवल इन मूल्यों तक पहुंचने की आवश्यकता है। आप गुणों का उपयोग करके ऐसा कर सकते हैं:

 class Metrics(object): # ... @property def func_calls(self): return self._metrics["func_calls"] @property def cat_pictures_served(self): return self._metrics["cat_pictures_served"] 

यहाँ हम @property का उपयोग करते हैं। यदि आप डेकोरेटर के लिए नए हैं, तो पायथन डेकोरेटर्स लेख पर प्राइमर पढ़ें। इस मामले में, @property डेकोरेटर आपको func_calls और cat_pictures_served का उपयोग करने की अनुमति देता है, जैसे कि वे विशेषताएँ थे:

 >>> metrics = Metrics() >>> metrics.func_calls 0 >>> metrics.cat_pictures_served 0 

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

 class Metrics(object): # ... def inc_func_calls(self): self._metrics["func_calls"] += 1 def inc_cat_pics(self): self._metrics["cat_pictures_served"] += 1 

:

1. inc_func_calls()
2. inc_cat_pics()

metrics . , , :

 >>> metrics = Metrics() >>> metrics.inc_func_calls() >>> metrics.inc_func_calls() >>> metrics.func_calls 2 

func_calls inc_func_calls() Python. , - metrics , .

: , inc_func_calls() inc_cat_pics() @property.setter int , .

Metrics :

 class Metrics(object): def __init__(self): self._metrics = { "func_calls": 0, "cat_pictures_served": 0, } @property def func_calls(self): return self._metrics["func_calls"] @property def cat_pictures_served(self): return self._metrics["cat_pictures_served"] def inc_func_calls(self): self._metrics["func_calls"] += 1 def inc_cat_pics(self): self._metrics["cat_pictures_served"] += 1 

ctypes

, - Python, CPython? ctypes , C. ctypes, Extending Python With C Libraries and the «ctypes» Module .

, , . - add_one() :

 void add_one(int *x) { *x += 1; } 

, x 1. , (shared) . , add.c , gcc:

 $ gcc -c -Wall -Werror -fpic add.c $ gcc -shared -o libadd1.so add.o 

C add.o . libadd1.so .

libadd1.so . ctypes Python:

 >>> import ctypes >>> add_lib = ctypes.CDLL("./libadd1.so") >>> add_lib.add_one <_FuncPtr object at 0x7f9f3b8852a0> 

ctypes.CDLL , libadd1 . add_one() , , Python-. , . Python , .

, ctypes :

 >>> add_one = add_lib.add_one >>> add_one.argtypes = [ctypes.POINTER(ctypes.c_int)] 

, C. , , :

 >>> add_one(1) Traceback (most recent call last): File "<stdin>", line 1, in <module> ctypes.ArgumentError: argument 1: <class 'TypeError'>: \ expected LP_c_int instance instead of int 

Python , add_one() , . , ctypes . :

 >>> x = ctypes.c_int() >>> x c_int(0) 

x 0 . ctypes byref() , .

: .

, . , .

add_one() :

 >>> add_one(ctypes.byref(x)) 998793640 >>> x c_int(1) 

बहुत बढ़िया! 1. , Python .

निष्कर्ष

Python . , Python.

Python:

• .
  
• Python- .
  
• ctypes.
  

Python .