पायथन में कोडिंग के लिए Google टिप्स। भाग एक: प्रोग्रामिंग टिप्स

परिभाषा

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

आकर्षण आते हैं

यह हार्ड-टू-डिटेक्ट एरर्स को पकड़ता है, जैसे टाइप एरर, उन्हें घोषित करने से पहले वेरिएबल्स का उपयोग करना आदि।

विपक्ष

PyChecker परिपूर्ण नहीं है। इसके सभी लाभ प्राप्त करने के लिए हमें चाहिए:

• उस पर एक नजर के साथ लिखें
• उसकी चेतावनियों को दबाओ
• कीड़े को ठीक करें
• या उनकी उपेक्षा करें

निर्णय

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

__pychecker__ = 'no-callinit no-classattr' 

इस तरह से चेतावनी को दबाने से निम्नलिखित योजना का लाभ होता है - हम आसानी से दमन की तलाश कर सकते हैं और उन पर वापस लौट सकते हैं। आप टाइप करके PyChecker चेतावनियों की सूची देख सकते हैं:

 pychecker -- help 

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

 def foo(a, unused_b, unused_c, d=None, e=None): _ = d, e return a 

आदर्श रूप से, PyChecker को परिष्कृत किया जाएगा ताकि यह आत्मविश्वास से कहा जा सके कि "अप्रयुक्त विज्ञापन" वास्तव में हैं।

परिभाषा

एक मॉड्यूल से दूसरे में खुले स्रोत कोड के पुन: उपयोग के लिए एक तंत्र।

आकर्षण आते हैं

नाम स्थान सम्मेलन बहुत सरल है। कोड में प्रत्येक ऑब्जेक्ट का स्थान एकल तरीके से इंगित किया गया है। x.Obj का कहना है कि ऑब्जेक्ट ओब्ज को मॉड्यूल x में घोषित किया जाता है।

विपक्ष

कभी-कभी मॉड्यूल नाम संघर्ष कर सकते हैं। कुछ मॉड्यूल नाम असुविधाजनक रूप से लंबे हो सकते हैं।

निर्णय

पैकेज और मॉड्यूल आयात करने के लिए आयात x का उपयोग करें।
जब x पैकेज उपसर्ग है, तो x आयात y से उपयोग करें, और y उपसर्ग के बिना मॉड्यूल नाम है।
X आयात y से z के रूप में उपयोग करें यदि दो मॉड्यूल का नाम y है , या यदि मॉड्यूल नाम असुविधाजनक रूप से लंबा है।
उदाहरण के लिए, sound.effects.echo मॉड्यूल को इस तरह आयात किया जा सकता है:

 from sound.effects import echo ... echo.EchoFilter(input, output, delay=0.7, atten=4) 

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

आकर्षण आते हैं

मॉड्यूल नामों में संघर्ष को दरकिनार किया जाता है। डिस्क पर एक मॉड्यूल ढूंढना आसान हो रहा है।

विपक्ष

चूंकि कोड को पोर्ट करना कठिन हो जाता है आपको पूरी तरह से मॉड्यूल के पूर्ण पदानुक्रम को फिर से बनाना होगा।

निर्णय

आपके सभी नए कोड को पैकेज में प्रत्येक मॉड्यूल को उसके पूर्ण पथ में आयात करना चाहिए।
आयात इस तरह होना चाहिए:

 #       import sound.effects.echo #        () from sound.effects import echo 

परिभाषा

एक अपवाद त्रुटियों या अन्य असाधारण स्थितियों को संभालने के लिए एक कोड ब्लॉक के सामान्य नियंत्रण प्रवाह से बाहर निकलने का एक साधन है।

आकर्षण आते हैं

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

विपक्ष

नियंत्रण प्रवाह गलत तरीके से चलना शुरू हो सकता है। लाइब्रेरी से किसी फ़ंक्शन को कॉल करते समय उस स्थिति को छोड़ना बहुत सरल है जिसमें एक त्रुटि उठाई जाएगी।

निर्णय

अपवाद हैंडलिंग को इन पदों का पालन करना चाहिए:

