Une façon plus pythonique d'exécuter un processus X fois

Question

Lequel est le plus pythonique ?

La boucle "While" :

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

Pour la boucle :

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

Edit : pas de duplication car il y a des réponses pour déterminer ce qui est le plus clair, par rapport à la façon d'exécuter une plage sans 'i' -- même si cela s'est avéré être le plus élégant.

Answer 1

Personnellement :

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

si vous n'avez pas besoin i . Si vous utilisez Python < 3 et que vous voulez répéter la boucle un grand nombre de fois, utilisez xrange car il n'est pas nécessaire de générer toute la liste au préalable.

Answer 2

Si vous recherchez les effets secondaires qui se produisent à l'intérieur de la boucle, j'opterais personnellement pour la solution suivante range() l'approche.

Si vous vous souciez du résultat des fonctions que vous appelez à l'intérieur de la boucle, j'opterais pour une compréhension de liste ou un map l'approche. Voici ce qu'il en est :

def f(n):
    return n * n

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

Answer 3

La boucle for est nettement plus pythonique, car elle utilise les fonctionnalités intégrées de haut niveau de Python pour transmettre ce que vous faites de manière plus claire et plus concise. Les frais généraux de range vs xrange, et l'assignation d'une valeur inutilisée de i découlent de l'absence d'une déclaration telle que celle de Verilog repeat déclaration. La principale raison de s'en tenir à la solution de la fourchette 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 repeat au lieu de range est moins claire parce que la fonction n'est pas aussi connue, et plus complexe parce qu'il faut l'importer. Si vous avez besoin d'une référence, les principaux guides de style sont les suivants PEP 20 - Le zen de Python y PEP 8 - Guide de style pour le code Python .

Nous notons également que la version à fourchettes est un exemple explicite utilisé à la fois dans le référence linguistique y tutoriel 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.

Answer 4

Les deux sont suffisamment "pythoniques".

Answer 5

Qu'en est-il ?

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

ou d'une manière plus laide :

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

ou si vous voulez voir la dernière fois :

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