जब पायथन में प्रोग्रामिंग याद करने वाली चीजें

ज़ेन पायथन

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

एक बार मेरा ध्यान इस ओर आकर्षित हुआ:

सुंदर बदसूरत से बेहतर है

UPDATE: हैकर न्यूज़ के इस लेख पर काफी चर्चाएँ हुईं। उनसे कुछ सुधार।

मुझे एक फ़ंक्शन दें जो संख्याओं की एक सूची लेता है और केवल दो से विभाजित संख्याओं को लौटाता है।

#----------------------------------------------------------------------- halve_evens_only = lambda nums: map(lambda i: i/2, filter(lambda i: not i%2, nums)) #----------------------------------------------------------------------- def halve_evens_only(nums): return [i/2 for i in nums if not i % 2] 

पायथन में बहुत सरल चीजों को याद रखें

दो चर के मूल्यों का आदान-प्रदान:

  a, b = b, a 

स्लाइस के लिए चरण तर्क। उदाहरण के लिए:

  a = [1,2,3,4,5] >>> a[::2] # iterate over the whole list in 2-increments [1,3,5] 

विशेष मामला x [:: - 1] x.reverse () व्यक्त करने का एक साधन है।

  >>> a[::-1] [5,4,3,2,1] 

अद्यतन: ध्यान रखें x.reverse () सूची को फ़्लिप करता है, और स्लाइस आपको ऐसा करने की क्षमता देता है:

  >>> x[::-1] [5, 4, 3, 2, 1] >>> x[::-2] [5, 3, 1] 

• डिफ़ॉल्ट मानों के लिए परिवर्तनशील परिवर्तनीय प्रकारों का उपयोग न करें

  def function(x, l=[]): # Don't do this def function(x, l=None): # Way better if l is None: l = [] 

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

• वस्तुओं का उपयोग करें न कि वस्तुओं का

iteritems जनरेटर का उपयोग करता है और इसलिए बहुत बड़ी सूचियों के साथ काम करते समय यह बेहतर है।

  d = {1: "1", 2: "2", 3: "3"} for key, val in d.items() # builds complete list when called. for key, val in d.iteritems() # calls values only when requested. 

यह सीमा और xrange के समान है जब xrange केवल पूछे जाने वाले मानों को आमंत्रित करता है।

अद्यतन: ध्यान दें कि पुनरावृत्तियों , पुनरावृत्तियों , पुनरावृत्तियों को पायथन 3.x से हटा दिया गया है। dict.keys () , dict.items () और dict.values ​​() सूची के बजाय विचार लौटाएगा। docs.python.org/release/3.1.5/whatsnew/3.0.html#views-and-iterators-instead-of-lists

• का प्रयोग करें और प्रकार नहीं है

न करें:

  if type(s) == type(""): ... if type(seq) == list or \ type(seq) == tuple: ... 

बेहतर:

  if isinstance(s, basestring): ... if isinstance(seq, (list, tuple)): ... 

आपको ऐसा क्यों नहीं करना चाहिए: stackoverflow.com/a/1549854/504262

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

  >>> a=u'aaaa' >>> print isinstance(a, basestring) True >>> print isinstance(a, str) False 

ऐसा इसलिए है क्योंकि पायथन संस्करणों <3.0 में दो स्ट्रिंग प्रकार हैं: str और यूनिकोड :

  object | | basestring / \ / \ str unicode 

• विभिन्न संग्रहों का अन्वेषण करें

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

ज्यादातर मामलों में, इनका उपयोग किया जाता है:

अद्यतन: मुझे पता है कि अधिकांश ने इसका उपयोग नहीं किया है। मेरी ओर से अभद्रता। कुछ इसे लिख सकते हैं:

  freqs = {} for c in "abracadabra": try: freqs[c] += 1 except: freqs[c] = 1 

कुछ कह सकते हैं कि यह बेहतर होगा:

  freqs = {} for c in "abracadabra": freqs[c] = freqs.get(c, 0) + 1 

इसके बजाय, प्रकार के डिफ़ॉल्ट के संग्रह का उपयोग करें:

  from collections import defaultdict freqs = defaultdict(int) for c in "abracadabra": freqs[c] += 1 

अन्य संग्रह

  namedtuple() # factory function for creating tuple subclasses with named fields deque # list-like container with fast appends and pops on either end Counter # dict subclass for counting hashable objects OrderedDict # dict subclass that remembers the order entries were added defaultdict # dict subclass that calls a factory function to supply missing values 

अद्यतन: जैसा कि हैकर समाचार पर कई टिप्पणियों में उल्लेख किया गया है, मैं डिफॉल्ट के बजाय काउंटर का उपयोग कर सकता हूं ।

  >>> from collections import Counter >>> c = Counter("abracadabra") >>> c['a'] 5 