• इस तरह से अपवादों को उठाएँ: MyException ('त्रुटि संदेश') बढ़ाएँ , या MyException बढ़ाएँ । दो तर्कों के साथ लिखने के फॉर्म का उपयोग न करें: ( MyException, 'Error message' ) बढ़ाएं, साथ ही लिखने के स्ट्रिंग फॉर्म का भी उपयोग न करें ( 'Error message' बढ़ाएं )।
• मॉड्यूल (या पैकेज) को अपने स्वयं के ऑब्जेक्ट-ओरिएंटेड अपवाद वर्गों को परिभाषित करना चाहिए, जो अंतर्निहित अपवाद वर्ग से विरासत में प्राप्त होना चाहिए।
  मॉड्यूल के मुख्य अपवाद को एरर कहा जाना चाहिए।
  
  

   class Error(Exception): pass 

  
  
• कभी भी एक अपवाद का उपयोग न करें जो केवल सभी अपवादों को पकड़ता है यदि आप उन्हें बाद में ओवरएक्ससाइट नहीं करने जा रहे हैं, या यदि आप थ्रेड में बाहरी कोड ब्लॉक में नहीं हैं (और एक त्रुटि संदेश मुद्रित होता है)। इस संबंध में पायथन बहुत सहिष्णु है, इसके अलावा, आप कुछ भी पकड़ सकते हैं: नामकरण की त्रुटियां, कॉलिंग sys.exit () , Ctrl + C , परीक्षण विफलताओं और विभिन्न प्रकार के अपवादों को बाधित करना जो आप बस पकड़ना नहीं चाहते हैं।
• कोड में / ब्लॉक को छोड़कर कोड की मात्रा कम करें। ट्राइ ब्लॉक का शरीर जितना बड़ा होगा, उतनी ही अधिक संभावना है कि एक अपवाद कोड की एक पंक्ति में फेंक दिया जाएगा जिसमें आप बाद वाले को फेंकने की उम्मीद नहीं करते हैं। इन मामलों में, ब्लॉक को छोड़कर / कोशिश असली त्रुटि को छुपाती है।
• कोड को निष्पादित करने के लिए अंत में स्टेटमेंट को स्लाइड करें, इस बात की परवाह किए बिना कि क्या ट्रायल ब्लॉक में कोई अपवाद डाला गया था या नहीं। यह अक्सर अंतिम क्रियाओं के लिए उपयोगी होता है, जैसे किसी फ़ाइल को बंद करना।
• एक अपवाद को पकड़ने पर, अल्पविराम की तुलना में इसका उपयोग करना बेहतर होता है:
  
  

   try: raise Error except Error as error: pass 

  
  

परिभाषा

चर जो मॉड्यूल स्तर पर परिभाषित किए गए हैं।

आकर्षण आते हैं

कभी-कभी उपयोगी।

विपक्ष

आप अनजाने में आयात के दौरान मॉड्यूल के व्यवहार को बदल सकते हैं, जैसा कि मॉड्यूल आयात होने पर मॉड्यूल स्तर चर का असाइनमेंट पहले से ही पूरा हो गया है।

निर्णय

वर्ग चर के पक्ष में वैश्विक चर का उपयोग करने से बचें। नीचे कुछ अपवाद:

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

परिभाषा

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

आकर्षण आते हैं

सहायक वर्गों और कार्यों को परिभाषित करना संभव बनाता है जो केवल बहुत सीमित स्थान के भीतर ही उपयोग किए जाएंगे। ADT सिद्धांत के अनुरूप है।

विपक्ष

नेस्टेड या स्थानीय वर्गों के उदाहरणों को क्रमबद्ध नहीं किया जा सकता है।

निर्णय

वे अच्छे हैं।

परिभाषा

सूची जनरेटर और अभिव्यक्ति जनरेटर, नक्शे () , फिल्टर (), या लैम्ब्डा अभिव्यक्तियों का सहारा लिए बिना सूचियों और पुनरावृत्तियों को बनाने के लिए एक कॉम्पैक्ट और कुशल तरीका प्रदान करते हैं।

आकर्षण आते हैं

एक साधारण सूची जनरेटर सूचियों को बनाने के अन्य तरीकों की तुलना में क्लीनर और सरल हो सकता है। एक अभिव्यक्ति जनरेटर बहुत कुशल हो सकता है क्योंकि यह एक ही बार में पूरी सूची नहीं बनाता है।

