Une manière plus pythonique d'exécuter un processus X fois

Lequel est le plus pythonique?

En boucle:

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

Pour la boucle:

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

Edit: ne pas dupliquer car cela a des réponses pour déterminer ce qui est le plus clair, vs comment exécuter une plage sans `` i '' - même si cela a fini par être le plus élégant

Personnellement:

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

si vous n'en avez pas besoin i. Si vous utilisez Python <3 et que vous souhaitez répéter la boucle plusieurs fois, utilisez xrangecar il n'est pas nécessaire de générer la liste complète au préalable.

La boucle for est définitivement plus pythonique, car elle utilise la fonctionnalité intégrée de niveau supérieur de Python pour transmettre ce que vous faites à la fois plus clairement et plus précisément. La surcharge de range vs xrange, et l'attribution d'une ivariable inutilisée , proviennent de l'absence d'une instruction comme celle de Verilog repeat. La principale raison de s'en tenir à la solution pour la plage est que les autres méthodes sont plus complexes. Par exemple:

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'utilisation de la répétition au lieu de la plage est ici moins claire car ce n'est pas une fonction aussi connue, et plus complexe car vous devez l'importer. Les principaux guides de style si vous avez besoin d'une référence sont PEP 20 - Le Zen de Python et PEP 8 - Guide de style pour le code Python .

Nous notons également que la version for range est un exemple explicite utilisé à la fois dans la référence de langage et dans le didacticiel , bien que dans ce cas, la valeur soit utilisée. Cela signifie que la forme est forcément plus familière que l'expansion while d'une boucle for de style C.

Si vous recherchez les effets secondaires qui se produisent dans la boucle, je choisirais personnellement l' range()approche.

Si vous vous souciez du résultat des fonctions que vous appelez dans la boucle, j'opterais pour une compréhension ou une mapapproche de liste . Quelque chose comme ça:

def f(n):
    return n * n

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

Que diriez-vous?

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

ou d'une manière plus moche:

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

ou si vous voulez attraper la dernière fois à travers:

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

où:

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

Il n'y a pas de manière vraiment pythonique de répéter quelque chose. Cependant, c'est un meilleur moyen:

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

Si vous devez passer l'index, alors:

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

Considérez qu'il renvoie les résultats sous forme de collection. Donc, si vous avez besoin de collecter les résultats, cela peut vous aider.