अजगर छोटी गाड़ी कोड: 10 सबसे आम गलतियों डेवलपर्स बनाते हैं

अजगर के बारे में

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

इस लेख के बारे में

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

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

गलती # 1: फ़ंक्शन तर्कों के लिए डिफ़ॉल्ट मान के रूप में अभिव्यक्ति का दुरुपयोग

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

>>> def foo(bar=[]): # bar -    #      . ... bar.append("baz") #     ... ... return bar 

इस मामले में एक सामान्य गलती यह है कि वैकल्पिक तर्क के मूल्य को इस तर्क के लिए मान के बिना हर बार फ़ंक्शन को डिफ़ॉल्ट मान पर सेट किया जाएगा। उपरोक्त कोड में, उदाहरण के लिए, हम मान सकते हैं कि बार-बार फ़ंक्शन फू () (जो कि बार तर्क के लिए कोई मूल्य निर्दिष्ट किए बिना) कॉल करके, यह हमेशा "बाज" लौटाएगा, क्योंकि यह माना जाता है कि हर बार फू () के बिना कहा जाता है तर्क पट्टी को निर्दिष्ट करते हुए), बार [] (जो कि एक नई खाली सूची है) पर सेट है।

लेकिन देखते हैं कि वास्तव में क्या होगा:

 >>> foo() ["baz"] >>> foo() ["baz", "baz"] >>> foo() ["baz", "baz", "baz"] 

और? हर बार नई सूची बनाने के बजाय फोल () को मौजूदा सूची में डिफ़ॉल्ट मान "बाज" क्यों जोड़ना जारी रहता है?

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

संदर्भ के लिए, इस त्रुटि के लिए एक सामान्य "समाधान" निम्नलिखित परिभाषा है:

 >>> def foo(bar=None): ... if bar is None: # or if not bar: ... bar = [] ... bar.append("baz") ... return bar ... >>> foo() ["baz"] >>> foo() ["baz"] >>> foo() ["baz"] 

गलती # 2: वर्ग चर का दुरुपयोग

निम्नलिखित उदाहरण पर विचार करें:

 >>> class A(object): ... x = 1 ... >>> class B(A): ... pass ... >>> class C(A): ... pass ... >>> print Ax, Bx, Cx 1 1 1 

सब कुछ क्रम में लगता है।

 >>> Bx = 2 >>> print Ax, Bx, Cx 1 2 1 

हाँ, सब कुछ उम्मीद के मुताबिक था।

 >>> Ax = 3 >>> print Ax, Bx, Cx 3 2 3 

ये क्या!? हमने सिर्फ Ax को बदला है। Cx को भी क्यों बदला?

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

गलती नंबर 3: अपवाद ब्लॉक के लिए गलत पैरामीटर

मान लें कि आपके पास निम्नलिखित कोड है:

 >>> try: ... l = ["a", "b"] ... int(l[2]) ... except ValueError, IndexError: # To catch both exceptions, right? ... pass ... Traceback (most recent call last): File "<stdin>", line 3, in <module> IndexError: list index out of range 

यहाँ समस्या यह है कि अपवाद अभिव्यक्ति इस प्रकार निर्दिष्ट अपवादों की सूची को स्वीकार नहीं करती है। बल्कि, पायथन 2.x में, अभिव्यक्ति "अपवाद को छोड़कर, ई" का उपयोग एक वैकल्पिक दूसरे दिए गए दूसरे पैरामीटर (इस मामले में, ई) के अपवाद को बांधने के लिए किया जाता है ताकि इसे आगे निरीक्षण के लिए उपलब्ध कराया जा सके। परिणामस्वरूप, उपरोक्त कोड में, एक IndexError अपवाद को अपवाद कथन द्वारा नहीं पकड़ा गया है; इसके बजाय, अपवाद इंडेक्सएर्रर नामक पैरामीटर के साथ बंधन के साथ समाप्त होता है।

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

 >>> try: ... l = ["a", "b"] ... int(l[2]) ... except (ValueError, IndexError) as e: ... pass ... >>> 

गलती # 4: पायथन गुंजाइश नियमों की गलतफहमी

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

 >>> x = 10 >>> def foo(): ... x += 1 ... print x ... >>> foo() Traceback (most recent call last): File "<stdin>", line 1, in <module> File "<stdin>", line 2, in foo UnboundLocalError: local variable 'x' referenced before assignment 

क्या समस्या है?

उपरोक्त त्रुटि तब होती है क्योंकि जब आप किसी चर को दायरे में निर्दिष्ट करते हैं, तो पायथन स्वचालित रूप से उस दायरे में स्थानीय मान लेता है और किसी भी चर को किसी भी मूल दायरे में उसी नाम से छुपाता है।

इस प्रकार, कई आश्चर्यचकित होते हैं जब वे पहले से चल रहे कोड में UnboundLocalError प्राप्त करते हैं, जब इसे फ़ंक्शन बॉडी में कहीं असाइनमेंट ऑपरेटर जोड़कर संशोधित किया जाता है।

