Tous les résultats sont indiqués en secondes.
La fonction something() consiste généralement au choix d'un nombre flottant aléatoire :
from random import uniform def something(): return uniform(-100000,100000)
Bien que ne semblant avoir indépendemment que peu d'effets, l'application de l'ensemble de ces astuces dans un programme peut avoir un effet drastique sur son temps d'exécution.
Boucle while :
i = 0 while i < x: something() i += 1
Boucle for :
for i in range(x): something()
Boucle for préparée :
rng = range(x) for i in rng: something()
Moyenne de 10 essais sur des boucles à 1.000.000 de tours :
Moyenne de 1.000.000 d'essais sur des boucles à 10 tours :
La boucle for devant parcourir une liste d'éléments, l'initialisation de ladite liste lui prend du temps, problème que ne rencontre pas la boucle while. La boucle while est donc plus rapide lorsqu'il faut faire beaucoup de fois peu de tours.
Une fois lancée la boucle for se montre par contre bien plus véloce que sa voisine, qui s'encombre à chaque tour de boucle d'une opération sur le compteur. La boucle for est donc plus rapide lorsqu'il faut faire peu de fois beaucoup de tours.
La boule for “préparée”, en n'apellant plus la fonction range() à chaque tour, se montre la plus véloce dans toutes les situations.
Appel dans une boucle :
def doit(): something() rng = range(x) for i in rng: doit()
Boucle dans la fonction :
def doit(x): rng = range(x) for i in rng: something() doit(x)
1.000.000 de tours :
L'appel à une fonction prends du temps, il est donc bien plus rapide de mettre la boucle à l'intérieur de la fonction.
Dictionnaire :
for i in range(10000000): dict = {5:10,1:8,7:2}
Tableau :
for i in range(10000000): array = [10,8,2]
Liste :
for i in range(10000000): list = (10,8,2)
Dictionnaire :
for i in range(10000000): dict[1]
Tableau :
for i in range(10000000): array[1]
Liste :
for i in range(10000000): list[1]
From :
rng = range(x) for i in rng: from math import * something()
From limité :
rng = range(x) for i in rng: from math import pi something()
Import :
rng = range(x) for i in rng: import math something()
1.000.000 de tours :
En cas de besoin ou de volonté d'utiliser la syntaxe from, l'import d'éléments précis dans le module s'avère cinq à six fois plus véloce que l'import complet dudit module.
L'utilisation de la syntaxe import seule reste quand à elle de 12 à 13 fois plus efficiente.
Import multiple :
rng = range(x) for i in rng: import math something()
Import unique :
import math rng = range(x) for i in rng: something()
1.000.000 de tours :
Un import peut-être très long (cela dépend de la taille du module), il faut donc toujours éviter d'importer plusieurs fois la même chose, en faisant par exemple :
math = None rng = range(x) for i in rng: if math is None: import math something()
Division :
rng = range(x) for i in rng: 123456.789 / 4
Multiplication :
rng = range(x) for i in rng: 123456.789 * 0.25
Le résultat de ces calculs est le même.
Calcul effectué 1.000.000 de fois :
La multiplication est de deux à quatre fois plus rapide que la division.
Addition :
rng = range(x) for i in rng: i = i + 1
Incrémentation :
rng = range(x) for i in rng: i += 1
Calcul effectué 1.000.000 de fois :
L'incrémentation est légèrement plus rapide que l'addition.
Point dans la boucle :
arr = [] rng = range(x) for i in rng: arr.append(something())
Point hors de la boucle :
arr = [] append = arr.append rng = range(x) for i in rng: append(something())
Calcul effectué 1.000.000 de fois :
La référence à une méthode de classe (syntaxe du point), au lieu d'être recalculée à chaque tour de boucle, peut être une fois pour toutes stockée dans une variable, accélérant notablement les calculs.
En cours d'écriture.
A venir : benchmark code, parcourt et tri de tableaux/listes et dictionnaires, concaténation et vitesse des opérateurs mathématiques et de comparaison.
~~DISCUSSION~~