Python benchmark : accélérer ses calculs

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.

Boucles

While et for

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()

Bench

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

Conclusion

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 de fonction

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)

Bench

1.000.000 de tours :

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

Conclusion

L'appel à une fonction prends du temps, il est donc bien plus rapide de mettre la boucle à l'intérieur de la fonction.

Dictionnaires, tableaux et listes

Initialisation

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

Récupération d'une valeur

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

Imports

From et import

From :

rng = range(x)
for i in rng:
    from math import *
    something()

Cette syntaxe (import *) n'est correcte qu'au premier niveau du programme. J'ai ici passé outre les alertes afin d'en calculer la vitesse.

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()

Bench

1.000.000 de tours :

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

Conclusion

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.

Réimporter

Import multiple :

rng = range(x)
for i in rng:
    import math
    something()

Import unique :

import math
rng = range(x)
for i in rng:
    something()

Bench

1.000.000 de tours :

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

Conclusion

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()

Opérateurs

Division et multiplication

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.

Bench

Calcul effectué 1.000.000 de fois :

  1. Division : 0.121
  2. Multiplication : 0.047

Conclusion

La multiplication est de deux à quatre fois plus rapide que la division.

Incrémentation et addition

Addition :

rng = range(x)
for i in rng:
    i = i + 1

Incrémentation :

rng = range(x)
for i in rng:
    i += 1

Bench

Calcul effectué 1.000.000 de fois :

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

Conclusion

L'incrémentation est légèrement plus rapide que l'addition.

Classes

Accès aux méthodes

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())

Bench

Calcul effectué 1.000.000 de fois :

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

Conclusion

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.

WIP

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

Entrer votre commentaire. La syntaxe wiki est autorisée: