मेरी रिपोर्ट के शीर्षक में "मार्जिनल केस" वाक्यांश का क्या अर्थ है? सीमित मामला तब उठता है जब आप विकल्पों के एक अनुक्रम पर पुनरावृति करते हैं जब तक कि आप चरम मूल्य तक नहीं पहुंचते। उदाहरण के लिए, एक तरफा बहुभुज। यदि n = 3, तो यह एक त्रिभुज है, n = 4 एक चतुर्भुज है, n = 5 एक पंचभुज है, आदि। n अनंत के निकट आने पर, पक्ष छोटे और बड़े हो जाते हैं, और बहुभुज की रूपरेखा वृत्त की तरह बन जाती है। इस प्रकार, सर्कल नियमित बहुभुज के लिए सीमित मामला है। ऐसा तब होता है जब किसी निश्चित विचार को सीमा तक लाया जाता है।

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

गैर-प्रमुख संपत्ति

मुझे 90 के दशक में पायथन में दिलचस्पी हो गई: मेरे जीवन में यह ऐसी अवधि थी जब मुझे "गैर-मुख्य संपत्ति" से छुटकारा मिल गया, जैसा कि मैं इसे कहता हूं। कई चीजें मुझे बोर करने लगीं। उदाहरण के लिए रुकावटें। याद रखें, एक बार कई कंप्यूटर बोर्डों पर जंपर्स के साथ ऐसे संपर्क थे? और आप इन जंपर्स को मैनुअल पर सेट करते हैं ताकि वीडियो कार्ड को एक उच्च प्राथमिकता रुकावट प्राप्त हो, ताकि आपका गेम तेजी से चले? इसलिए, मैं उसी समय के आस-पास malloc() और free() का उपयोग करके मेमोरी को आवंटित और मुक्त करने से थक गया था क्योंकि मैंने अपने कंप्यूटर के प्रदर्शन को जम्पर्स के साथ समायोजित करना बंद कर दिया था। यह 1997 या तो था।

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

इसलिए, 90 के दशक के उत्तरार्ध में, मैं एक प्रोग्रामिंग भाषा की तलाश कर रहा था, जो मुझे इस विषय क्षेत्र और कार्य मॉडलिंग पर ध्यान केंद्रित करने की अनुमति देगा, बजाय इस बात की चिंता किए कि मेरे कंप्यूटर की मेमोरी किस क्षेत्र में संग्रहीत है। हम प्रसिद्ध स्क्रिप्टिंग भाषाओं के पापों को दोहराए बिना C ++ को सरल कैसे बना सकते हैं?

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

वाक्य-विन्यास

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

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

बेशक, हम कुछ सुधार कर सकते हैं। जब आप प्रोग्राम टेक्स्ट में प्रतिशत चिन्ह देखते हैं तो आप क्या सोचते हैं? स्ट्रिंग प्रक्षेप के बारे में, बिल्कुल! हालाँकि % मुख्य रूप से एक मॉड्यूल कैप्चर ऑपरेटर है, यह स्ट्रिंग्स के लिए अपरिभाषित था। और यदि ऐसा है, तो फिर इसका उपयोग क्यों नहीं?

न्यूमेरिक और स्ट्रिंग शाब्दिक जो बैकस्लैश के साथ दृश्यों को नियंत्रित करते हैं - यह सब सी में दिखेगा।

निष्पादन प्रवाह नियंत्रण? वही if , else , while , break और continue । बेशक, हम डेटा संरचनाओं और मूल्य सीमाओं पर पुनरावृति के for अच्छे पुराने का सह-चयन करके थोड़ा मज़ा जोड़ेंगे। इसे बाद में C ++ 11 में प्रस्तावित किया जाएगा, लेकिन पायथन में, ऑपरेटर के for शुरू में आकार की गणना के लिए सभी ऑपरेशन, ट्रैवर्सिंग लिंक, काउंटर को बढ़ाना, आदि, दूसरे शब्दों में, सब कुछ करना जो उपयोगकर्ता को डेटा संरचना के एक तत्व के साथ प्रदान करने के लिए आवश्यक था। किस प्रकार की संरचनाएं? इससे कोई फर्क नहीं पड़ता, बस इसके लिए इसे पास करें, यह पता लगाएगा।

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