विपक्ष

जटिल सूची जनरेटर या अभिव्यक्ति जनरेटर को पढ़ना मुश्किल हो सकता है।

निर्णय

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

अच्छा:

  result = [] for x in range(10): for y in range(5): if x * y > 10: result.append((x, y)) for x in xrange(5): for y in xrange(5): if x != y: for z in xrange(5): if y != z: yield (x, y, z) return ((x, complicated_transform(x)) for x in long_generator_function(parameter) if x is not None) squares = [x * x for x in range(10)] eat(jelly_bean for jelly_bean in jelly_beans if jelly_bean.color == 'black') 

खराब:

  result = [(x, y) for x in range(10) for y in range(5) if x * y > 10] return ((x, y, z) for x in xrange(5) for y in xrange(5) if x != y for z in xrange(5) if y != z) 

परिभाषा

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

आकर्षण आते हैं

मानक पुनरावृत्तियों और ऑपरेटरों सरल और कुशल हैं। वे आंतरिक पुन: कॉल के बिना, ऑपरेशन को सीधे व्यक्त करते हैं। और मानक ऑपरेटरों का उपयोग करने वाला एक फ़ंक्शन सरल है। इसका उपयोग विभिन्न प्रकारों के साथ किया जा सकता है जो इस ऑपरेशन का समर्थन करते हैं।

विपक्ष

आप विधि के नाम से वस्तुओं के प्रकारों का नाम नहीं दे सकते (उदाहरण के लिए, has_key () का अर्थ है कि यह एक शब्दकोष है)। यह भी एक फायदा है।

निर्णय

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

अच्छा:

  for key in adict: ... if key not in adict: ... if obj in alist: ... for line in afile: ... for k, v in dict.iteritems(): ... 

खराब:

  for key in adict.keys(): ... if not adict.has_key(key): ... for line in afile.readlines(): ... 

परिभाषा

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

आकर्षण आते हैं

कोड को सरल करता है स्थानीय चर और नियंत्रण प्रवाह की स्थिति प्रत्येक कॉल के लिए समान रहती है। एक जनरेटर को एक फ़ंक्शन से कम मेमोरी की आवश्यकता होती है जो एक बार में मानों की एक सूची बनाता है।

विपक्ष

कोई विपक्ष नहीं हैं।

निर्णय

ठीक। जनरेटर कार्यों के लिए प्रलेखन लाइनों में "रिटर्न:" के बजाय "जनरेट:" को वरीयता दें।

परिभाषा

लैम्बडा फ़ंक्शन एक फ़ंक्शन में एक नियमित फ़ंक्शन के निर्माण के विकल्प के रूप में अनाम कार्यों को परिभाषित करता है। वे अक्सर कॉलबैक फ़ंक्शंस या ऑपरेटरों को उच्च ऑर्डर फ़ंक्शंस जैसे कि मानचित्र () और फ़िल्टर () के लिए घोषित करने के लिए उपयोग किया जाता है।

आकर्षण आते हैं

सुविधाजनक।

विपक्ष

स्थानीय कार्यों की तुलना में इसे पढ़ना और डीबग करना कठिन है। गुम नामों का मतलब है कि कॉल स्टैक को पढ़ना कठिन होगा। स्पष्टता सीमित है क्योंकि एक फ़ंक्शन में केवल एक अभिव्यक्ति हो सकती है।

निर्णय

इनलाइन अभिव्यक्ति के लिए अच्छा है। यदि लैम्ब्डा फ़ंक्शन के अंदर कोड 60-80 अक्षरों से अधिक है, तो इस फ़ंक्शन को एक नियमित (या नेस्टेड) ​​फ़ंक्शन के रूप में परिभाषित करना बेहतर हो सकता है। सरल संचालन के लिए, जैसे गुणा, लंबोदा फ़ंक्शन के बजाय ऑपरेटर मॉड्यूल से फ़ंक्शन का उपयोग करें। उदाहरण के लिए, लैम्बडा x, y: x * y के बजाय oper.mul का उपयोग करना बेहतर है।

परिभाषा

