modo pitonico di fare qualcosa N volte senza una variabile indice?

Ogni giorno amo sempre più il pitone.

Oggi stavo scrivendo un codice come:

for i in xrange(N):
    do_something()

Ho dovuto fare qualcosa N volte. Ma ogni volta non dipendeva dal valore di i(variabile indice). Mi sono reso conto che stavo creando una variabile che non avevo mai usato ( i), e ho pensato "Esiste sicuramente un modo più pitonico di farlo senza la necessità di quella inutile variabile indice".

Quindi ... la domanda è: sai come fare questo semplice compito in un modo più (pitone) bello?

Un approccio leggermente più veloce rispetto al looping xrange(N)è:

import itertools

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

Usa la variabile _, come ho appreso quando ho posto questa domanda , ad esempio:

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

Uso solo for _ in range(n), è dritto al punto. Genererà l'intero elenco per numeri enormi in Python 2, ma se stai usando Python 3 non è un problema.

poiché la funzione è un cittadino di prima classe, puoi scrivere un piccolo wrapper (dalle risposte di Alex)

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

quindi puoi passare la funzione come argomento.

_ È la stessa cosa di x. Tuttavia è un idioma di Python utilizzato per indicare un identificatore che non si intende utilizzare. In Python questi identificatori non memorizzano o allocano lo spazio come fanno le variabili in altre lingue. È facile dimenticarlo. Sono solo nomi che puntano a oggetti, in questo caso un numero intero su ogni iterazione.

Ho trovato le varie risposte davvero eleganti (soprattutto quelle di Alex Martelli) ma volevo quantificare le prestazioni in prima persona, quindi ho elaborato il seguente 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))

Ho anche trovato una soluzione alternativa che si basa su quella di Martelli e utilizza map()per chiamare la funzione di payload. OK, ho tradito un po 'il fatto che mi sono preso la libertà di far accettare al parametro payload un parametro che viene scartato: non so se c'è un modo per aggirare questo. Tuttavia, ecco i risultati:

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

quindi l'utilizzo di map produce un miglioramento di circa il 30% rispetto allo standard per loop e di un ulteriore 19% rispetto a Martelli.

Supponi di aver definito do_something come una funzione e che desideri eseguirlo N volte. Forse puoi provare quanto segue:

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

Che ne dici di un semplice ciclo while?

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

Hai già la variabile; perché non usarlo?