अरे हाँ! हम सी में मूल डिजाइन दोष को ठीक करेंगे - एक झूलते हुए अल्पविराम जोड़ें!

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

 If (n = 0) then begin writeln('N is now zero'); func := 1 end 

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

 int a[] = {4, 5, 6}; 

लेकिन जब आपका इनिलाइज़र लंबा हो जाता है और आप इसे लंबवत व्यवस्थित करते हैं, तो आपको पास्कल में उतनी ही असुविधाजनक विषमता मिलती है:

 int a[] = { 4, 5, 6 }; 

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

बाद में, C99 और C ++ 11 मानकों ने भी शुरुआती गलतफहमी को ठीक कर दिया, जिससे आप इनिशियलाइज़र में अंतिम शाब्दिक के बाद अल्पविराम जोड़ सकते हैं।

नामस्थान

हमें अपनी प्रोग्रामिंग लैंग्वेज में भी इस तरह के नामस्थान या नेमस्पेस को लागू करने की आवश्यकता है। यह भाषा का एक महत्वपूर्ण हिस्सा है जो हमें नाम संघर्ष जैसी गलतियों से बचाना चाहिए। हम इसे C ++ से आसान करेंगे: उपयोगकर्ता को मनमाने ढंग से नामस्थान की क्षमता देने के बजाय, हम प्रति मॉड्यूल (फ़ाइल) में एक नाम स्थान बनाएंगे और उन्हें फ़ाइल नामों के साथ नामित करेंगे। उदाहरण के लिए, यदि आप मॉड्यूल foo.py बनाते हैं, तो इसे नेमस्पेस foo असाइन किया जाएगा।

नेमस्पेस के ऐसे सरलीकृत मॉडल के साथ काम करने के लिए, एक उपयोगकर्ता को केवल एक ऑपरेटर की आवश्यकता होती है।

my_package निर्देशिका बनाएं, my_module.py फ़ाइल को my_module.py , और फ़ाइल में कक्षा घोषित करें:

 class C(object): READ = 1 WRITE = 2 

तब वर्ग विशेषताओं तक पहुंच इस प्रकार होगी:

 import my_package.my_module my_package.my_module.C.READ 

चिंता न करें, हम प्रत्येक बार उपयोगकर्ता को पूरा नाम प्रिंट करने के लिए बाध्य नहीं करेंगे। हम उन्हें नाम के "निकटता" की डिग्री को अलग करने के लिए import विवरण के कई संस्करणों का उपयोग करने का अवसर देंगे:

 import my_package.my_module my_package.my_module.C.READ from my_package import my_module my_module.C.READ from my_package.my_module import C C.READ 

इस प्रकार, विभिन्न पैकेजों में दिए गए समान नाम कभी संघर्ष नहीं करेंगे:

 import json j = json.load(file) import pickle p = pickle.load(file) 

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

कार्य अधिभार

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

सिस्टम एपीआई

हम उपयोगकर्ता को सॉकेट सहित कई सिस्टम एपीआई तक पूर्ण पहुंच प्रदान करेंगे। मुझे समझ में नहीं आता है कि स्क्रिप्टिंग भाषाओं के लेखक हमेशा सॉकेट खोलने के अपने सरल तरीके क्यों पेश करते हैं। हालांकि, उन्हें कभी भी पूर्ण यूनिक्स सॉकेट एपीआई का एहसास नहीं होता है। वे 5-6 कार्यों को लागू करते हैं जो वे समझते हैं, और बाकी सब कुछ फेंक देते हैं। पायथन, उनके विपरीत, ओएस के साथ बातचीत करने के लिए मानक मॉड्यूल हैं जो प्रत्येक मानक सिस्टम कॉल को लागू करते हैं। इसका मतलब है कि आप अभी स्टीवंस की किताब खोल सकते हैं और कोड लिखना शुरू कर सकते हैं। और आपके सभी सॉकेट, प्रक्रियाएं और कांटे ठीक वैसे ही काम करेंगे जैसे कि यह कहता है। हां, यह संभव है कि गुइडो या शुरुआती पायथन योगदानकर्ताओं ने ऐसा सिर्फ इसलिए किया, क्योंकि वे सिस्टम लाइब्रेरी के अपने कार्यान्वयन को लिखने के लिए बहुत आलसी थे, फिर भी उपयोगकर्ताओं को समझाने के लिए आलसी थे कि सॉकेट कैसे काम करते हैं। लेकिन परिणामस्वरूप, उन्होंने एक अद्भुत प्रभाव हासिल किया: आप अपने सभी UNIX ज्ञान को C और C ++ में प्राप्त पायथन पर्यावरण में स्थानांतरित कर सकते हैं।

