Combien de méthodes de boucle rapide connaissez-vous en Python ?

Bonjour à tous, je suis somenzz, aujourd'hui nous allons étudier la méthode de boucle la plus rapide en Python.

Diverses postures

Par exemple, il existe une tâche simple, qui consiste à accumuler de 1 à 100 millions. Nous pouvons y parvenir d'au moins 7 manières, répertoriées comme suit :

1 boucle while

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

2. pour la boucle

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

3, plage de somme

def sum_range(n=100_000_000):
return sum(range(n))

4, générateur de somme (générateur)

def sum_generator(n=100_000_000):
return sum(i for i in range(n))

5, compréhension de liste de somme (compréhension de liste)

def sum_list_comp(n=100_000_000):
return sum([i for i in range(n)])

6, somme numpy

import numpy
def sum_numpy(n=100_000_000):
return numpy.sum(numpy.arange(n, dtype=numpy.int64))

7, somme numpy python range

import numpy
def sum_numpy_python_range(n=100_000_000):
return numpy.sum(range(n))

Ci-dessus Les résultats obtenus par les 7 méthodes sont les mêmes, mais le temps consommé est différent. Vous pouvez deviner quelle méthode est la plus rapide, puis regarder les résultats d'exécution du code suivant :

import timeit

def main():
l_align = 25
print(f'{"1、while 循环":<{l_align}} {timeit.timeit(while_loop, number=1):.6f}')
print(f"{'2、for 循环':<{l_align}}{timeit.timeit(for_loop, number=1):.6f}")
print(f'{"3、sum range":<{l_align}} {timeit.timeit(sum_range, number=1):.6f}')
print(f'{"4、sum generator":<{l_align}} {timeit.timeit(sum_generator, number=1):.6f}')
print(f'{"5、sum list comprehension":<{l_align}} {timeit.timeit(sum_list_comp, number=1):.6f}')
print(f'{"6、sum numpy":<{l_align}} {timeit.timeit(sum_numpy, number=1):.6f}')
print(f'{"7、sum numpy python range":<{l_align}} {timeit.timeit(sum_numpy_python_range, number=1):.6f}')

if __name__ == '__main__':
main()

Les résultats d'exécution sont les suivants :

Un moyen plus rapide

for que while block

for et while font essentiellement la même chose, mais while est du pur code Python, tandis que pour les appels d'extensions C pour incrémenter et vérifier les limites des variables, nous connaissons CPython L'interpréteur est écrit en langage C, le code Python est plus lent que le code C, et la boucle for représente C, et la boucle while représente Python, donc for est plus rapide que while.

La somme intégrée de numpy est plus rapide que la somme de Python

numpy est principalement écrite en C. Pour la même fonction, numpy est nettement plus rapide De même, l'arrangement de numpy est nettement plus rapide que la plage de Python.

L'utilisation croisée sera plus lente

La somme de Numpy est utilisée en combinaison avec la plage de Python, et le résultat est le plus long, voir méthode 7. Il est préférable d'utiliser le package numpy pour terminer la tâche, comme la méthode 6.

Les générateurs sont plus rapides que les compréhensions de listes

Les générateurs sont paresseux et ne généreront pas 100 millions de nombres à la fois, tandis que les compréhensions de listes alloueront tous les nombres à la fois. Sans parler de l'utilisation élevée de la mémoire, ils ne sont pas encore efficaces. Ils sont moins utilisés. de cache, donc les performances sont légèrement moins bonnes.

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!