En Python, vous pouvez facilement mesurer le temps d’exécution avec le module timeit de la bibliothèque standard.
Cet article décrit deux cas :
- Mesurez le temps d’exécution dans le script Python :
timeit.timeit(), timeit.repeat() - Mesurez le temps d’exécution dans Jupyter Notebook :
%timeit, %%timeit
Mesurez le temps d’exécution dans le script Python :timeit.timeit(), timeit.repeat()
Définissez un test de fonction simple (n) qui calcule la somme de n nombres consécutifs à titre d’exemple et mesurez son temps d’exécution.
import timeit
def test(n):
return sum(range(n))
n = 10000
loop = 1000
result = timeit.timeit('test(n)', globals=globals(), number=loop)
print(result / loop)
# 0.0002666301020071842
En transmettant le code que vous souhaitez mesurer sous forme de chaîne à timeit.timeit(), votre code est exécuté plusieurs fois et son heure d’exécution est renvoyée.
La valeur par défaut du nombre est 1 000 000. Notez que si vous exécutez un code chronophage avec la valeur par défaut, cela prendra beaucoup de temps.
Le code s’exécute dans l’espace de noms global en passant globals() à globals. Sans elle, la fonction test et la variable n ne seraient pas reconnues dans l’exemple ci-dessus.
Le code peut être un objet appelable au lieu d’une chaîne, vous pouvez donc également le spécifier avec une expression lambda sans arguments. Dans ce cas, il n’est pas nécessaire de spécifier l’argument globals.
result = timeit.timeit(lambda: test(n), number=loop)
print(result / loop)
# 0.00027574066299712287
timeit.timeit() renvoie simplement le temps (en secondes) qu’il a fallu pour exécuter le code le nombre de fois.
Dans l’exemple ci-dessus, le temps par exécution est mesuré en divisant par le nombre d’exécutions (nombre). Si vous ne divisez pas, la valeur du résultat augmente simplement à mesure que le nombre d’exécutions augmente.
print(timeit.timeit(lambda: test(n), number=1))
print(timeit.timeit(lambda: test(n), number=10))
print(timeit.timeit(lambda: test(n), number=100))
# 0.0003999490290880203
# 0.0038685189792886376
# 0.03517670702422038
timeit.repeat() peut être utilisé pour répéter timeit(). Le résultat est renvoyé sous forme de liste.
repeat = 5
print(timeit.repeat(lambda: test(n), repeat=repeat, number=100))
# [0.044914519996382296, 0.039663890027441084, 0.02868645201670006, 0.022745631984435022, 0.023260265996214002]
Mesurez le temps d’exécution dans Jupyter Notebook :%timeit, %%timeit
Dans Jupyter Notebook (IPython), vous pouvez utiliser les commandes magiques %timeit et %%timeit pour mesurer le temps d’exécution de votre code. Il n’est pas nécessaire d’importer le module timeit.
% fois
Pour %timeit, spécifiez le code cible après %timeit avec un espace.
Par défaut, le nombre et la répétition dans timeit.timeit() sont définis automatiquement. Il peut également être spécifié avec les options -n et -r.
La moyenne et l’écart type sont calculés.
%timeit test(n)
# 259 µs ± 4.87 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
%timeit -r 3 -n 10000 test(n)
# 237 µs ± 6.44 µs per loop (mean ± std. dev. of 3 runs, 10000 loops each)
%% fois
Vous pouvez utiliser la commande magique %%timeit pour mesurer le temps d’exécution de la cellule.
Par exemple, essayez d’exécuter le même processus en utilisant NumPy. Comme pour %timeit, -n et -r sont facultatifs.
Notez que %%timeit mesure le temps d’exécution de la cellule entière, donc l’exemple suivant inclut le temps d’importation de NumPy.
%%timeit -r 3 -n 10000
import numpy as np
a = np.arange(n)
np.sum(a)
# 19.7 µs ± 9.57 µs per loop (mean ± std. dev. of 3 runs, 10000 loops each)
%%timeit est le moyen le plus simple de mesurer le temps d’exécution car vous écrivez simplement %%timeit au début de la cellule.
Voir le lien suivant pour un exemple Jupyter Notebook (.ipynb).