Modo più pitonico per eseguire un processo X volte

Qual è più pitonico?

While loop:

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

Per loop:

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

Modifica: non duplicare perché questo ha risposte per determinare quale è più chiaro, rispetto a come eseguire un intervallo senza "i", anche se è risultato il più elegante

Personalmente:

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

se non ti serve i. Se usi Python <3 e vuoi ripetere il ciclo molte volte, usalo xrangepoiché non è necessario generare l'intera lista in anticipo.

Il ciclo for è decisamente più pitonico, poiché utilizza le funzionalità integrate di livello superiore di Python per trasmettere ciò che stai facendo in modo più chiaro e conciso. L'overhead di range vs xrange e l'assegnazione di una ivariabile inutilizzata derivano dall'assenza di un'istruzione come l' repeataffermazione di Verilog . Il motivo principale per attenersi alla soluzione for range è che altri modi sono più complessi. Per esempio:

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"

L'uso della ripetizione al posto dell'intervallo qui è meno chiaro perché non è una funzione così nota e più complesso perché è necessario importarlo. Le guide di stile principali se hai bisogno di un riferimento sono PEP 20 - The Zen of Python e PEP 8 - Style Guide for Python Code .

Notiamo anche che la versione for range è un esempio esplicito utilizzato sia in riferimento linguaggio che nel tutorial , sebbene in tal caso venga utilizzato il valore. Significa che la forma è destinata ad essere più familiare dell'espansione while di un ciclo for in stile C.

Se stai cercando gli effetti collaterali che si verificano all'interno del ciclo, personalmente sceglierei range() approccio.

Se ti interessa il risultato di qualunque funzione chiami all'interno del ciclo, sceglierei una comprensione o un mapapproccio di elenco . Qualcosa come questo:

def f(n):
    return n * n

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

Che ne dite di?

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

o in un modo più brutto:

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

o se vuoi vedere l'ultima volta:

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

dove:

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

Non esiste un modo veramente pitonico di ripetere qualcosa. Tuttavia, è un modo migliore:

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

Se devi superare l'indice, allora:

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

Considera che restituisce i risultati come raccolta. Quindi, se hai bisogno di raccogliere i risultati, può aiutare.