Welche Python-Schleifenmethode ist die schnellste?

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. Zum Beispiel der folgende Testcode:

import timeit


def while_loop(n=100_000_000):
i = 0
s = 0
while i < n:
s += i
i += 1
return s


def for_loop(n=100_000_000):
s = 0
for i in range(n):
s += i
return s


def main():
print('while looptt', timeit.timeit(while_loop, number=1))
print('for looptt', timeit.timeit(for_loop, number=1))


if __name__ == '__main__':
main()
# => while loop 4.718853999860585
# => for loop 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 while.

Der Hauptunterschied liegt in den unterschiedlichen Mechanismen zwischen den beiden.

In jeder Schleife führt while​ tatsächlich zwei Schritte mehr aus als for​: Grenzüberprüfung und Inkrementierung der Variablen i​. 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. < n​）和自增计算（i +=1​）。这两步操作都是显式的纯 Python 代码。

for​ Die 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 und unnötige Grenzprüfungen und automatische Inkrementierungsberechnungen in der for-Schleife hinzufügen:

import timeit


def while_loop(n=100_000_000):
i = 0
s = 0
while i < n:
s += i
i += 1
return s


def for_loop(n=100_000_000):
s = 0
for i in range(n):
s += i
return s


def for_loop_with_inc(n=100_000_000):
s = 0
for i in range(n):
s += i
i += 1
return s


def for_loop_with_test(n=100_000_000):
s = 0
for i in range(n):
if i < n:
pass
s += i
return s


def main():
print('while looptt', timeit.timeit(while_loop, number=1))
print('for looptt', timeit.timeit(for_loop, number=1))
print('for loop with incrementtt',
timeit.timeit(for_loop_with_inc, number=1))
print('for loop with testtt', timeit.timeit(for_loop_with_test, number=1))


if __name__ == '__main__':
main()
# => while loop 4.718853999860585
# => for loop 3.211570399813354
# => for loop with increment4.602369500091299
# => for loop with test 4.18337869993411

Es ist ersichtlich, dass die hinzugefügten Grenzprüfungen und automatischen -Inkrementberechnungen Die Additionsoperation hat großen Einfluss auf die Ausführungseffizienz der for-Schleife.

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.

Für die obige Operation zum Ermitteln der Summe arithmetischer Folgen kann mit Hilfe der in Python integrierten Summenfunktion eine Ausführungseffizienz erzielt werden, die viel größer ist als die von for oder while Schleife.

import timeit


def while_loop(n=100_000_000):
i = 0
s = 0
while i < n:
s += i
i += 1
return s


def for_loop(n=100_000_000):
s = 0
for i in range(n):
s += i
return s


def sum_range(n=100_000_000):
return sum(range(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__':
main()
# => while loop 4.718853999860585
# => for loop 3.211570399813354
# => sum range0.8658821999561042

Sie können sehen, dass sich die Ausführungseffizienz des Codes exponentiell erhöht 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 C-Sprache implementiert, während die Summenoperation in der for-Schleife durch reinen Python-Code s += i implementiert wird. C>Python.

Erweitern Sie Ihr Denken noch einmal. Wir sind alle mit Geschichten über Gauss‘ geniale Berechnung der Summen von 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):
i = 0
s = 0
while i < n:
s += i
i += 1
return s


def for_loop(n=100_000_000):
s = 0
for i in range(n):
s += i
return s


def sum_range(n=100_000_000):
return sum(range(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__':
main()
# => while loop 4.718853999860585
# => for loop 3.211570399813354
# => sum range0.8658821999561042
# => math sum 2.400018274784088e-06

Die endgültige Ausführungszeit der mathematischen Summe beträgt etwa 2,4e-6, was um das Millionenfache verkürzt wird. 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 einen Schritt umzuwandeln. Die Effizienz wurde natürlich wie nie zuvor gesteigert.

Abschließende Schlussfolgerung (ein bisschen rätselhaft):

Der schnellste Weg, eine Schleife zu implementieren - - - ist, keine Schleife zu machen

Für Python Dafür Verwenden Sie dazu so weit wie möglich integrierte Funktionen und reduzieren Sie reinen Python-Code in Schleifen auf ein Minimum.

Das obige ist der detaillierte Inhalt vonWelche Python-Schleifenmethode ist die schnellste?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!