Welche Methode der Python-Schleifen am schnellsten ist, kann Ihr Verständnis untergraben!

Wie wir alle wissen, ist Python keine effiziente Sprache. Darüber hinaus ist das Schleifen in jeder Sprache ein sehr zeitaufwändiger Vorgang. Wenn ein einfacher Einzelschrittvorgang eine Zeiteinheit in Anspruch nimmt und dieser Vorgang Zehntausende Male wiederholt wird, erhöht sich auch die letztendlich aufgewendete Zeit um das Zehntausendfache.

while und for sind zwei Schlüsselwörter, die häufig zum Implementieren von Schleifen in Python verwendet werden. Es gibt tatsächlich eine Lücke in ihrer Betriebseffizienz. Beispielsweise der folgende Testcode:

import timeit
def while_loop(n=100_000_000):
 ich = 0
 s = 0
 während ich <
 s += ich
 ich += 1
 Rückkehr s
def for_loop(n=100_000_000):
 s = 0
 für i im Bereich(n):
 s += ich
 Rückkehr s
def main():
 print('while looptt', timeit.timeit(while_loop, number=1))
 print('for looptt', timeit.timeit(for_loop, number=1))
if __name__ == '__main__':
 hauptsächlich()
# => while-Schleife 4.718853999860585
# => for-Schleife 3.211570399813354

Dies ist eine einfache Summenoperation, die die Summe aller natürlichen Zahlen von 1 bis n berechnet. Sie können sehen, dass die for-Schleife 1,5 Sekunden schneller ist als die while-Schleife.

Der Hauptunterschied liegt in den unterschiedlichen Mechanismen zwischen den beiden.

Während in jeder Schleife tatsächlich zwei Schritte mehr ausgeführt werden als für: Grenzen prüfen und Variable i inkrementieren. Das heißt, jedes Mal, wenn eine Schleife ausgeführt wird, führt while eine Grenzprüfung (while i < n) und eine Inkrementberechnung (i +=1) durch. Bei beiden Schritten handelt es sich um expliziten reinen Python-Code.

Die for-Schleife muss keine Grenzprüfungen und Inkrementierungsoperationen durchführen und fügt keinen expliziten Python-Code hinzu (reiner Python-Code ist weniger effizient als der zugrunde liegende C-Code). Wenn die Anzahl der Zyklen groß genug ist, entsteht eine erhebliche Effizienzlücke.

Sie können zwei weitere Funktionen hinzufügen, um unnötige Grenzprüfungen und Inkrementierungsberechnungen in der for-Schleife hinzuzufügen:

import timeit
def while_loop(n=100_000_000):
 ich = 0
 s = 0
 während ich <
 s += ich
 ich += 1
 Rückkehr s
def for_loop(n=100_000_000):
 s = 0
 für i im Bereich(n):
 s += ich
 Rückkehr s
def for_loop_with_inc(n=100_000_000):
 s = 0
 für i im Bereich(n):
 s += ich
 ich += 1
 Rückkehr s
def for_loop_with_test(n=100_000_000):
 s = 0
 für i im Bereich(n):
 wenn ich <
 passieren
 s += ich
 Rückkehr s
def main():
 print('while looptt', timeit.timeit(while_loop, number=1))
 print('for looptt', timeit.timeit(for_loop, number=1))
 print('for-Schleife mit Inkrementierung',
 timeit.timeit(for_loop_with_inc, number=1))
 print('for-Schleife mit testtt', timeit.timeit(for_loop_with_test, number=1))
if __name__ == '__main__':
 hauptsächlich()
# => while-Schleife 4.718853999860585
# => für Schleife 3.211570399813354
# => for-Schleife mit Inkrement 4.602369500091299
# => for-Schleife mit Test 4.18337869993411

Es ist ersichtlich, dass die hinzugefügte Grenzprüfung und die automatische Inkrementierungsoperation tatsächlich die Ausführungseffizienz der for-Schleife stark beeinflusst haben.

Wie bereits erwähnt, sind der zugrunde liegende Python-Interpreter und die integrierten Funktionen in der Sprache C implementiert. Die Ausführungseffizienz der C-Sprache ist viel höher als die von Python.

import timeit
def while_loop(n=100_000_000):
 ich = 0
 s = 0
 während ich <
 s += ich
 ich += 1
 Rückkehr s
def for_loop(n=100_000_000):
 s = 0
 für i im Bereich(n):
 s += ich
 Rückkehr s
def sum_range(n=100_000_000):
 Rückgabesumme(Bereich(n))
def main():
 print('while looptt', timeit.timeit(while_loop, number=1))
 print('for looptt', timeit.timeit(for_loop, number=1))
 print('sum rangett', timeit.timeit(sum_range, number=1))
if __name__ == '__main__':
 hauptsächlich()
# => while-Schleife 4.718853999860585
# => für Schleife 3.211570399813354
# => sum range0.8658821999561042

Es ist ersichtlich, dass sich die Ausführungseffizienz des Codes verdoppelt hat, nachdem die integrierte Funktion sum zum Ersetzen der Schleife verwendet wurde.

Die Akkumulationsoperation der integrierten Funktion sum ist eigentlich eine Schleife, wird jedoch in der Sprache C implementiert, während die Summenoperation in der for-Schleife von reinem Python ausgeführt wird Code s += wurde mir klar. C > Python.

Erweitern Sie Ihr Denken. Wir sind alle mit Geschichten über Gauss‘ geniale Berechnung der Summe der Zahlen 1 bis 100 aufgewachsen.Die Summe von 1…100 ist gleich (1 + 100) * 50. Diese Berechnungsmethode kann auch auf die obige Summationsoperation angewendet werden.

import timeit
def while_loop(n=100_000_000):
 ich = 0
 s = 0
 während ich <
 s += ich
 ich += 1
 Rückkehr s
def for_loop(n=100_000_000):
 s = 0
 für i im Bereich(n):
 s += ich
 Rückkehr s
def sum_range(n=100_000_000):
 Rückgabesumme(Bereich(n))
def math_sum(n=100_000_000):
 return (n * (n - 1)) // 2
def main():
 print('while looptt', timeit.timeit(while_loop, number=1))
 print('for looptt', timeit.timeit(for_loop, number=1))
 print('sum rangett', timeit.timeit(sum_range, number=1))
 print('math sumtt', timeit.timeit(math_sum, number=1))
if __name__ == '__main__':
 hauptsächlich()
# => while-Schleife 4.718853999860585
# => für Schleife 3.211570399813354
# => Summenbereich0,8658821999561042
# => math sum 2.400018274784088e-06

Die endgültige Ausführungszeit von math sum beträgt etwa 2,4e-6, was sich um das Millionenfache verkürzt. Der Grundgedanke dabei ist, dass ein Codeteil Hunderte Millionen Mal ausgeführt werden muss, da die Effizienz von Schleifen gering ist.

Machen Sie einfach keine Schleife und verwenden Sie mathematische Formeln, um Hunderte Millionen Schleifenoperationen in nur einem Schritt umzuwandeln. Die Effizienz wurde natürlich wie nie zuvor gesteigert.

Abschließendes Fazit (ein bisschen Riddler):

Der schnellste Weg, eine Schleife zu implementieren - - — ——Verwenden Sie einfach keine Schleifen

Verwenden Sie für Python so weit wie möglich integrierte Funktionen, um den reinen Python-Code in der Schleife zu minimieren.

Das obige ist der detaillierte Inhalt vonWelche Methode der Python-Schleifen am schnellsten ist, kann Ihr Verständnis untergraben!. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!