pythonowy sposób na zrobienie czegoś N razy bez zmiennej indeksu?

Każdego dnia coraz bardziej kocham Pythona.

Dzisiaj pisałem kod taki jak:

for i in xrange(N):
    do_something()

Musiałem coś zrobić N razy. Ale za każdym razem nie zależało od wartości i(zmienna indeksu). Zdałem sobie sprawę, że tworzę zmienną, której nigdy nie używałem ( i), i pomyślałem: „Z pewnością istnieje bardziej pythonowy sposób zrobienia tego bez potrzeby stosowania tej bezużytecznej zmiennej indeksu”.

A więc ... pytanie brzmi: czy wiesz, jak wykonać to proste zadanie w bardziej (pytonicznie) piękny sposób?

Nieco szybszym podejściem niż zapętlenie xrange(N)jest:

import itertools

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

Użyj zmiennej _, jak się nauczyłem , zadając to pytanie , na przykład:

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

Po prostu używam for _ in range(n), to jest od razu do rzeczy. W Pythonie 2 wygeneruje całą listę ogromnych liczb, ale jeśli używasz Pythona 3, nie stanowi to problemu.

ponieważ funkcja jest obywatelem pierwszej klasy, możesz napisać małe opakowanie (od odpowiedzi Alexa)

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

wtedy możesz przekazać funkcję jako argument.

_ Jest tym samym, co x. Jednak jest to idiom Pythona, który służy do wskazania identyfikatora, którego nie zamierzasz używać. W Pythonie te identyfikatory nie zajmują pamięci ani nie przydzielają miejsca, jak zmienne w innych językach. Łatwo o tym zapomnieć. To tylko nazwy wskazujące na obiekty, w tym przypadku liczba całkowita w każdej iteracji.

Uważam, że różne odpowiedzi są naprawdę eleganckie (szczególnie Alex Martelli), ale chciałem oszacować wydajność z pierwszej ręki, więc przygotowałem następujący scenariusz:

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

Wymyśliłem również alternatywne rozwiązanie, które opiera się na rozwiązaniu Martelliego i używa map()do wywołania funkcji ładunku. OK, trochę oszukałem, ponieważ pozwoliłem sobie na to, by ładunek akceptował parametr, który zostanie odrzucony: nie wiem, czy istnieje sposób na obejście tego. Niemniej jednak oto wyniki:

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

więc użycie mapy daje poprawę o około 30% w stosunku do standardowej pętli i dodatkowe 19% w porównaniu ze standardem Martelli.

Załóżmy, że zdefiniowałeś funkcję do_something jako funkcję i chcesz wykonać ją N razy. Może możesz spróbować następujących rzeczy:

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

A co z prostą pętlą while?

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

Masz już zmienną; dlaczego tego nie użyć?