हम सुंदर मुहावरेदार पायथन लिखते हैं

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

नोट : सभी सिफारिशें कई संस्करणों में दी गई हैं: सबसे पहले, "सबसे खराब" विकल्प चलते हैं, और फिर सबसे अच्छा विकल्प पेश किया जाता है। भाषा संस्करण 2.7 के लिए वास्तविक, संस्करण 3.3 के लिए अंतर विशिष्ट "पैटर्न" के नोटों में पाया जा सकता है।

संख्या की एक सरणी

बुरा : कभी-कभी वे ऐसा लिखते हैं।

for i in [0, 1, 2, 3, 4, 5]: print i**2 

अच्छा : सबसे अच्छा, एक जनरेटर के साथ। लेकिन 32-बिट सिस्टम में, एक मिलियन नंबरों की एक सूची ~ 32 एमबी मेमोरी पर कब्जा कर लेगी।

 for i in range(6): print i**2 

बहुत बढ़िया: सबसे अच्छा विकल्प। दूसरे के विपरीत, xrange एक समय में केवल एक मूल्य देता है, और आपको संपूर्ण सरणी को संग्रहीत करने के लिए अतिरिक्त मेमोरी की आवश्यकता नहीं होती है।

 for i in xrange(6): print i**2 

नोट : पायथन 3.3 में, xrange पहले से ही कर्नेल में है और बस range कहलाता range ।

सूची चक्र

खराब : अक्सर पूर्व सी प्रोग्रामर इसे लिखते हैं।

 colors = ['red', 'green', 'blue', 'yellow'] for i in range(len(colors)): print colors[i] 

अच्छा : सबसे अच्छा विकल्प।

 colors = ['red', 'green', 'blue', 'yellow'] for color in colors: print color 

लेकिन अगर आपको सूची के सामने से वापस जाने की आवश्यकता है?

ख़राब : फिर से, C से पास होने पर खुद को महसूस होता है

 colors = ['red', 'green', 'blue', 'yellow'] for i in range(len(colors)-1, -1, -1): print colors[i] 

अच्छा : लेकिन अजगर में वे इस तरह लिखते हैं:

 colors = ['red', 'green', 'blue', 'yellow'] for color in reversed(colors): print color 

सूचकांक सूची चक्र

ऊपर जैसा बुरा ।

 colors = ['red', 'green', 'blue', 'yellow'] for i in range(len(colors)): print i, '-->', colors[i] 

अच्छा : एक अधिक सुंदर विकल्प:

 colors = ['red', 'green', 'blue', 'yellow'] for i, color in enumerate(colors): print i, '-->', color 

डबल सूची चक्र

ऊपर जैसा बुरा ।

 names = ['raymond', 'rachel', 'matthew'] colors = ['red', 'green', 'blue', 'yellow'] n = min(len(names), len(colors)) for i in range(n): print names[i], '-->', colors[i] 

अच्छा : दो सूचियों में से हम एक सूची बनाते हैं। समस्या यह है कि zip पहले विकल्प की तुलना में अधिक मेमोरी का उपयोग करता है।

 names = ['raymond', 'rachel', 'matthew'] colors = ['red', 'green', 'blue', 'yellow'] for name, color in zip(names, colors): print name, '-->', color 

उत्कृष्ट : zip विपरीत, izip कैशिंग का उपयोग करता है, जो मेमोरी को बचाने में महत्वपूर्ण मदद करता है।

 names = ['raymond', 'rachel', 'matthew'] colors = ['red', 'green', 'blue', 'yellow'] for name, color in izip(names, colors): print name, '-->', color 

नोट : पायथन 3.3 में, izip कर्नेल को izip जाता है और इसे बस zip कहा जाता है।

एल्गोरिथ्म द्वारा क्रमबद्ध सूची

खराब : तुलना करने के लिए एक फ़ंक्शन का उपयोग करना।

 colors = ['red', 'green', 'blue', 'yellow'] def compare_length(c1, c2): if len(c1) < len(c2): return -1 if len(c1) > len(c2): return 1 return 0 print sorted(colors, cmp=compare_length) 

