जारी रखा जाए। सी ++ के अंतिम मामले के रूप में पायथन में शुरुआत । भाग 1/2 ”।

चर और डेटा प्रकार

अब जब हम अंततः गणित का पता लगा लेते हैं, तो चलिए तय करते हैं कि हमारी भाषा में चर का क्या अर्थ होना चाहिए।

C ++ में, एक प्रोग्रामर के पास एक विकल्प होता है: स्टैक पर रखे गए स्वचालित चर का उपयोग करें, या प्रोग्राम डेटा मेमोरी में मान रखें, इन मानों को केवल स्टैक पर रखें। क्या होगा यदि हम पायथन के लिए इनमें से केवल एक विकल्प चुनते हैं?

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

तो अभिव्यक्ति

a = 3 

इसका मतलब यह होगा कि हमने प्रोग्राम डेटा मेमोरी (तथाकथित "हीप") में एक ऑब्जेक्ट "3" बनाया और नाम "ए" को इसका संदर्भ बनाया। और अभिव्यक्ति

 b = a 

इस स्थिति में, इसका मतलब यह होगा कि हमने चर "बी" को मेमोरी में उसी ऑब्जेक्ट को संदर्भित करने के लिए मजबूर किया है जो "ए" को संदर्भित करता है, दूसरे शब्दों में, हमने पॉइंटर की नकल की।

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

हमें कितने प्रकार के हैश टेबल लागू करने की आवश्यकता है? (पायथन में, इस प्रकार को "शब्दकोश" कहा जाता है - dict ।) एक! मानों की ओर संकेत करने वाले बिंदुओं से इसे संबद्ध करने दें।

इस प्रकार, हमें अपनी भाषा में C ++ विनिर्देशन - टेम्पलेट्स का एक बड़ा हिस्सा लागू करने की आवश्यकता नहीं है, क्योंकि हम वस्तुओं पर सभी संचालन करते हैं, और ऑब्जेक्ट हमेशा पॉइंटर द्वारा पहुंच योग्य होते हैं। बेशक, पायथन में लिखे गए कार्यक्रमों में खुद को पॉइंटर्स के साथ काम करने के लिए सीमित नहीं करना पड़ता है: न्यूमपी जैसे पुस्तकालय हैं, जिसके साथ वैज्ञानिक मेमोरी में डेटा सरणियों के साथ काम करते हैं, जैसे वे फोरट्रान में होंगे। लेकिन भाषा का आधार - "a = 3" जैसे भाव - हमेशा संकेत के साथ काम करते हैं।

"सब कुछ एक संकेतक है" की अवधारणा भी सीमा के प्रकारों की संरचना को सरल बनाती है। शब्दकोशों की एक सूची चाहते हैं? बस एक सूची बनाएं और वहां शब्दकोश डालें! आपको अनुमति के लिए अजगर से पूछने की आवश्यकता नहीं है, आपको अतिरिक्त प्रकार की घोषणा करने की आवश्यकता नहीं है, सब कुछ बॉक्स से बाहर काम करता है।

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

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

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

 def get_address(): ... return host, port host, port = get_address() 

अनपैकिंग के कई उपयोगी दुष्प्रभाव हैं, उदाहरण के लिए, चर मानों का आदान-प्रदान निम्न प्रकार से लिखा जा सकता है:

 x, y = y, x 

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

डेविड व्हीलर ने कहा: "अतिरिक्त स्तर के अप्रत्यक्ष निर्माण से सभी प्रोग्रामिंग समस्याएं हल हो जाती हैं।" पायथन में लिंक का उपयोग करना अप्रत्यक्षता का स्तर है जो पारंपरिक रूप से C ++ सहित कई भाषाओं में कई समस्याओं को हल करने के लिए उपयोग किया गया है। लेकिन अगर यह स्पष्ट रूप से वहां उपयोग किया जाता है, और यह कार्यक्रमों को जटिल करता है, तो पायथन में इसका उपयोग अंतर्निहित रूप से, समान रूप से सभी प्रकार के डेटा के संबंध में किया जाता है, और उपयोगकर्ता के अनुकूल है।

