"ए बनाम वी भाषा" को आगे बढ़ाने वाले कामरेडों के लिए अजगर का परिचय भाषा बी ”और अन्य पूर्वाग्रहों

सभी हेब्रच निवासियों के लिए, जिनके पास deja vu की भावना है: मुझे इस पोस्ट को "पायथन का परिचय" और इस पर टिप्पणियों द्वारा लेख लिखने के लिए प्रेरित किया गया था। दुर्भाग्य से, इस "परिचय" अहम की गुणवत्ता ... चलो उदास चीजों के बारे में बात नहीं करते हैं। लेकिन "सी ++ पायथन की तुलना में तेज है" श्रेणियों से टिप्पणियों में स्क्वैबल्स का निरीक्षण करना भी दुखद था, "रस्ट सी ++ की तुलना में भी तेज है", "पायथन की जरूरत नहीं है", आदि। यह आश्चर्यजनक है कि उन्होंने रूबी को याद नहीं किया!

जैसा कि बजरन स्ट्रॉस्ट्रप ने कहा,

"केवल दो प्रकार की प्रोग्रामिंग भाषाएं हैं: वे जिन्हें लोग हर समय शपथ लेते हैं, और जो कोई उपयोग नहीं करता है।"

गंदे शाप के लिए गिरने के बिना पाइथन से परिचित होना चाहते हैं, जो हर किसी के लिए आपका स्वागत है!

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

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

मैं आपको पायथन से परिचित कराना चाहता हूं और आपके अनुभव को एक नई दिशा में स्थानांतरित करने में मदद करना चाहता हूं। किसी भी तकनीक की तरह, इसकी अपनी ताकत और कमजोरियां हैं। अजगर, जैसे C ++, Rust, Ruby, JS और बाकी सब, एक उपकरण है। निर्देश किसी भी उपकरण से जुड़े होते हैं और आपको किसी भी उपकरण का सही उपयोग करना सीखना चाहिए।

"लेखक, कोई दिमाग नहीं है, क्या आप हमें पायथन से मिलवाने जा रहे हैं?" चलो परिचित हो जाओ!

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

इस लोकप्रियता का कारण क्या है? आपकी अनुमति से, मैं अपना संस्करण प्रस्तुत करूंगा।

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

अच्छा पायथन कोड सुंदर दिखता है। और सुंदर कोड लिखने के लिए - एक सुखद व्यवसाय क्या नहीं है?

टिप 0: आगे पढ़ने से पहले, कृपया ज़ेन पायथन कॉर्नर पर एक नज़र डालें। भाषा इन पदों पर आधारित है और यदि आप उनसे परिचित होंगे तो हमारा संचार बहुत अधिक सुखद होगा।

क्या चालाक आदमी खरोज के साथ आया था?

उन लोगों के लिए पहला झटका जिन्होंने कभी पायथन में कोड नहीं देखा है, निर्देशों के शरीर का इंडेंटेशन है:

def main(): ins = input('Please say something') for w in ins.split(' '): if w == 'hello': print('world!') 

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

उस रात मैं पायथन के साथ बैठ गया। पीछे देखते हुए, मैं निश्चित रूप से कह सकता हूं कि नई सामग्री को जल्दी से अवशोषित करने में क्या मदद मिली। यह एक कोड संपादक था। उसी वीएलके के प्रभाव के तहत, ऊपर वर्णित घटनाओं से कुछ समय पहले, मैंने एक संपादक के रूप में विंडोज से उबंटू और एमाक्स पर स्विच किया (2007 के आंगन में, Pyharm, एटम, वीएस कोड और अन्य - कई और वर्षों तक)। "ठीक है, अब Emacs PR होगा ..." - आप कहते हैं। बस थोड़ा सा :) परंपरागत रूप से, Emacs में <tab> कुंजी <tab> नहीं जोड़ती है, लेकिन इस मोड के नियमों के अनुसार लाइन को संरेखित करने का कार्य करती है। दबाया गया <tab> - और कोड की पंक्ति को अगले उपयुक्त स्थान पर स्थानांतरित कर दिया गया है:

इस तरह से आपको यह कभी नहीं सोचना है कि क्या आपने कोड को सही तरीके से संरेखित किया है।

टिप 1: जब आप पायथन को जानते हैं, तो एक संपादक का उपयोग करें जो इंडेंटेशन का ख्याल रखता है।

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

