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

Question 1

Cada día amo más y más a Python.

Hoy, estaba escribiendo un código como:

for i in xrange(N):
    do_something()

Tuve que hacer algo N veces. Pero cada vez no dependía del valor de i (variable í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 hacer esto sin la necesidad de esa variable de índice inútil”.

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

Question 2

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

import itertools

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

Question 3

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

Question 4

solo uso for _ in range(n), va directo al grano. Va a generar la lista completa para números grandes en Python 2, pero si está usando Python 3, no hay problema.

Question 5

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

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

entonces puedes pasar la función como argumento.

Question 6

El _ es lo mismo que x. Sin embargo, es un idioma de Python que se usa para indicar un identificador que no tiene la intención de usar. En python, estos identificadores no requieren memoria 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.

Question 7

Encontré las diversas respuestas realmente elegantes (especialmente las de Alex Martelli), pero quería cuantificar el rendimiento de primera mano, así que preparé el siguiente guión:

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 utiliza map() para llamar a la función de carga útil. Bien, hice un poco de trampa porque me tomé la libertad de hacer que la carga útil aceptara un parámetro que se descarta: no sé si hay alguna forma de evitarlo. Sin embargo, aquí están los resultados:

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

por lo que el uso de map produce una mejora de aproximadamente un 30 % sobre el bucle for estándar y un 19 % adicional sobre el de Martelli.

Question 8

Suponga que ha definido hacer algo como una función, y le gustaría realizarla norte veces. Tal vez puedas probar lo siguiente:

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

¿Ha sido útil esta solución?