सशर्त अभिव्यक्ति एक तंत्र है जो अगर निर्माण के लिए संक्षिप्त सिंटैक्स प्रदान करता है। उदाहरण के लिए, x = 1 यदि दूसरा कंडोम 2 है ।

आकर्षण आते हैं

छोटा और अगर निर्माण से अधिक आरामदायक है।

विपक्ष

यदि यह कथन की तुलना में पढ़ना अधिक कठिन हो सकता है। यदि अभिव्यक्ति बहुत लंबी है, तो यह लिखना मुश्किल हो सकता है।

निर्णय

केवल इनलाइन अभिव्यक्तियों के लिए उपयोग करें। अन्य मामलों में, यदि निर्माण हो तो पूर्णरूपेण उपयोग करने को प्राथमिकता दें।

परिभाषा

आप फ़ंक्शन तर्क सूची के अंत में चर के मानों को असाइन कर सकते हैं, उदाहरण के लिए, foo (a, b = 0) को परिभाषित करें :
यदि फ़ंक्शन फू को केवल एक तर्क के साथ कहा जाता है, तो तर्क बी 0 होगा। यदि इसे दो तर्कों के साथ कहा जाता है, तो b का दूसरा तर्क होगा।

आकर्षण आते हैं

अक्सर आपके पास एक फ़ंक्शन होता है जो कई डिफ़ॉल्ट मानों का उपयोग करता है। लेकिन कभी-कभी आपको डिफ़ॉल्ट मानों को ओवरराइड करने की आवश्यकता होती है। पायथन भी विधि / कार्य अधिभार का समर्थन नहीं करता है, और मानक तर्क अधिभार व्यवहार को "अनुकरण" करने का एक सरल तरीका है।

विपक्ष

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

निर्णय

निम्नलिखित चेतावनियों के साथ प्रयोग किया जा सकता है:
कार्यों या विधि परिभाषाओं में मानक मूल्यों के रूप में उत्परिवर्तित वस्तुओं का उपयोग न करें।

अच्छा:

 def foo(a, b=None): if b is None: b = [] 

खराब:

 def foo(a, b=[]): 

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

 def foo(a, b=1): ... 

अच्छा:

 foo(1) foo(1, b=2) 

खराब:

 foo(1, 2) 

डेटा तक पहुंचने के लिए गुणों का उपयोग करें या उन मूल्यों को असाइन करें जहां आप सामान्य रूप से साधारण गेट्टर या सेटर विधि का उपयोग करेंगे।

परिभाषा

गणना पद्धति बहुत जटिल नहीं होने पर, मानक विशेषता पहुंच के रूप में एक्सेस विधि कॉल और विशेषता असाइनमेंट को लपेटने का एक तरीका है।

आकर्षण आते हैं

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

विपक्ष

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

निर्णय

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

अच्छा:

 import math class Square(object): """A square with two properties: a writable area and a read-only perimeter. To use: >>> sq = Square(3) >>> sq.area 9 >>> sq.perimeter 12 >>> sq.area = 16 >>> sq.side 4 >>> sq.perimeter 16 """ def __init__(self, side): self.side = side def __get_area(self): """Calculates the 'area' property.""" return self.side ** 2 def ___get_area(self): """Indirect accessor for 'area' property.""" return self.__get_area() def __set_area(self, area): """Sets the 'area' property.""" self.side = math.sqrt(area) def ___set_area(self, area): """Indirect setter for 'area' property.""" self.__set_area(area) area = property(___get_area, ___set_area, doc="""Gets or sets the area of the square.""") @property def perimeter(self): return self.side * 4 

परिभाषा

जब हम बूलियन मूल्यों के संदर्भ में अजगर गलत मूल्यों की गणना करते हैं। इसे याद रखने का सबसे आसान तरीका यह है कि सभी "खाली" मान, जैसे कि गलत , 0 , कोई नहीं , [] , {} , का मूल्यांकन बूलियन संदर्भ में किया जाता है।

आकर्षण आते हैं

पायथन के बूलियन मूल्यों का उपयोग करने वाले ऐसे सशर्त निर्माण पठनीय और कम त्रुटि वाले हैं। ज्यादातर मामलों में, वे तेज होते हैं।