ओह अच्छी तरह से अपने गतिशील टाइपिंग

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

यह स्पष्ट करने योग्य है कि पायथन में टाइपिंग सख्त है और एक संख्या को एक स्ट्रिंग में जोड़ने से काम नहीं होता है:

 1 + '1' >>> TypeError: unsupported operand type(s) for +: 'int' and 'str' 

पायथन फ़ंक्शन के हस्ताक्षर की जांच भी करता है जब इसे कॉल किया जाता है और कॉल सिग्नेचर सही नहीं होने पर अपवाद को फेंक देगा:

 def sum(x, y): return x + y sum(10, 20, 30) >>> TypeError: sum() takes 2 positional arguments but 3 were given 

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

 def sum(x, y): return x + y sum(10, '10') >>> TypeError: can only concatenate str (not "int") to str 

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

 # main.py: def sum(x: int, y: int) -> int: return x + y sum(10, '10') $ mypy main.py tmp.py:5: error: Argument 2 to "sum" has incompatible type "str"; expected "int" 

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

 #      , :   :) from typing import TypeVar, Iterable Num = TypeVar('Num', int, float) def sum(items: Iterable[Num]) -> Num: accum = 0 for item in items: accum += item return accum sum([1, 2, 3]) >>> 6 

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

नीम हकीम! बतख टाइपिंग

कई बार, पायथन उत्साही रहस्यमय होने का दिखावा करते हैं और "डक टाइपिंग" के बारे में बात करते हैं।
बतख टाइपिंग प्रोग्रामिंग में बत्तख परीक्षण का उपयोग है:

यदि कोई वस्तु बतख की तरह फटती है, तो बतख की तरह उड़ती है और बतख की तरह चलती है, तो यह सबसे अधिक संभावना है कि वह बतख है।

एक उदाहरण पर विचार करें:

 class RpgCharacter: def __init__(self, weapon) self.weapon = weapon def battle(self): self.weapon.attack() 