• पायथन में कक्षाएं बनाते समय, जादू के तरीकों का उपयोग करें

  __eq__(self, other) # Defines behavior for the equality operator, ==. __ne__(self, other) # Defines behavior for the inequality operator, !=. __lt__(self, other) # Defines behavior for the less-than operator, <. __gt__(self, other) # Defines behavior for the greater-than operator, >. __le__(self, other) # Defines behavior for the less-than-or-equal-to operator, <=. __ge__(self, other) # Defines behavior for the greater-than-or-equal-to operator, >=. 

कई अन्य जादुई तरीके हैं।

• सशर्त नियुक्तियों

  x = 3 if (y == 1) else 2 

यह कोड ठीक वैसा ही है जैसा लगता है: " 3 से x असाइन करें यदि y = 1 , अन्यथा 2 से x असाइन करें"। आप इसे लागू कर सकते हैं यदि आपके पास कुछ अधिक जटिल है:

  x = 3 if (y == 1) else 2 if (y == -1) else 1 

हालांकि कुछ बिंदु पर यह बहुत दूर चला जाता है।

ध्यान दें कि आप किसी भी अभिव्यक्ति में अगर ... का उपयोग कर सकते हैं। उदाहरण के लिए:

  (func1 if y == 1 else func2)(arg1, arg2) 

Func1 यहाँ बुलाया जाएगा अगर y = 1 , और func2 अन्यथा। दोनों मामलों में, तर्कों arg1 और arg2 के साथ संबंधित फ़ंक्शन को बुलाया जाएगा।

इसी तरह, निम्नलिखित भी सच है:

  x = (class1 if y == 1 else class2)(arg1, arg2) 

जहाँ class1 और class2 वर्ग हैं।

• आवश्यक होने पर एलिप्सिस का प्रयोग करें।

अद्यतन: हैकर समाचार टिप्पणीकारों में से एक ने उल्लेख किया: "सभी तत्वों को प्राप्त करने के लिए दीर्घवृत्त का उपयोग करना" केवल एक ही मार्ग के लक्ष्य को प्राप्त करने के सिद्धांत का उल्लंघन करता है। मानक पदनाम [:] है । मैं उससे सहमत हूं। स्टैकओवरफ़्लो पर बेस्ट नम्पी उपयोग उदाहरण:

एलिप्सिस का उपयोग बहुआयामी डेटा संरचनाओं को स्लाइस करने के लिए किया जाता है।

इस स्थिति में, इसका मतलब है कि आपको सभी आयामों में बहुआयामी स्लाइस का विस्तार करने की आवश्यकता है।

एक उदाहरण:

  >>> from numpy import arange >>> a = arange(16).reshape(2,2,2,2) 

अब आपके पास ऑर्डर 2x2x2x2 का 4-आयामी मैट्रिक्स है। 4 वें आयाम के सभी पहले तत्वों का चयन करने के लिए, आप दीर्घवृत्त का उपयोग कर सकते हैं:

  >>> a[..., 0].flatten() array([ 0, 2, 4, 6, 8, 10, 12, 14]) 

जो लिखने के बराबर है:

  >>> a[:,:,:,0].flatten() array([ 0, 2, 4, 6, 8, 10, 12, 14]) 

पिछले प्रस्ताव।

कक्षा बनाते समय, आप __getitem__ का उपयोग करके अपनी कक्षा की वस्तु को शब्दकोश की तरह व्यवहार कर सकते हैं। इस वर्ग को एक उदाहरण के रूप में लें:

  class MyClass(object): def __init__(self, a, b, c, d): self.a, self.b, self.c, self.d = a, b, c, d def __getitem__(self, item): return getattr(self, item) x = MyClass(10, 12, 22, 14) 

__Getitem__ के कारण , आप x ['a'] के रूप में ऑब्जेक्ट x का मान प्राप्त कर पाएंगे। यह शायद एक ज्ञात तथ्य है।

इस ऑब्जेक्ट का उपयोग पायथन स्लाइस docs.python.org/library/stdtypes.html#bltin-ellipsis-object को विस्तारित करने के लिए किया जाता है , इसलिए यदि हम जोड़ते हैं:

  def __getitem__(self, item): if item is Ellipsis: return [self.a, self.b, self.c, self.d] else: return getattr(self, item) 

हम सभी तत्वों की सूची प्राप्त करने के लिए x [...] का उपयोग कर सकते हैं।

  >>> x = MyClass(11, 34, 23, 12) >>> x[...] [11, 34, 23, 12] 

---

पुनश्च

यह सत्यजीत रंजीव के पोस्ट का अनुवाद है - " अजगर में कोडिंग करते समय याद रखने वाली कुछ बातें। " लेकिन ट्रांसफर हब में मेरे पास 0.5 कर्म नहीं हैं, और यह मुझे ड्राफ्ट को बचाने की अनुमति नहीं देता है, इसलिए मैं इसे पोस्ट करता हूं। कृपया सभी टिप्पणियाँ पीएम में अनुवाद और वर्तनी पर भेजें, और अधिक न डालें =)