Python benchmark : accélérer ses calculs

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 :

1. Boucle while : 0.6407999277
2. Boucle for : 0.6034000397
3. Boucle for préparée : 0,5895000458

Moyenne de 1.000.000 d'essais sur des boucles à 10 tours :

1. Boucle while : 0.000006115
2. Boucle for : 0.000006264
3. Boucle for préparée : 0,000005651

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 :

1. Appel dans une boucle : 1.341
2. Boucle dans la fonction : 1.164

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)

1. Dictionnaire : 2.356
2. Tableau : 2.309
3. Liste : 0.639

Dictionnaire :

for i in range(10000000):
  dict[1]

Tableau :

for i in range(10000000):
  array[1]

Liste :

for i in range(10000000):
  list[1]

1. Dictionnaire : 0.795
2. Tableau : 0.702
3. Liste : 0.802

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 :

1. From : 12.56
2. From limité : 2.99
3. Import : 0.99

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 :

1. Import multiple : 9.95
2. Import unique : 0.79

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 :

1. Division : 0.121
2. Multiplication : 0.047

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 :

1. Addition : 0.140
2. Incrémentation : 0.117

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 :

1. Point dans la boucle : 1.307
2. Point hors de la boucle : 1.157

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~~