यहाँ क्लासिक निर्भरता इंजेक्शन है। RpgCharacter वर्ग weapon निर्माता को निर्माणकर्ता में और बाद में, battle() विधि में, weapon.attack() बुलाता है। लेकिन RpgCharacter weapon के विशिष्ट कार्यान्वयन पर निर्भर नहीं करता है। यह तलवार, बीएफजी 9000, या एक फूल के बर्तन के साथ व्हेल हो सकता है, जो किसी भी समय दुश्मन के सिर पर उतरने के लिए तैयार है। यह महत्वपूर्ण है कि ऑब्जेक्ट पर attack() विधि है, पायथन को बाकी सभी चीजों में दिलचस्पी नहीं है।

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

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

 interface IWeapon { void attack(); } public class Sword implements IWeapon { public void attack() { //... } } public class RpgCharacter { IWeapon weapon; public RpgCharacter(IWeapon weapon) { this.weapon = weapon; } public void battle() { weapon.attack(); } } 

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

प्रक्रियात्मक दृष्टिकोण और __ विशेष_ विधियाँ __ ()

पायथन एक ऑब्जेक्ट-ओरिएंटेड भाषा है और object क्लास वंशानुक्रम पदानुक्रम के मूल में है:

 isinstance('abc', object) >>> True isinstance(10, object) >>> True 

लेकिन जहाँ Java और C # में obj.ToString() उपयोग किया जाता है, obj.ToString() में str(obj) लिए कॉल आएगा। या उदाहरण के लिए, myList.length बजाय, पायथन ने len(my_list) । भाषा के निर्माता, गुइडो वैन रोसुम ने इसे इस प्रकार समझाया:

जब मैं len(x) कहने वाले कोड को पढ़ता हूं, तो मुझे पता है कि कुछ की लंबाई का अनुरोध किया जा रहा है। यह मुझे तुरंत बताता है कि परिणाम पूर्णांक होगा, और तर्क कुछ प्रकार का कंटेनर है। इसके विपरीत, जब x.len() पढ़ते हैं, तो मुझे यह जानना होगा कि x कुछ प्रकार का कंटेनर है जो एक विशिष्ट इंटरफ़ेस को लागू करता है या उस वर्ग से विरासत में मिला है जिसमें len() विधि है। [स्रोत]

फिर भी, अपने अंदर, फ़ंक्शन len() , str() और कुछ अन्य वस्तु के कुछ तरीकों को कॉल करेंगे:

 class User: def __init__(self, name, last_name): self.name = name self.last_name = last_name def __str__(self): return f"Honourable {self.name} {self.last_name}" u = User('Alex', 'Black') label = str(u) print(label) >>> Honourable Alex Black 

भाषा संचालकों द्वारा गणितीय और बूलियन दोनों के साथ-साथ for ... in ... लूप ऑपरेटरों, संदर्भ ऑपरेटर, इंडेक्स ऑपरेटर [] , आदि के लिए भी विशेष विधियों का उपयोग किया जाता है।
उदाहरण के लिए, एक __iter__() प्रोटोकॉल में दो विधियाँ शामिल हैं: __iter__() और __next__() :

 #  Iterable, IEnumerable, std::iterator  .. class InfinitePositiveIntegers: def __init__(self): self.counter = 0 def __iter__(self): """      .    iter(). """ return self def __next__(self): """  .    next(). """ self.counter += 1 return self.counter for i in InfinitePositiveIntegers(): print(i) >>> 1 >>> 2 >>> ... #  ,  Ctrl + C 

खैर, आइए बताते हैं खास तरीके। लेकिन वे इतने मुड़ क्यों दिखते हैं? गुइडो ने इसे इस तथ्य से समझाया कि उनके पास बिना नाम के सामान्य नाम थे, प्रोग्रामर खुद कम से कम, जल्दी या बाद में उन्हें फिर से परिभाषित नहीं करेंगे। यानी ____() मूर्ख के खिलाफ एक तरह का संरक्षण है। जैसा कि समय ने दिखाया है - संरक्षण प्रभावी है :)

टिप 4: अंतर्निहित कार्यों और विशेष ऑब्जेक्ट विधियों पर एक करीब से नज़र डालें। वे भाषा का एक अभिन्न हिस्सा हैं, जिसके बिना इसे पूरी तरह से बोलना असंभव है।

इनकैप्सुलेशन कहाँ है? मेरा निजी कहाँ है ?! मेरी परीकथा कहाँ है !!

पायथन में वर्ग विशेषताओं के लिए कोई पहुँच संशोधक नहीं है। वस्तुओं के अंदरूनी हिस्से बिना किसी प्रतिबंध के उपयोग के लिए खुले हैं। हालाँकि, एक सम्मलेन है जिसके अनुसार उपसर्ग _ साथ गुण को निजी माना जाता है, उदाहरण के लिए:

 import os class MyFile: #    _os_handle = None def __init__(self, path: str): self._open(path) #    def _open(self, path): # os.open() - **    . #      open(). #   os.open()    . self._os_handle = os.open(path, os.O_RDWR | os.O_CREAT) #      def close(self): if self._os_handle is not None: os.close(self._os_handle) f = MyFile('/tmp/file.txt') print(f._os_handle) #    ""    ! f.close() 

क्यों?

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

अंत में, हम सभी यहाँ वयस्क हैं।

- कार्ल फास्ट [स्रोत] ।

 class C: def __init__(self): self.__x = 10 def get_x(self): return self.__x c = C() c.__x >>> 'C' object has no attribute '__x' print(c.get_x()) >>> 10 print(c._C__x) >>> 10 

 class BaseFile: def __init__(self, path): self.path = path class LocalMixin: def read_from_local(self): with open(self.path) as f: return f.read() class CachedMixin: class CacheMissError(Exception): pass def __init__(self): # Tepe,         #   __cache,   __from_cache(), # ,     ! self.__cache = {} def __from_cache(self): return self.__cache[self.path] def read_from_cache(self): try: return self.__from_cache() except KeyError as e: raise self.CacheMissError() from e def store_to_cache(self, data): self.__cache[self.path] = data class File(CachedMixin, LocalMixin, BaseFile): def __init__(self, path): CachedMixin.__init__(self) BaseFile.__init__(self, path) def read(self): try: return self.read_from_cache() except CachedMixin.CacheMissError: data = self.read_from_local() self.store_to_cache(data) return data 

अंत में, भाषा में गुणों की उपस्थिति के कारण, जावा शैली में getX(), setX() लिखने के लिए कोई मतलब नहीं है: getX(), setX() । उदाहरण के लिए, मूल रूप से लिखित कक्षा Coordinates ,

 class Coordinates: def __init__(self, x, y): self.x = x self.y = y c = Coordinates(10, 10) print(cx, cy) >>> (10, 10) 

मुझे x विशेषता तक पहुंच को नियंत्रित करने की आवश्यकता थी। सही तरीका यह होगा कि इसे property साथ बदल दिया जाए, जिससे बाहरी दुनिया के साथ एक अनुबंध बना रहे।

 class Coordinates: _x = 0 def __init__(self, x, y): self.x = x self.y = y @property def x(self): return self._x @x.setter def x(self, val): if val > 10: self._x = val else: raise ValueError('x should be greater than 10') c = Coordinates(20, 10) cx = 5 >>> ValueError: x should be greater than 10 

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

अपवादों के बारे में थोड़ा सा

पायथन संस्कृति में अपवादों के लिए एक अनूठा दृष्टिकोण है। सामान्य अवरोधन और प्रसंस्करण के अलावा एक ला सी ++ / जावा, आप संदर्भ में अपवादों के उपयोग का सामना करेंगे

"ईजीएफपी की अनुमति की तुलना में माफी के लिए पूछना आसान है।"

विरोधाभास करने के लिए - बहुत ज्यादा मत लिखो if , ज्यादातर मामलों में, निष्पादन इस शाखा पर जाएगा। इसके बजाय, try..except में तर्क को try..except ।

उदाहरण: एक POST अनुरोध हैंडलर की कल्पना करें जो एक सशर्त डेटाबेस में एक उपयोगकर्ता बनाता है। फ़ंक्शन के इनपुट में कुंजी-मूल्य प्रकार का एक शब्दकोश (शब्दकोश) है:

 def create_user_handler(data: Dict[str, str]): try: database.user.persist( username=data['username'], password=data['password'] ) except KeyError: print('There was a missing field in data passed for user creation') 

हमने चेक "क्या username या password data में निहित है" के साथ कोड को प्रदूषित नहीं किया। हम उम्मीद करते हैं कि वे सबसे अधिक संभावना है। हम इन क्षेत्रों का उपयोग करने के लिए "अनुमति" के लिए नहीं कहते हैं, लेकिन जब अगले कुल्हेर लापता डेटा के साथ एक फॉर्म पोस्ट करते हैं, तो "माफी मांगें"।

 def create_user_handler(data): if 'last_name' not in data: data['last_name'] = '' try: database.user.persist( username=data['username'], password=data['password'], last_name=data['last_name'] ) except KeyError: print('There was a missing field in data passed for user creation') 

त्रुटियों को कभी भी चुपचाप नहीं गुजरना चाहिए। - अपवादों को अनदेखा न करें! आधुनिक पायथन में निर्माण raise from एक अद्भुत raise from है जो आपको अपवाद श्रृंखला के संदर्भ को बनाए रखने की अनुमति देता है। उदाहरण के लिए:

 class MyProductError(Exception): def __init__(self): super().__init__('There has been a terrible product error') def calculate(x): try: return 10 / x except ZeroDivisionError as e: raise MyProductError() from e 

raise from e MyProductError बिना raise from e अपवाद श्रृंखला MyProductError पर टूट जाती है, और हम यह पता नहीं लगा सकते हैं कि वास्तव में इस त्रुटि का कारण क्या था। raise from X साथ, थ्रो अपवाद का कारण (यानी X ) __cause__ विशेषता में संग्रहीत होता है:

 try: calculate(0) except MyProductError as e: print(e.__cause__) >>> division by zero 

 class PositiveIntegers: def __init__(self, limit): self.counter = 0 self.limit = limit def __iter__(self): return self def __next__(self): self.counter += 1 if self.counter == self.limit: #  hasNext()  moveNext(), #  ,   raise StopIteration() return self.counter for i in PositiveIntegers(5): print(i) > 1 > 2 > 3 > 4 

टिप 6: हम केवल असाधारण स्थितियों में अपवाद से निपटने के लिए भुगतान करते हैं। उनकी उपेक्षा मत करो!

एक होना चाहिए - और अधिमानतः केवल एक ही - ऐसा करने का पिछला तरीका।

switch या पैटर्न मिलान? - if और शब्दकोशों का उपयोग करें। do- ? - इसके लिए while और for । goto ? मुझे लगता है कि आप खुद अनुमान लगा चुके हैं। यह कुछ डिज़ाइन तकनीकों और पैटर्नों पर लागू होता है जो अन्य भाषाओं में दी गई प्रतीत होती हैं। सबसे आश्चर्यजनक बात यह है कि उनके कार्यान्वयन पर कोई तकनीकी प्रतिबंध नहीं है, यह सिर्फ "हम इसे स्वीकार नहीं करते हैं"।

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

 human = HumanBuilder.withName("Alex").withLastName("Black").ofAge(20).withHobbies(['tennis', 'programming']).build() 

होगा

 human = Human( name="Alex" last_name="Black" age=20 hobbies=['tennis', 'programming'] ) 

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

 val shortGreetings = people .filter { it.name.length < 10 } .map { "Hello, ${it.name}!" } 

पायथन में, map() , filter() और कई अन्य, फ़ंक्शन हैं, संग्रह के तरीके नहीं हैं। इस कोड को एक के बाद एक करके, हमें मिलता है:

 short_greetings = map(lambda h: f"Hello, {h.name}", filter(lambda h: len(h.name) < 10, people)) 

मेरी राय में यह भयानक लग रहा है। इसलिए, जैसे लंबे बंडल के लिए .takewhile().filter().map().reduce() तथाकथित का उपयोग करना बेहतर है समावेशन (कॉम्प्रिहेंशन), ​​या अच्छे पुराने चक्र। वैसे, कोटलिन पर एक ही उदाहरण संगत सूची समझ के रूप में दिया गया है। और अजगर पर यह इस तरह दिखता है:

 short_greetings = [ f"Hello {h.name}" for h in people if len(h.name) < 10 ] 

विधि श्रृंखलाओं का उपयोग किया जाता है जहां वे मानक उपकरणों की तुलना में अधिक कुशल होते हैं। उदाहरण के लिए, Django वेब फ्रेमवर्क में, डेटाबेस क्वेरी ऑब्जेक्ट बनाने के लिए चेन का उपयोग किया जाता है:

 query = User.objects \ .filter(last_visited__gte='2019-05-01') \ .order_by('username') \ .values('username', 'last_visited') \ [:5] 

टिप 7: इससे पहले कि आप पिछले अनुभव से बहुत परिचित हों, लेकिन पायथन में परिचित नहीं हैं, अपने आप से पूछें कि एक अनुभवी अजगर क्या निर्णय करेगा?

अजगर धीमा

हां।

हां, जब यह सांख्यिकीय रूप से टाइप और संकलित भाषाओं की तुलना में निष्पादन की गति की बात आती है।

लेकिन क्या आप एक विस्तृत जवाब चाहते हैं?

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

जेक VanderPlas ने अपने ब्लॉग में बताया कि सीपीथॉन में हुड के नीचे क्या होता है जब पूर्णांक मानों वाले दो चर जोड़ते हैं:

 a = 1 b = 2 c = a + b 

यहां तक ​​कि अगर हम सीपीथॉन के जंगल में नहीं जाते हैं, तो हम कह सकते हैं कि चर a , b और c को स्टोर करने के लिए, दुभाषिया को ढेर पर तीन ऑब्जेक्ट बनाने होंगे, जिसमें प्रकार और (पॉइंटर्स टू) मान संग्रहीत किए जाएंगे; binary_add<int, int>(a->val, b->val) जैसे कुछ को कॉल करने के लिए अतिरिक्त ऑपरेशन के दौरान प्रकार और मूल्यों का फिर से पता लगाना; परिणाम को c लिखें।
यह समान सी प्रोग्राम की तुलना में बहुत अक्षम है।

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

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

?

1. . ( CFFI ) . API (extensions) C/C++. , Rust, Go Kotlin Native !
2. , :
   
   • PyPy , JIT-. , , ?
   • Cython — Python C.
   • IronPython — , .NET framework.

8: , . , IO (, , ) , , , , :)

? Linux MacOS, 95% . , 3., 2.7. Windows . : Docker, Windows Subsystem for Linux, Cygwin, , .

9: . , — - .

"Hello world" ? बहुत बढ़िया! machine learning- - Python Package Index (PyPI).

(packages), .. (virtual environments). , . - . pip . pip . , pipenv poetry — npm, bundler, cargo ..

0xA: — pip virtualenv . — , , . , — sys.path — , .

?

? . :

Dive into python...

, . , , :)

, !