forma pitónica de hacer algo N veces sin una variable de índice?

Todos los días amo Python más y más.

Hoy estaba escribiendo un código como:

for i in xrange(N):
    do_something()

Tenía que hacer algo N veces. Pero cada vez no dependía del valor de i(variable de índice). Me di cuenta de que estaba creando una variable que nunca usé ( i), y pensé "Seguramente hay una forma más pitónica de hacerlo sin la necesidad de esa variable de índice inútil".

Entonces ... la pregunta es: ¿sabes cómo hacer esta tarea simple de una manera más hermosa (pitónica)?

Un enfoque un poco más rápido que el bucle xrange(N)es:

import itertools

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

Use la variable _, como aprendí cuando hice esta pregunta , por ejemplo:

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

Solo uso for _ in range(n), es directo al grano. Generará la lista completa para grandes números en Python 2, pero si está usando Python 3 no es un problema.

Dado que la función es un ciudadano de primera clase, puede escribir un pequeño contenedor (de las respuestas de Alex)

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

entonces puedes pasar la función como argumento.

El _ es lo mismo que x. Sin embargo, es un idioma de Python que se utiliza para indicar un identificador que no tiene intención de usar. En python, estos identificadores no toman memor ni asignan espacio como lo hacen las variables en otros idiomas. Es fácil olvidar eso. Son solo nombres que apuntan a objetos, en este caso un número entero en cada iteración.

Las varias respuestas me parecieron realmente elegantes (especialmente las de Alex Martelli) pero quería cuantificar el rendimiento de primera mano, así que preparé el siguiente script:

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

También se me ocurrió una solución alternativa que se basa en la de Martelli y que se usa map()para llamar a la función de carga útil. Bien, hice un poco de trampa al tomar la libertad de hacer que la carga útil aceptara un parámetro que se descarta: no sé si hay alguna forma de evitar esto. Sin embargo, aquí están los resultados:

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

por lo tanto, el uso del mapa produce una mejora de aproximadamente el 30% sobre el bucle estándar y un 19% adicional sobre el de Martelli.

Suponga que ha definido do_something como una función y le gustaría realizarlo N veces. Quizás puedas probar lo siguiente:

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

¿Qué pasa con un simple ciclo while?

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

Ya tienes la variable; ¿Por qué no usarlo?