इसलिए, हमने तय किया कि हम अपनी सरल स्क्रिप्टिंग भाषा बनाने के लिए C ++ से "उधार" क्या सुविधाएँ लेंगे। अब हमें यह तय करने की आवश्यकता है कि हम क्या तय करना चाहते हैं।

अपरिभाषित व्यवहार

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

संचालन प्राथमिकताएँ

आपको समान त्रुटियों का सामना करना पड़ा होगा: अभिव्यक्ति

 oflags & 0x80 == nflags & 0x80 

हमेशा 0 लौटाता है, क्योंकि C की तुलना बिटवाइज़ ऑपरेशंस पर पूर्वता लेती है। दूसरे शब्दों में, यह अभिव्यक्ति का मूल्यांकन करता है

 oflags & (0x80 == nflags) & 0x80 

ओह, वह सी!

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

 (oflags & 0x80) == (nflags & 0x80) 

अन्य सुधार

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

हम अपने तार्किक ऑपरेटरों ( https://en.wikipedia.org/wiki/Short-circuit_evaluation ) के लिए संक्षिप्त संगणना की संभावना छोड़ देंगे, लेकिन उन्हें केवल बूलियन नहीं, बल्कि किसी भी प्रकार के अंतिम मूल्य को वापस करने की क्षमता के साथ संपन्न करते हैं। फिर जैसे भाव

 s = error.message or 'Error' 

इस उदाहरण में, वेरिएबल को error.message सेट किया error.message यदि यह error.message है, अन्यथा स्ट्रिंग 'एरर'।

हम सी के विचार का विस्तार करते हैं कि 0 पूर्णांक के अलावा अन्य वस्तुओं के लिए झूठे के बराबर है। उदाहरण के लिए, खाली लाइनों और कंटेनरों पर।

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

सख्त बनाम कमजोर टाइपिंग

स्क्रिप्टिंग भाषा के डिजाइन में एक और महत्वपूर्ण मुद्दा: टाइपिंग की कठोरता। दर्शकों में से कई जावास्क्रिप्ट से परिचित हैं? यदि संख्या 3 को स्ट्रिंग '4' से घटाया जाए तो क्या होगा?

 js> '4' - 3 1 

बहुत बढ़िया! और यदि आप संख्या 3 को स्ट्रिंग '4' में जोड़ते हैं?

 js> '4' + 3 "43" 

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

 js> [] + [] "" js> [] + {} "[object Object]" 

हम उम्मीद करते हैं कि अतिरिक्त संचालन सराहनीय है, लेकिन बाद के मामले में शर्तों को बदलने पर क्या होगा?

 js> {} + [] 0 

जावास्क्रिप्ट अपनी समस्याओं में अकेला नहीं है। Perl एक समान स्थिति में भी कम से कम कुछ वापस करने की कोशिश करता है:

 perl> "3" + 1 4 

और awk कुछ ऐसा करेगा:

 $ echo | awk '{print "3" + 1}' 4 

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

ढीली टाइपिंग भी कोड पठनीयता को कम करती है, क्योंकि भले ही हम किसी प्रोग्राम में निहित प्रकार की कास्टिंग का सही ढंग से उपयोग करते हैं, यह किसी प्रोग्रामर के लिए अप्रत्याशित रूप से होता है।

पायथन में, सी ++ में, इस तरह के भाव एक त्रुटि लौटाएंगे।

 >>> '4' - 3 TypeError >>> '4' + 3 TypeError 

क्योंकि टाइप कास्टिंग, यदि वास्तव में आवश्यक है, तो स्पष्ट रूप से लिखना आसान है:

 >>> int('4') + 3 7 >>> '4' + str(3) '43' 

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

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

जारी: " C ++ के अंतिम मामले के रूप में पायथन। भाग 2/2 । "