लेकिन अगर सब कुछ एक कड़ी है, तो ये लिंक किस चीज का उल्लेख करते हैं? C ++ जैसी भाषाओं के कई प्रकार होते हैं। आइए पायथन में केवल एक डेटा प्रकार छोड़ें - एक ऑब्जेक्ट! प्रकार सिद्धांत के क्षेत्र में विशेषज्ञ अपने सिर को निराशाजनक रूप से हिलाते हैं, लेकिन मेरा मानना ​​है कि एक स्रोत डेटा प्रकार, जिसमें से भाषा के अन्य सभी प्रकार व्युत्पन्न हैं, एक अच्छा विचार है जो भाषा की एकरूपता और इसके उपयोग में आसानी सुनिश्चित करता है।

विशिष्ट मेमोरी सामग्री के लिए, विभिन्न पायथन कार्यान्वयन (PyPy, Jython, या MicroPython) विभिन्न तरीकों से मेमोरी का प्रबंधन कर सकते हैं। लेकिन बेहतर मानसिक मॉडल बनाने के लिए पायथन सादगी और एकरूपता को कैसे लागू किया जाए, यह बेहतर ढंग से समझने के लिए, सी के रूप में सीपीथॉन में पायथन संदर्भ कार्यान्वयन को चालू करना बेहतर है, जिसे हम python.org पर डाउनलोड कर सकते हैं।

 struct { struct _typeobject *ob_type; /* followed by object's data */ } 

हम सीपीथॉन स्रोत कोड में जो देखेंगे, वह एक संरचना है जिसमें एक दिए गए चर के प्रकार और एक पेलोड के बारे में जानकारी के लिए एक सूचक होता है जो चर के विशिष्ट मूल्य को परिभाषित करता है।

जानकारी कैसे काम करती है? आइए फिर से सीपीथॉन स्रोत कोड में खुदाई करें।

 struct _typeobject { /* ... */ getattrfunc tp_getattr; setattrfunc tp_setattr; /* ... */ newfunc tp_new; freefunc tp_free; /* ... */ binaryfunc nb_add; binaryfunc nb_subtract; /* ... */ richcmpfunc tp_richcompare; /* ... */ } 

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

यह C और C ++ से मौलिक रूप से भिन्न है, जिसमें प्रकार की जानकारी नामों से जुड़ी होती है, न कि चर के मान से। पायथन में, सभी नाम लिंक से जुड़े हैं। संदर्भ द्वारा मूल्य, बदले में, प्रकार का है। यह गतिशील भाषाओं का सार है।

भाषा की सभी विशेषताओं का एहसास करने के लिए, लिंक पर दो संचालन को परिभाषित करना हमारे लिए पर्याप्त है। सबसे स्पष्ट में से एक नकल है। जब हम एक वैरिएबल, एक शब्दकोश में एक स्लॉट, या किसी ऑब्जेक्ट की विशेषता के लिए एक मान प्रदान करते हैं, तो हम लिंक को कॉपी करते हैं। यह एक सरल, तेज और पूरी तरह से सुरक्षित संचालन है: लिंक की प्रतिलिपि बनाने से ऑब्जेक्ट की सामग्री नहीं बदलती है।

दूसरा ऑपरेशन एक फ़ंक्शन या विधि कॉल है। जैसा कि हमने ऊपर दिखाया, एक पायथन प्रोग्राम केवल अंतर्निहित वस्तुओं में लागू किए गए तरीकों के माध्यम से मेमोरी के साथ बातचीत कर सकता है। इसलिए, यह मेमोरी एक्सेस से संबंधित त्रुटि का कारण नहीं बन सकता है।

आपके पास एक प्रश्न हो सकता है: यदि सभी चर में संदर्भ होते हैं, तो मैं एक पैरामीटर के रूप में फ़ंक्शन को पास करके परिवर्तन के चर के मूल्य की रक्षा कैसे कर सकता हूं?

 n = 3 some_function(n) # Q: I just passed a pointer! # Could some_function() have changed “3”? 

इसका उत्तर यह है कि पायथन में सरल प्रकार अपरिवर्तनीय हैं: वे बस उस विधि को लागू नहीं करते हैं जो उनके मूल्य को बदलने के लिए जिम्मेदार है। अपरिवर्तनीय (अपरिवर्तनीय) int , float , tuple या str को भाषाओं में प्रदान करते हैं जैसे "सब कुछ एक सूचक है" समान अर्थ प्रभाव है जो स्वचालित चर सी में प्रदान करते हैं।