यह सुविधा सूचियों का उपयोग करते समय डेवलपर्स के लिए विशेष रूप से भ्रमित है। निम्नलिखित उदाहरण पर विचार करें:

 >>> lst = [1, 2, 3] >>> def foo1(): ... lst.append(5) #   ... ... >>> foo1() >>> lst [1, 2, 3, 5] >>> lst = [1, 2, 3] >>> def foo2(): ... lst += [5] # ...    ! ... >>> foo2() Traceback (most recent call last): File "<stdin>", line 1, in <module> File "<stdin>", line 2, in foo UnboundLocalError: local variable 'lst' referenced before assignment 

और? Foo1 दुर्घटनाग्रस्त क्यों होता है जबकि foo1 ठीक काम कर रहा है?

उत्तर पिछले उदाहरण के समान है, लेकिन, लोकप्रिय धारणा के अनुसार, यहां स्थिति अधिक सूक्ष्म है। foo1 असाइनमेंट ऑपरेटर को lst पर लागू नहीं करता है, जबकि foo2 नहीं करता है। इस बात को ध्यान में रखते हुए कि lst + = [5] वास्तव में lst = lst + [5] के लिए एक शॉर्टहैंड है, हम देखते हैं कि हम मूल्य lst (इसलिए पायथन इसे स्थानीय दायरे में है) मानने की कोशिश कर रहे हैं। हालाँकि, जिस मूल्य को हम lst देना चाहते हैं, वह lst पर ही आधारित है (फिर से, इसे अब स्थानीय दायरे में माना जाता है), जो अभी तक निर्धारित नहीं किया गया है। और हमें एक त्रुटि मिलती है।

गलती # 5: इस पर पुनरावृत्ति के दौरान एक सूची बदलना

निम्नलिखित कोड में समस्या काफी स्पष्ट होनी चाहिए:

 >>> odd = lambda x : bool(x % 2) >>> numbers = [n for n in range(10)] >>> for i in range(len(numbers)): ... if odd(numbers[i]): ... del numbers[i] # BAD: Deleting item from a list while iterating over it ... Traceback (most recent call last): File "<stdin>", line 2, in <module> IndexError: list index out of range 

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

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

 >>> odd = lambda x : bool(x % 2) >>> numbers = [n for n in range(10)] >>> numbers[:] = [n for n in numbers if not odd(n)] # ahh, the beauty of it all >>> numbers [0, 2, 4, 6, 8] 

गलती # 6: गलतफहमी है कि अजगर बंद में चर कैसे बांधता है

निम्नलिखित उदाहरण पर विचार करें:

 >>> def create_multipliers(): ... return [lambda x : i * x for i in range(5)] >>> for multiplier in create_multipliers(): ... print multiplier(2) ... 

आप निम्न आउटपुट की उम्मीद कर सकते हैं:

 0 2 4 6 8 

लेकिन वास्तव में आपको यह मिलता है:

 8 8 8 8 8 

आश्चर्य!

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

इस सामान्य अजगर समस्या का समाधान होगा:

 >>> def create_multipliers(): ... return [lambda x, i=i : i * x for i in range(5)] ... >>> for multiplier in create_multipliers(): ... print multiplier(2) ... 0 2 4 6 8 

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

गलती # 7: चक्रीय मॉड्यूल निर्भरता पैदा करना

मान लीजिए कि आपके पास दो फाइलें हैं, एक-बीडीओ और एक-एक बीडीओ, जिनमें से प्रत्येक दूसरे को आयात करता है, इस प्रकार है:

थिंकपैड में:

 import b def f(): return bx print f() 

B.py

 import a x = 1 def g(): print af() 

सबसे पहले, a Oracle आयात करने का प्रयास करें:

 >>> import a 1 

यह ठीक काम किया। यह आपको आश्चर्यचकित कर सकता है। आखिरकार, मॉड्यूल एक दूसरे को चक्रीय रूप से आयात करते हैं और यह संभवतः एक समस्या होना चाहिए, है ना?

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

इसलिए, हमारे उदाहरण पर लौटते समय, जब हमने थिंकपैड को आयात किया था, तो उसे बीडोमो को आयात करने में कोई समस्या नहीं थी, क्योंकि बी-थ्रो को इसकी आवश्यकता नहीं है कि इसके आयात के दौरान किसी भी ऑरेकल को परिभाषित किया जाएगा। B.py a का एकमात्र संदर्भ a af to () है। लेकिन यह कॉल g () में है और an.py तो सब कुछ ठीक काम करता है।

लेकिन क्या होगा अगर हम b.py?

 >>> import b Traceback (most recent call last): File "<stdin>", line 1, in <module> File "b.py", line 1, in <module> import a File "a.py", line 6, in <module> print f() File "a.py", line 4, in f return bx AttributeError: 'module' object has no attribute 'x' 

