timetime 1.0

TimeTime est une classe qui permet d'afficher le temps d'exécution de fonctions, également de les comparer entre eux

TimeTime

Résumé

TimeTime est une classe qui permet d’afficher le temps d’exécution de fonctions, également de les comparer entre eux. TimTime retourne le temps d’exécution total pour <loops> boucles (par défaut 10000) et le temps moyen par boucle.

TimeTime est simple à utiliser. Il est basé sur les modules built-in time et re.

Usage

Les fonctions à comparer doivent être sans arguments. Il est fortement recommandé, pour la lisibilité des résultats de l'analyse, qu'elle ne comporte pas d'impressions écran de résultats de la fonction elle-même (si ça doit être le cas, voyez une alternative pour éviter un "print" dans l'exemple).

from timetime import TimeTime

def fonction1():
	...

def fonction2():
	...

f1 = TimeTime(fonction1)
f2 = TimeTime(fonction2)

print(f1)
print(f2)
print(f1 == f2)
etc.

TimeTime.loops = 1000
TimeTime.version()
TimeTime.demo()
etc.

Exemple

cet exemple vous montre également comment contourner le cas où vos fonctions de test doivent envoyer des impressions. On les renvoie dans un fichier /dev/null (nul - je crois, sous windows)

import os
from timetime import TimeTime as tt

def fonc1():
    with open(os.devnull, 'w') as f:
         f.write('b'+'c')

a = 'b'+'c'
def fonc2():
    with open(os.devnull, 'w') as f:
        f.write(a)

f1 = tt(fonc1)
f2 = tt(fonc2)
# quelle est la fonction la plus rapide ?
for i in range(3):
    print("--- phase", i, "---")
    print(f1 == f2)

Commentaires à propos de l'exemple

Les résultats:

--- phase 0 ---

fonc1() == fonc2()
------------------------------------------
fonc1(), 10000 loops.
Total runtime = 0.2219841480255127
Mean loop = 2.219841480255127e-05
------------------------------------------
------------------------------------------
fonc2(), 10000 loops.
Total runtime = 0.21685266494750977
Mean loop = 2.1685266494750976e-05
------------------------------------------
--- phase 1 ---

fonc1() == fonc2()
------------------------------------------
fonc1(), 10000 loops.
Total runtime = 0.21837949752807617
Mean loop = 2.1837949752807617e-05
------------------------------------------
------------------------------------------
fonc2(), 10000 loops.
Total runtime = 0.216231107711792
Mean loop = 2.16231107711792e-05
------------------------------------------
--- phase 2 ---

fonc1() == fonc2()
------------------------------------------
fonc1(), 10000 loops.
Total runtime = 0.21810102462768555
Mean loop = 2.1810102462768555e-05
------------------------------------------
------------------------------------------
fonc2(), 10000 loops.
Total runtime = 0.21857643127441406
Mean loop = 2.1857643127441406e-05
------------------------------------------

que constate-ton ?

Que l'avantage de concatener préalablement une seule fois n'est pas du tout évident sur le fait de concaténer l'équivalent de la chainea à chaque tour de boucle.

Ces comparaisons entre diverses implémentations ou diverses fonctions ne sont pas toujours aussi proches; voyez timetime_demo.py