maneira pitônica de fazer algo N vezes sem uma variável de índice?

Todos os dias eu amo python cada vez mais.

Hoje, eu estava escrevendo um código como:

for i in xrange(N):
    do_something()

Eu tive que fazer algo N vezes. Mas cada vez que não dependia do valor dei (variável de índice). Percebi que estava criando uma variável que nunca usei ( i) e pensei: "Certamente há uma maneira mais pitônica de fazer isso sem a necessidade dessa variável de índice inútil".

Então ... a pergunta é: você sabe como fazer essa tarefa simples de uma maneira mais bonita (pitônica)?

Uma abordagem um pouco mais rápida do que a repetição xrange(N)é:

import itertools

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

Use a variável _, como aprendi quando fiz essa pergunta , por exemplo:

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

Eu apenas uso for _ in range(n), é direto ao ponto. Ele irá gerar a lista inteira para grandes números no Python 2, mas se você estiver usando o Python 3, não será um problema.

como a função é um cidadão de primeira classe, você pode escrever um pequeno invólucro (das respostas de Alex)

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

então você pode passar a função como argumento.

_ É a mesma coisa que x. No entanto, é um idioma python usado para indicar um identificador que você não pretende usar. Em python, esses identificadores não ocupam memória ou alocam espaço, como as variáveis ​​em outros idiomas. É fácil esquecer isso. Eles são apenas nomes que apontam para objetos, neste caso, um número inteiro em cada iteração.

Achei as várias respostas realmente elegantes (principalmente as de Alex Martelli), mas queria quantificar o desempenho em primeira mão, então preparei o seguinte 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))

Eu também vim com uma solução alternativa que se baseia na de Martelli e usa map()para chamar a função de carga útil. OK, enganei-me um pouco porque tive a liberdade de fazer a carga aceitar um parâmetro que é descartado: não sei se há uma maneira de contornar isso. No entanto, aqui estão os resultados:

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

portanto, o uso do mapa gera uma melhoria de aproximadamente 30% sobre o padrão para loop e de 19% extra sobre o Martelli.

Suponha que você definiu do_something como uma função e gostaria de executá-lo N vezes. Talvez você possa tentar o seguinte:

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

Que tal um loop while simples?

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

Você já tem a variável; por que não usá-lo?