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.211570399813354Il 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.18337869993411On 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.8658821999561042Vous 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.
L'opération d'accumulation de la fonction intégrée sum est en fait une boucle, mais elle est implémentée en langage C, tandis que l'opération de somme dans la boucle for est implémentée par du code Python pur s += i. C > Python. Élargissez à nouveau votre réflexion. Nous avons tous grandi en entendant des histoires sur l'ingénieux calcul de Gauss sur la somme des nombres de 1 à 100. La somme de 1…100 est égale à (1 + 100) * 50. Cette méthode de calcul peut également être appliquée à l'opération de sommation ci-dessus.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-06Ce 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!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
