Quelle méthode de bouclage Python est la plus rapide ?

Comme nous le savons tous, Python n'est pas un langage efficace. De plus, le bouclage est une opération très chronophage dans n’importe quelle langue. Si une opération simple en une seule étape prend 1 unité de temps, si cette opération est répétée des dizaines de milliers de fois, le temps final passé augmentera également des dizaines de milliers de fois.

while et for sont deux mots-clés couramment utilisés pour implémenter des boucles en Python, mais il existe en réalité une lacune dans leur efficacité opérationnelle. Par exemple, le code de test suivant :​

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

Il s'agit d'une simple opération de somme qui calcule la somme de tous les nombres naturels de 1 à n. Vous pouvez voir que la boucle for est 1,5 seconde plus rapide que la boucle while.

La principale différence réside dans les mécanismes différents des deux.

Dans chaque boucle, while​ effectue en fait deux étapes de plus que for​ : vérification des limites et incrémentation de la variable i​. Autrement dit, chaque fois qu'une boucle est effectuée, while effectuera une vérification des limites (tandis que i < n​) et un calcul d'incrément (i +=1​). Les deux étapes sont du code Python pur et explicite. Les boucles < n​）和自增计算（i +=1​）。这两步操作都是显式的纯 Python 代码。

for​ n'ont pas besoin d'effectuer des vérifications de limites ni d'opérations d'incrémentation, et n'ajoutent pas de code Python explicite (le code Python pur est moins efficace que le code C sous-jacent). Lorsque le nombre de cycles est suffisamment important, un écart d’efficacité important apparaît.

Vous pouvez ajouter deux fonctions supplémentaires et ajouter des vérifications de limites et des calculs d'auto-incrémentation inutiles à la boucle for :

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

On peut voir que les vérifications de limites et les opérations d'auto-incrémentation ajoutées affectent grandement l'efficacité d'exécution de la boucle for. boucle .

Comme mentionné précédemment, l'interpréteur sous-jacent et les fonctions intégrées de Python sont implémentés en langage C. L'efficacité d'exécution du langage C est bien supérieure à celle de Python.

Pour l'opération ci-dessus consistant à trouver la somme d'une séquence arithmétique, à l'aide de la fonction somme intégrée de Python, vous pouvez obtenir une efficacité d'exécution bien supérieure à celle d'une boucle for ou while.

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

Vous pouvez voir qu'après avoir utilisé la fonction intégrée sum​ pour remplacer la boucle, l'efficacité d'exécution du code a augmenté de façon exponentielle.

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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!