एकीकृत प्रकार और विधियां सामान्यीकृत प्रोग्रामिंग, या जेनरिक के उपयोग को सरल बनाती हैं, जितना संभव हो। फ़ंक्शन min() , max() , sum() और जैसे बिल्ट-इन हैं, उन्हें आयात करने की कोई आवश्यकता नहीं है। और वे किसी भी डेटा प्रकार के साथ काम करते हैं जिसमें min() और max() लिए तुलना संचालन, sum() लिए परिवर्धन sum() , आदि शामिल हैं।

ऑब्जेक्ट बनाएँ

हमने सामान्य शब्दों में पाया कि वस्तुओं को कैसे व्यवहार करना चाहिए। अब हम यह निर्धारित करेंगे कि हम उन्हें कैसे बनाएंगे। यह भाषा वाक्य रचना का विषय है। C ++ ऑब्जेक्ट बनाने के लिए कम से कम तीन तरीकों का समर्थन करता है:

1. स्वचालित, इस वर्ग का एक चर घोषित करके:
   

    my_class c(arg); 

2. new ऑपरेटर का उपयोग करना:
   

    my_class *c = new my_class(arg); 

3. फैक्टरी, एक मनमाना फ़ंक्शन कॉल करके जो एक पॉइंटर लौटाता है:
   

    my_class *c = my_factory(arg); 

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

उसी पुस्तक द गैंग्स ऑफ फोर से हमने सीखा कि वस्तुओं को बनाने के लिए एक कारखाना सबसे लचीला और सार्वभौमिक तरीका है। इसलिए, केवल पायथन में इस पद्धति को लागू किया गया है।

सार्वभौमिकता के अलावा, यह विधि इस मायने में अच्छी है कि आपको यह सुनिश्चित करने के लिए अनावश्यक वाक्यविन्यास के साथ भाषा को अधिभारित करने की आवश्यकता नहीं है: एक फ़ंक्शन कॉल हमारी भाषा में पहले से ही लागू है, और एक कारखाना फ़ंक्शन से अधिक कुछ नहीं है।

पायथन में ऑब्जेक्ट्स बनाने का एक और नियम यह है: कोई भी डेटा प्रकार का अपना कारखाना है। बेशक, आप किसी भी अतिरिक्त, कस्टम कारखानों की संख्या लिख ​​सकते हैं (जो सामान्य कार्य या तरीके होंगे, बेशक), लेकिन सामान्य नियम मान्य रहेगा:

 # Let's make type objects # their own type's factories! c = MyClass() i = int('7') f = float(length) s = str(bytes) 

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

इस प्रकार, भाषा के केवल मूल वाक्यविन्यास का उपयोग करते हुए, वस्तुओं को बनाते समय कोई हेरफेर, जैसे कि "एरिना" या "अनुकूली" पैटर्न, को संक्षिप्त किया जा सकता है, क्योंकि C ++ से उधार लिया गया एक और महान विचार यह है कि प्रकार स्वयं निर्धारित करता है कि यह कैसे होता है new ऑब्जेक्ट उसके लिए कैसे काम करते हैं, इसके ऑब्जेक्ट्स को spawning।

NULL के बारे में कैसे?

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

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

आप पूछ सकते हैं: "अगर वस्तुओं पर संचालन की संरचना अपरिवर्तित है, जैसा कि हमने पहले देखा था, तो उपयोगकर्ता इस संरचना में सूचीबद्ध नहीं किए गए तरीकों और विशेषताओं के साथ अपनी कक्षाएं कैसे बनाएंगे?"

जादू इस तथ्य में निहित है कि कस्टम कक्षाओं के लिए पायथन में बहुत ही सरल "तैयारी" है, जिसमें बहुत कम संख्या में तरीकों को लागू किया गया है। यहाँ सबसे महत्वपूर्ण हैं:

 struct _typeobject { getattrfunc tr_getattr; setattrfunc tr_setattr; /* ... */ newfunc tp_new; /* ... */ } 

