pythonischer Weg, etwas N-mal ohne Indexvariable zu machen?

Jeden Tag liebe ich Python mehr und mehr.

Heute habe ich einen Code geschrieben wie:

for i in xrange(N):
    do_something()

Ich musste N-mal etwas tun. Aber jedes Mal hing es nicht vom Wert von i(Indexvariable) ab. Mir wurde klar, dass ich eine Variable erstellte, die ich nie verwendet habe (i ), und dachte: "Es gibt sicherlich einen pythonischeren Weg, dies zu tun, ohne dass diese nutzlose Indexvariable benötigt wird."

Also ... die Frage ist: Weißt du, wie man diese einfache Aufgabe (pythonischer) schöner macht?

Ein etwas schnellerer Ansatz als das Schleifen xrange(N)ist:

import itertools

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

Verwenden Sie die Variable _, wie ich bei der Beantwortung dieser Frage erfahren habe , zum Beispiel:

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

Ich benutze nur for _ in range(n), es ist direkt auf den Punkt. Es wird die gesamte Liste für große Zahlen in Python 2 generieren, aber wenn Sie Python 3 verwenden, ist dies kein Problem.

Da die Funktion ein erstklassiger Bürger ist, können Sie einen kleinen Wrapper schreiben (aus Alex Antworten).

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

dann können Sie die Funktion als Argument übergeben.

Das _ ist dasselbe wie x. Es ist jedoch eine Python-Sprache, die verwendet wird, um einen Bezeichner anzugeben, den Sie nicht verwenden möchten. In Python benötigen diese Bezeichner kein Memor oder weisen keinen Speicherplatz zu, wie dies bei Variablen in anderen Sprachen der Fall ist. Das kann man leicht vergessen. Es sind nur Namen, die auf Objekte verweisen, in diesem Fall eine Ganzzahl bei jeder Iteration.

Ich fand die verschiedenen Antworten sehr elegant (insbesondere die von Alex Martelli), wollte aber die Leistung aus erster Hand quantifizieren und habe mir das folgende Skript ausgedacht:

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

Ich habe mir auch eine alternative Lösung ausgedacht, die auf der von Martelli aufbaut und map()zum Aufrufen der Nutzlastfunktion verwendet wird. OK, ich habe ein bisschen geschummelt, weil ich mir die Freiheit genommen habe, die Nutzlast dazu zu bringen, einen Parameter zu akzeptieren, der verworfen wird: Ich weiß nicht, ob es einen Weg gibt, dies zu umgehen. Trotzdem hier die Ergebnisse:

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

Die Verwendung der Karte ergibt also eine Verbesserung von ungefähr 30% gegenüber dem Standard für Schleifen und zusätzlichen 19% gegenüber Martellis.

Angenommen, Sie haben do_something als Funktion definiert und möchten diese N- mal ausführen . Vielleicht können Sie Folgendes versuchen:

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

Was ist mit einer einfachen while-Schleife?

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

Sie haben bereits die Variable; warum nicht benutzen?