एक प्रक्रिया एक्स टाइम्स चलाने के लिए अधिक पाइथोनिक तरीका

Question

कौन सा पायथनिक है?

पाश जबकि:

count = 0 
while count < 50: 
    print "Some thing" 
    count = count + 1 

पाश के लिए:

for i in range(50): 
    print "Some thing" 

संपादित करें: नकल नहीं है क्योंकि इस निर्धारित करने के लिए जो स्पष्ट है जवाब है, बनाम कैसे बिना एक सीमा को चलाने के लिए 'मैं' - भले ही यह सबसे सुरुचिपूर्ण

Answer 1

निजी तौर पर:

for _ in range(50): 
    print "Some thing" 

आप i की जरूरत नहीं है, तो। यदि आप पाइथन < 3 का उपयोग करते हैं और आप लूप को कई बार दोहराना चाहते हैं, तो xrange का उपयोग करें क्योंकि पूरी सूची को पहले से उत्पन्न करने की आवश्यकता नहीं है।

Answer 2

हो गया है यदि आप एस के बाद हैं लूप के भीतर होने वाले विचार प्रभाव, मैं व्यक्तिगत रूप से range() दृष्टिकोण के लिए जाता हूं।

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

def f(n): 
    return n * n 

results = [f(i) for i in range(50)] 
# or using map: 
results = map(f, range(50)) 

Answer 3

कुछ दोहराने का वास्तव में पाइथोनिक तरीका नहीं है।

नक्शा: हालांकि, यह एक बेहतर तरीका है (लैम्ब्डा सूचकांक: (do_something), xrange (10))

अगर आप सूचकांक तो पारित करने के लिए की जरूरत है:

नक्शा (लैम्ब्डा सूचकांक: do_something (इंडेक्स), xrange (10))

मान लें कि यह परिणाम संग्रह के रूप में लौटाता है, इसलिए यदि आपको परिणाम एकत्र करने की आवश्यकता है तो इससे मदद मिल सकती है।

Answer 4

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

from itertools import repeat 

for unused in repeat(None, 10): 
    del unused # redundant and inefficient, the name is clear enough 
    print "This is run 10 times" 

रेंज के बजाय दोहराने का उपयोग करते हुए यहां कम स्पष्ट है क्योंकि यह नहीं और साथ ही एक समारोह, और अधिक जटिल में जाना जाता है क्योंकि आप इसे आयात करने की आवश्यकता है। यदि आपको संदर्भ की आवश्यकता है तो मुख्य शैली मार्गदर्शिका PEP 20 - The Zen of Python और PEP 8 - Style Guide for Python Code हैं।

हम यह भी ध्यान देते हैं कि श्रेणी संस्करण के लिए language reference और tutorial दोनों में उपयोग किया जाने वाला एक स्पष्ट उदाहरण है, हालांकि उस स्थिति में मान का उपयोग किया जाता है। इसका मतलब यह है कि लूप के लिए सी-शैली के विस्तार के दौरान फॉर्म अधिक परिचित होने के लिए बाध्य है।

Answer 5

कैसे?

while BoolIter(N, default=True, falseIndex=N-1): 
    print 'some thing' 

या एक अधिक बदसूरत तरह से:

for _ in BoolIter(N): 
    print 'doing somthing' 

या आप के माध्यम से पिछली बार पकड़ने के लिए चाहते हैं:

for lastIteration in BoolIter(N, default=False, trueIndex=N-1): 
    if not lastIteration: 
     print 'still going' 
    else: 
     print 'last time' 

जहां:

क्रम में

class BoolIter(object): 

    def __init__(self, n, default=False, falseIndex=None, trueIndex=None, falseIndexes=[], trueIndexes=[], emitObject=False): 
     self.n = n 
     self.i = None 
     self._default = default 
     self._falseIndexes=set(falseIndexes) 
     self._trueIndexes=set(trueIndexes) 
     if falseIndex is not None: 
      self._falseIndexes.add(falseIndex) 
     if trueIndex is not None: 
      self._trueIndexes.add(trueIndex) 
     self._emitObject = emitObject 


    def __iter__(self): 
     return self 

    def next(self): 
     if self.i is None: 
      self.i = 0 
     else: 
      self.i += 1 
     if self.i == self.n: 
      raise StopIteration 
     if self._emitObject: 
      return self 
     else: 
      return self.__nonzero__() 

    def __nonzero__(self): 
     i = self.i 
     if i in self._trueIndexes: 
      return True 
     if i in self._falseIndexes: 
      return False 
     return self._default 

    def __bool__(self): 
     return self.__nonzero__()