façon pythonique de faire quelque chose N fois sans variable d'index?

Chaque jour, j'aime de plus en plus python.

Aujourd'hui, j'écrivais du code comme:

for i in xrange(N):
    do_something()

J'ai dû faire quelque chose N fois. Mais chaque fois ne dépendait pas de la valeur de i(variable d'index). J'ai réalisé que je créais une variable que je n'avais jamais utilisée ( i), et j'ai pensé "Il y a sûrement une manière plus pythonique de faire cela sans avoir besoin de cette variable d'index inutile."

Alors ... la question est: savez-vous comment faire cette tâche simple d'une manière plus (pythonique) belle?

Une approche légèrement plus rapide que le bouclage xrange(N)est:

import itertools

for _ in itertools.repeat(None, N):
    do_something()

Utilisez la variable _, comme je l'ai appris lorsque j'ai posé cette question , par exemple:

# A long way to do integer exponentiation
num = 2
power = 3
product = 1
for _ in xrange(power):
    product *= num
print product

J'utilise juste for _ in range(n), c'est droit au but. Cela va générer la liste complète des nombres énormes dans Python 2, mais si vous utilisez Python 3, ce n'est pas un problème.

puisque la fonction est un citoyen de première classe, vous pouvez écrire un petit wrapper (à partir des réponses d'Alex)

def repeat(f, N):
    for _ in itertools.repeat(None, N): f()

alors vous pouvez passer la fonction comme argument.

Le _ est la même chose que x. Cependant, c'est un idiome python utilisé pour indiquer un identifiant que vous n'avez pas l'intention d'utiliser. En python, ces identificateurs ne prennent pas de mémoire ni n'allouent d'espace comme le font les variables dans d'autres langages. C'est facile de l'oublier. Ce ne sont que des noms qui pointent vers des objets, dans ce cas un entier à chaque itération.

J'ai trouvé les différentes réponses très élégantes (en particulier celles d'Alex Martelli) mais je voulais quantifier les performances de première main, alors j'ai concocté le scénario suivant:

from itertools import repeat
N = 10000000

def payload(a):
    pass

def standard(N):
    for x in range(N):
        payload(None)

def underscore(N):
    for _ in range(N):
        payload(None)

def loopiter(N):
    for _ in repeat(None, N):
        payload(None)

def loopiter2(N):
    for _ in map(payload, repeat(None, N)):
        pass

if __name__ == '__main__':
    import timeit
    print("standard: ",timeit.timeit("standard({})".format(N),
        setup="from __main__ import standard", number=1))
    print("underscore: ",timeit.timeit("underscore({})".format(N),
        setup="from __main__ import underscore", number=1))
    print("loopiter: ",timeit.timeit("loopiter({})".format(N),
        setup="from __main__ import loopiter", number=1))
    print("loopiter2: ",timeit.timeit("loopiter2({})".format(N),
        setup="from __main__ import loopiter2", number=1))

J'ai également proposé une solution alternative qui s'appuie sur celle de Martelli et utilise map()pour appeler la fonction de charge utile. OK, j'ai un peu triché en ce sens que j'ai pris la liberté de faire accepter à la charge utile un paramètre qui est rejeté: je ne sais pas s'il existe un moyen de contourner cela. Néanmoins, voici les résultats:

standard:  0.8398549720004667
underscore:  0.8413165839992871
loopiter:  0.7110594899968419
loopiter2:  0.5891903560004721

donc l'utilisation de la carte donne une amélioration d'environ 30% par rapport à la boucle standard pour et 19% supplémentaires par rapport à celle de Martelli.

Supposons que vous ayez défini do_something comme une fonction et que vous souhaitiez l'exécuter N fois. Vous pouvez peut-être essayer ce qui suit:

todos = [do_something] * N  
for doit in todos:  
    doit()

Qu'en est-il d'une simple boucle while?

while times > 0:
    do_something()
    times -= 1

Vous avez déjà la variable; pourquoi ne pas l'utiliser?