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

Question 1

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

घुमाव के दौरान:

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

पाश के लिए:

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

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

Question 2

निजी तौर पर:

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

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

Question 3

लूप के लिए निश्चित रूप से अधिक पाइथोनिक है, क्योंकि यह कार्यशीलता में निर्मित पायथन के उच्च स्तर का उपयोग करके यह बताता है कि आप और अधिक स्पष्ट और संक्षिप्त रूप से क्या कर रहे हैं। रेंज बनाम ओवरेंज के ओवरहेड, और अप्रयुक्त iचर को असाइन करना , वेरिलोग के 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 हैं - द ज़ेन ऑफ़ पायथन और PEP 8 - पायथन कोड के लिए स्टाइल गाइड ।

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

Question 4

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

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

def f(n):
    return n * n

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

Question 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__()

Question 6

किसी चीज़ को दोहराने का वास्तव में एक पैथोनिक तरीका नहीं है। हालांकि, यह एक बेहतर तरीका है:

map(lambda index:do_something(), xrange(10))

यदि आपको सूचकांक को पास करने की आवश्यकता है तो:

map(lambda index:do_something(index), xrange(10))

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