ओह, ओह। यह अच्छा नहीं है! यहाँ समस्या यह है कि b.py के import प्रक्रिया के दौरान यह a.py को आयात करने की कोशिश करता है, जो बदले में f () को कॉल करता है, जो bx तक पहुँचने की कोशिश करता है लेकिन bx को अभी तक परिभाषित नहीं किया गया है। इसलिए एटिट्यूड अपवाद है।

इस समस्या का कम से कम एक समाधान बहुत तुच्छ है। बस g.py को आयात करें () में:

 x = 1 def g(): import a # This will be evaluated only when g() is called print af() 

अब जब हम इसे आयात करते हैं, तो सब कुछ ठीक है:

 >>> import b >>> bg() 1 # Printed a first time since module 'a' calls 'print f()' at the end 1 # Printed a second time, this one is our call to 'g' 

गलती # 8: पायथन मानक पुस्तकालय में मॉड्यूल नामों के साथ नाम काटना

पायथन के आकर्षण में से एक इसके कई मॉड्यूल हैं जो बॉक्स से बाहर आते हैं। लेकिन परिणामस्वरूप, यदि आप होशपूर्वक इसका पालन नहीं करते हैं, तो आप पा सकते हैं कि आपके मॉड्यूल का नाम मानक लाइब्रेरी में मॉड्यूल के समान नाम के साथ हो सकता है जो पायथन के साथ आता है (उदाहरण के लिए, आपके कोड में नाम के साथ एक मॉड्यूल हो सकता है email.py, जो समान नाम के साथ मानक लाइब्रेरी मॉड्यूल के साथ संघर्ष करेगा)।

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

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

गलती # 9: पायथन 2 और पायथन 3 के बीच अंतर को ध्यान में रखने में विफलता

निम्नलिखित foo.py फ़ाइल पर विचार करें:

 import sys def bar(i): if i == 1: raise KeyError(1) if i == 2: raise ValueError(2) def bad(): e = None try: bar(int(sys.argv[1])) except KeyError as e: print('key error') except ValueError as e: print('value error') print(e) bad() 

अजगर 2 पर, यह ठीक काम करेगा:

 $ python foo.py 1 key error 1 $ python foo.py 2 value error 2 

लेकिन अब देखते हैं कि पायथन 3 में यह कैसे काम करेगा:

 $ python3 foo.py 1 key error Traceback (most recent call last): File "foo.py", line 19, in <module> bad() File "foo.py", line 17, in bad print(e) UnboundLocalError: local variable 'e' referenced before assignment 

यहाँ क्या हुआ? "समस्या" यह है कि पायथन 3 में, अपवाद ब्लॉक में कोई वस्तु इसके बाहर उपलब्ध नहीं है। (इसका कारण यह है कि अन्यथा इस ब्लॉक में वस्तुओं को मेमोरी में संग्रहीत किया जाएगा जब तक कि कचरा कलेक्टर शुरू न हो और वहां से उनके संदर्भ हटा दें)।

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

 import sys def bar(i): if i == 1: raise KeyError(1) if i == 2: raise ValueError(2) def good(): exception = None try: bar(int(sys.argv[1])) except KeyError as e: exception = e print('key error') except ValueError as e: exception = e print('value error') print(exception) good() 

इसे पायथन 3 में चलाएं:

 $ python3 foo.py 1 key error 1 $ python3 foo.py 2 value error 2 

URAAAA!

गलती # 10: __del__ विधि का अनुचित उपयोग

मान लें कि आपके पास इस तरह एक mod.py फ़ाइल है:

 import foo class Bar(object): ... def __del__(self): foo.cleanup(self.myhandle) 

और आप इसे एक और दूसरे_मॉडोरा से करने की कोशिश कर रहे हैं:

 import mod mybar = mod.Bar() 

और एक भयानक विशेषता प्राप्त करें।

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

इस "कार्य के लिए एक तारांकन के साथ" समाधान atexit.register () का उपयोग करना है। इस प्रकार, जब आपका प्रोग्राम निष्पादन को पूरा करता है (जब यह सामान्य रूप से बाहर निकलता है), दुभाषिया अपना काम पूरा करने से पहले आपके हैंडल को हटा देता है।

इसे ध्यान में रखते हुए, उपरोक्त mod.py code के लिए fix कुछ इस तरह दिख सकता है:

 import foo import atexit def cleanup(handle): foo.cleanup(handle) class Bar(object): def __init__(self): ... atexit.register(cleanup, self.myhandle) 

इस तरह का कार्यान्वयन एक सामान्य कार्यक्रम समाप्ति के बाद किसी भी आवश्यक सफाई को कॉल करने का एक सरल और विश्वसनीय तरीका प्रदान करता है। जाहिर है, स्वयं के साथ जुड़ी हुई वस्तु से कैसे निपटा जाए, इसका निर्णय। नामहैंडल नाम foo.cleanup पर छोड़ दिया गया है, लेकिन मुझे लगता है कि आप इस विचार को समझते हैं।

निष्कर्ष

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

इस लेख में शामिल पायथन की बारीकियों से परिचय कुछ सामान्य गलतियों से बचते हुए भाषा के आपके उपयोग को अनुकूलित करने में मदद करेगा।