tp_new() उपयोगकर्ता वर्ग के लिए एक हैश तालिका बनाता है, जो tp_new() प्रकार के लिए है। tp_getattr() इस हैश टेबल से कुछ निकालता है, और tp_setattr() , इसके विपरीत, वहाँ कुछ डालता है। इस प्रकार, किसी भी तरीके और विशेषताओं को संग्रहीत करने के लिए मनमानी कक्षाओं की क्षमता सी भाषा संरचनाओं के स्तर पर नहीं, बल्कि उच्च स्तर पर प्रदान की जाती है - एक हैश तालिका। (बेशक, प्रदर्शन अनुकूलन से संबंधित कुछ मामलों के अपवाद के साथ।)

पहुँच संशोधक

हम उन सभी नियमों और अवधारणाओं के साथ क्या करते हैं जो C ++ कीवर्ड के आसपास private और protected ? पायथन, एक स्क्रिप्टिंग भाषा होने के नाते, उन्हें ज़रूरत नहीं है। हमारे पास पहले से ही भाषा के "संरक्षित" भाग हैं - ये बिल्ट-इन प्रकार के डेटा हैं। किसी भी परिस्थिति में पायथन एक कार्यक्रम की अनुमति नहीं देगा, उदाहरण के लिए, एक फ्लोटिंग-पॉइंट संख्या के बिट्स में हेरफेर करने के लिए! भाषा की अखंडता को बनाए रखने के लिए एनकैप्सुलेशन का यह स्तर पर्याप्त है। हम, पायथन के रचनाकारों का मानना ​​है कि जानकारी को छिपाने के लिए भाषा की अखंडता एकमात्र अच्छा बहाना है। अन्य सभी संरचनाओं और उपयोगकर्ता प्रोग्राम डेटा को सार्वजनिक माना जाता है।

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

मेमोरी प्रबंधन

निचले स्तर पर हमारी वस्तुओं, संख्याओं और तारों का क्या होता है? वे वास्तव में स्मृति में कैसे संग्रहीत किए जाते हैं, कैसे सीपीथॉन उन्हें साझा पहुंच प्रदान करता है, वे कब और किन परिस्थितियों में नष्ट हो जाते हैं?

और इस मामले में, हमने मेमोरी के साथ काम करने का सबसे सामान्य, अनुमानित और उत्पादक तरीका चुना: सी-प्रोग्राम की तरफ से, हमारे सभी ऑब्जेक्ट्स साझा किए गए पॉइंटर्स हैं ।

इस ज्ञान को ध्यान में रखते हुए, डेटा संरचनाएं जो हमने पहले "चर और डेटा प्रकार" अनुभाग में जांच की थीं, उन्हें निम्नानुसार पूरक किया जाना चाहिए:

 struct { Py_ssize_t ob_refcnt; struct { struct _typeobject *ob_type; /* followed by object's data */ } } 

इसलिए, पायथन में हर वस्तु (हमारा मतलब है कि CPython का कार्यान्वयन, निश्चित रूप से) का अपना संदर्भ काउंटर है। एक बार जब यह शून्य हो जाता है, तो ऑब्जेक्ट को हटाया जा सकता है।

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

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

अजगर डेवलपर त्रुटियों

हमने एक ऐसी भाषा विकसित करने की कोशिश की जो शुरुआती लोगों के लिए पर्याप्त सरल हो, लेकिन पेशेवरों के लिए भी पर्याप्त आकर्षक हो। उसी समय, हम उन उपकरणों को समझने और उनका उपयोग करने में गलतियों से बचने में सक्षम नहीं थे जो हमने खुद बनाए थे।

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

 >>> 'byte string ' + u'unicode string' u'byte string unicode string' 

नतीजतन, कुछ वेबसाइटों ने ठीक काम किया, जबकि उनके उपयोगकर्ता अंग्रेजी का उपयोग कर रहे थे, लेकिन अन्य वर्णमाला के पात्रों का उपयोग करते समय उन्होंने क्रिप्टिक त्रुटियों का उत्पादन किया।

पायथन 3 में यह भाषा डिज़ाइन बग तय किया गया है:

 >>> b'byte string ' + u'unicode string' TypeError: can't concat bytes to str 