अच्छा : कुंजी छँटाई का उपयोग करना। बहुत कम मेमोरी का उपयोग करता है।

 colors = ['red', 'green', 'blue', 'yellow'] print sorted(colors, key=len) 

नोट : cmp विधि को पायथन 3.x कर्नेल से हटा दिया गया है।

शब्दकोश कुंजी चक्र

सामान्य विधि कुंजियों को वापस करती है। इस तरह के लूप के साथ, शब्दकोश की एक पुनरावृत्ति होती है, इसलिए, इसे प्रक्रिया में नहीं बदला जा सकता है।

 for k in d: print k 

शब्दकोश को लूप में बदलने के लिए, कुंजी लूप का उपयोग करें (उदाहरण: R शुरू होने वाली सभी कुंजियों को हटाना):

 for k in d.keys(): if k.startswith('R'): del d[k] 

इस मामले में, d.keys() शब्दकोश कुंजियों की एक प्रति बनाता है, जो हमें मूल संरचना के साथ स्वतंत्र रूप से काम करने की अनुमति देता है।

मुख्य चक्र और शब्दकोश मूल्य चक्र

खराब : चाबियाँ द्वारा लूप और अंतिम से वापसी मूल्य। धीमा तरीका:

 for k in d: print k, '-->', d[k] 

अच्छा : यह मूल्यों के माध्यम से लूप करने के लिए तेज़ है

 for k, v in d.items(): print k, '-->', v 

उत्कृष्ट : लेकिन सबसे अच्छा और सबसे तेज़ तरीका एक पुनरावृत्ति का उपयोग करना है:

 for k, v in d.iteritems(): print k, '-->', v 

दो सूचियों को एक शब्दकोश में संयोजित करना

बहुत तेजी से विधि, शब्दकोश उत्पन्न करने के लिए केवल एक टपल का उपयोग किया जाता है।

 names = ['raymond', 'rachel', 'matthew'] colors = ['red', 'green', 'blue'] d = dict(izip(names, colors)) # d    : # {'matthew': 'blue', 'rachel': 'green', 'raymond': 'red'} 

एक शब्दकोश में आइटम की गिनती

खराब : सामान्य तरीका:

 colors = ['red', 'green', 'red', 'blue', 'green', 'red'] d = {} for color in colors: if color not in d: d[color] = 0 d[color] += 1 #{'blue': 1, 'green': 2, 'red': 3} 

अच्छा : get() फ़ंक्शन का उपयोग करता है:

 colors = ['red', 'green', 'red', 'blue', 'green', 'red'] d = {} for color in colors: d[color] = d.get(color, 0) + 1 

महान : सबसे उन्नत तरीका है defaultdict() का उपयोग defaultdict() । लेकिन आपको पता होना चाहिए कि यह कैसे काम करता है ।

 d = defaultdict(int) for color in colors: d[color] += 1 

समूहीकरण सूची आइटम

खराब : यदि आपको कुछ मानदंड (उदाहरण में, स्ट्रिंग की लंबाई) द्वारा आइटम सूची करने की आवश्यकता है, तो वे अक्सर इस पद्धति का उपयोग करते हैं:

 names = ['raymond', 'rachel', 'matthew', 'roger', 'betty', 'melissa', 'judith', 'charlie'] d = {} for name in names: key = len(name) if key not in d: d[key] = [] d[key].append(name) {5: ['roger', 'betty'], 6: ['rachel', 'judith'], 7: ['raymond', 'matthew', 'melissa', 'charlie']} 

अच्छा : लेकिन बहुत अधिक सुरुचिपूर्ण और तेज़ तरीका है:

 d = defaultdict(list) for name in names: key = len(name) d[key].append(name) 

परिणाम

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

UPD : PyCon 2013 की वीडियो रिपोर्ट, जिसमें से कोड उदाहरण लिए गए थे: http://youtu.be/OSGv2VnC0go (अंग्रेजी में), अभी भी बहुत सारी रोचक जानकारी लेख में स्थानांतरित नहीं हुई है, साथ ही स्पीकर का हास्य और करिश्मा भी।