विपक्ष

सी / सी ++ डेवलपर्स के लिए अजीब लग सकता है।

निर्णय

यदि संभव हो तो स्पष्ट रूप से गलत का उपयोग करें। उदाहरण के लिए, अगर फू: अगर फू से बेहतर है ! = []:। आपको कुछ अपवादों को याद रखना चाहिए:

• कभी नहीं == या ! = एकल वस्तुओं की तुलना करें जैसे कि कोई नहीं । उपयोग है या नहीं है ।
• यदि x का अर्थ है तो लिखने से सावधान रहें : यदि आपका मतलब है कि x कोई नहीं है:, उदाहरण के लिए, जब किसी चर या तर्क का परीक्षण किया जाता है जो किसी को भी चूकता नहीं है , लेकिन उनका मान दूसरे में बदल दिया गया है। एक और मूल्य की गणना झूठी में बूलियन जांच के साथ की जा सकती है।
• == का उपयोग करके कभी भी बूलियन चर की तुलना झूठी के साथ न करें। इसके बजाय x का उपयोग करें। यदि आपको किसी से भी गलत को अलग करने की आवश्यकता है, तो स्ट्रिंग अभिव्यक्ति का उपयोग करें जैसे कि x और x कोई नहीं है ।
• अनुक्रमों (पंक्तियों, सूचियों, टुपल्स) के लिए, इस तथ्य का उपयोग करें कि खाली अनुक्रम गलत का मूल्यांकन करता है, इसलिए यदि seq नहीं है या यदि seq से बेहतर है यदि len (seq) या नहीं तो len (seq) :।
• जब आप पूर्णांक के साथ काम करते हैं, तो फाल्स के साथ एक स्पष्ट तुलना में लाभ की तुलना में अधिक जोखिम होता है ( 0 के रूप में कोई नहीं के यादृच्छिक प्रसंस्करण)। आप एक मान की तुलना कर सकते हैं जो एक पूर्णांक है (और शून्य के साथ लेन () फ़ंक्शन को निष्पादित करने का परिणाम नहीं है ) ।

अच्छा:

 if not users: print "no" if foo == 0: self.handle_zero() if i % 10 == 0: self.handle_multiple_of_ten() 

खराब:

 if len(users) == 0: print 'no users' if foo is not None and not foo: self.handle_zero() if not i % 10: self.handle_multiple_of_ten() 

ध्यान दें कि "0" (जो कि, स्ट्रिंग के रूप में 0) True का मूल्यांकन करता है।

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

परिभाषा

पायथन का वर्तमान संस्करण वैकल्पिक निर्माण प्रदान करता है जो लोगों को निश्चित रूप से सबसे अच्छा लगता है।

निर्णय

हम पायथन के संस्करणों का उपयोग नहीं करते हैं जो इन सुविधाओं का समर्थन नहीं करते हैं, इसलिए नई शैलियों का उपयोग करने का कोई कारण नहीं है।

अच्छा:

 words = foo.split(':') [x[1] for x in my_list if x[2] == 5] map(math.sqrt, data) #   -     fn(*args, **kwargs) 

खराब:

 words = string.split(foo, ':') map(lambda x: x[1], filter(lambda x: x[2] == 5, my_list)) 

परिभाषा

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

 def get_adder(summand1): """Returns a function that adds numbers to a given number.""" def adder(summand2): return summand1 + summand2 return adder 

आकर्षण आते हैं

अक्सर एक क्लीनर और अधिक सुरुचिपूर्ण कोड की ओर जाता है। यह विशेष रूप से लिस्प और स्कीम (और हास्केल और एमएल और ..) प्रोग्रामर के साथ काम करने के लिए आरामदायक है।

विपक्ष

इस तरह के PEP-0227 से लिए गए उदाहरण में अजीब त्रुटियां हो सकती हैं:

 i = 4 def foo(x): def bar(): print i, # ... #    # ... for i in x: # ,  i   Foo,  - Bar  . print i, bar() 

इस प्रकार foo ([1,2,3]) 1 2 3 3 का उत्पादन करेगा, न कि 1 2 3 4 का ।

निर्णय

का उपयोग कर सकते हैं।