पायथन 2 में एक समान त्रुटि अतुलनीय तत्वों से युक्त सूचियों के "भोले" छाँटने से संबंधित थी:

 >>> sorted(['b', 1, 'a', 2]) [1, 2, 'a', 'b'] 

इस मामले में पायथन 3 उपयोगकर्ता को स्पष्ट करता है कि वह कुछ सार्थक करने की कोशिश कर रहा है:

 >>> sorted(['b', 1, 'a', 2]) TypeError: unorderable types: int() < str() 

हनन

उपयोगकर्ता अब और फिर कभी-कभी पायथन भाषा की गतिशील प्रकृति का दुरुपयोग करते हैं, और फिर, 90 के दशक में, जब सर्वोत्तम प्रथाओं को अभी तक व्यापक रूप से नहीं जाना गया था, यह विशेष रूप से अक्सर होता है:

 class Address(object): def __init__(self, host, port): self.host = host self.port = port 

"लेकिन यह इष्टतम नहीं है!" - कुछ ने कहा, "क्या होगा यदि पोर्ट डिफ़ॉल्ट मान से भिन्न नहीं है? वैसे भी, हम इसके भंडारण पर एक पूरी कक्षा की विशेषता खर्च करते हैं! " और परिणाम कुछ इस तरह है

 class Address(object): def __init__(self, host, port=None): self.host = host if port is not None: # so terrible self.port = port 

इसलिए, कार्यक्रम में एक ही प्रकार की वस्तुएं दिखाई देती हैं, जो कि, समान रूप से संचालित नहीं की जा सकती हैं, क्योंकि उनमें से कुछ की एक निश्चित विशेषता है, जबकि अन्य नहीं! और हम पहले से इसकी उपस्थिति की जाँच किए बिना इस विशेषता को नहीं छू सकते हैं:

 # code was forced to use introspection # (terrible!) if hasattr(addr, 'port'): print(addr.port) 

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

 # today's best practice: # every atribute always present if addr.port is not None: print(addr.port) 

तो, गतिशील रूप से जोड़े गए और हटाए गए विशेषताओं के साथ शुरुआती प्रयोग समाप्त हो गए, और अब हम पायथन में कक्षाओं को उसी तरह से देखते हैं जैसे सी ++ में।

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

 class Dataframe(object): def __init__(self, columns): if isinstance(columns, str): columns = columns.split(',') self.columns = columns 

लेकिन यह दृष्टिकोण इसकी समस्याओं को जन्म दे सकता है। उदाहरण के लिए, क्या होगा यदि कोई उपयोगकर्ता गलती से हमें एक पंक्ति देता है जिसका उपयोग स्तंभ नामों की सूची के रूप में करने का इरादा नहीं है? या यदि स्तंभ नाम में अल्पविराम होना चाहिए?

इसके अलावा, इस तरह के कोड को बनाए रखना, डिबग करना और विशेष रूप से परीक्षण करना अधिक कठिन है: परीक्षणों में यह संभव है कि हम जिन दो प्रकारों का समर्थन करते हैं उनमें से केवल एक की जांच करें, लेकिन कवरेज अभी भी 100% होगी, और हम दूसरे प्रकार का परीक्षण नहीं करेंगे।

नतीजतन, हम इस निष्कर्ष पर पहुंचे कि पायथन उपयोगकर्ता को किसी भी प्रकार के कार्यों के तर्कों को पारित करने की अनुमति देता है, लेकिन उनमें से अधिकांश स्थितियों में उसी तरह से एक फ़ंक्शन का उपयोग करेंगे जैसे कि वे सी: उसी प्रकार के एक तर्क को पास करते हैं।

एक कार्यक्रम में eval() का उपयोग करने की आवश्यकता को एक स्पष्ट वास्तुशिल्प गलत अनुमान माना जाता है। सबसे अधिक संभावना है, आपने अभी यह पता नहीं लगाया कि सामान्य तरीके से कैसे करें। − , Jupyter notebook - − eval() , Python ! , C++ .

, ( getattr() , hasattr() , isinstance() ) . , , , , : , , , !

: , . 20 , C++ Python. , , . .

, shared_ptr TensorFlow 2016 2018 .

TensorFlow − C++-, Python- ( C++ − TensorFlow, ).

TensorFlow, shared_ptr , . , .

C++? . , ? , , C++ Python!