Python timeit

1. Avantages de timeit :
2. Utiliser le module timeit pour comparer le temps d’exécution de deux extraits de code
3. Utiliser l’interface de ligne de commande du module timeit

Le module timeit est l’un des modules les plus simples et les plus faciles à mettre en œuvre parmi toutes les catégories d’outils qui profilent l’exécution du code Python. Le tutoriel traite de l’utilisation et de l’implémentation du module timeit en Python.

Python contient une bibliothèque intégrée timeit qui peut calculer le temps d’exécution de minuscules extraits de code Python. Le module fonctionne en exécutant le code python donné des millions de fois et prédit le moins de temps écoulé lors de l’exécution de ce code à partir de tous les résultats possibles.

Avantages de timeit :

• Fournit un résultat efficace avec précision. La précision du temps d’exécution rendu par cette fonction est tout simplement plus élevée qu’en utilisant le module time simple.
• Il exécute l’extrait de code donné plus d’un million de fois, ce qui offre des lectures beaucoup plus pertinentes du temps écoulé pendant son exécution.
• Il a en outre une interface de ligne de commande supplémentaire en plus de l’interface appelable générique, qui est facile à comprendre et à appliquer.

Passons à autre chose, décrivons et concentrons-nous sur la syntaxe de la fonction timeit() du module timeit.

timeit.timeit(stmt, setup, timer, number)

La fonction timeit.timeit() prend quatre paramètres, qui ont tous été brièvement expliqués pour faciliter la compréhension de la fonction ci-dessous :

• stmt : Comme son nom l’indique, c’est l’énoncé qu’il faut mesurer. La valeur par défaut est pass dans ce cas.
• setup : Signifie le code qui doit s’exécuter avant que le stmt ne soit abordé. Encore une fois, il a un défaut comme pass.
• timer : un objet de base timeit.Timer. Il a déjà une valeur par défaut décente qui lui est assignée, qui n’a généralement pas besoin d’être modifiée.
• number : indique le nombre d’exécutions de l’extrait de code donné que le programmeur souhaite exécuter.

Nous verrons différents exemples d’implémentation de la fonction timeit.timeit() du module timeit.

Utiliser le module timeit pour calculer le temps d’exécution d’un extrait de code simple

Cette méthode définit un extrait de code dans une variable entre guillemets triples (''').

Le code suivant utilise le module timeit pour calculer le temps d’exécution d’un extrait de code simple.

import timeit

setup1 = "from math import sqrt"
code1 = """
def a():
    list1 = []
    for i in range(50):
        list1.append(sqrt(i))
"""
print(timeit.timeit(setup=setup1, stmt=code1, number=10000))

Le programme ci-dessus fournit la sortie sous forme de temps d’exécution pris en secondes. Ce temps d’exécution résulte d’un million d’itérations de l’extrait de code donné.

Nous devons également noter qu’il est bon d’impliquer toutes les instructions d’importation essentielles dans l’argument de configuration.

Utiliser le module timeit pour comparer le temps d’exécution de deux extraits de code

Le module timeit peut également être utilisé pour comparer le temps d’exécution de deux extraits de code donnés. Ici, nous allons prendre deux fonctions utilisées respectivement pour la Recherche binaire et la Recherche linéaire et comparer leurs temps d’exécution.

Le code suivant utilise le module timeit pour comparer le temps d’exécution de deux extraits.

import timeit

# function for binary search


def b_s(mylist, find):
    while len(mylist) > 0:
        mid = (len(mylist)) // 2
        if mylist[mid] == find:
            return True
        elif mylist[mid] < find:
            mylist = mylist[:mid]
        else:
            mylist = mylist[mid + 1 :]
    return False


# function for linear search
def l_s(mylist, find):
    for x in mylist:
        if x == find:
            return True
    return False


def b_time():
    SETUP_CODE = """
from __main__ import b_s
from random import randint"""
    TEST_CODE = """
mylist = [x for x in range(10000)]
find = randint(0, len(mylist))
b_s(mylist, find)"""
    times = timeit.repeat(setup=SETUP_CODE, stmt=TEST_CODE, repeat=3, number=10000)
    print("Binary search time: {}".format(min(times)))


def l_time():
    SETUP_CODE = """
from __main__ import l_s
from random import randint"""
    TEST_CODE = """
mylist = [x for x in range(10000)]
find = randint(0, len(mylist))
l_s(mylist, find)
    """
    times = timeit.repeat(setup=SETUP_CODE, stmt=TEST_CODE, repeat=3, number=10000)
    print("Linear search time: {}".format(min(times)))


if __name__ == "__main__":
    l_time()
    b_time()

Utiliser l’interface de ligne de commande du module timeit

Prenons un code de fonction simple et sa syntaxe dans l’interface de ligne de commande et abordons tous les arguments un par un.

Le code suivant utilise l’interface de ligne de commande du module timeit.

C:\Windows\System32>python3 -m timeit -s "from math import sqrt" -n 10000 -r 5 'a = sqrt(34532)'

Ici, nous avons pris la même fonction que le premier exemple de l’article.

Passons à autre chose, considérons tous les arguments utilisés ici dans l’interface de ligne de commande.

• timeit : Un argument positionnel simple qui précise l’existence et l’utilisation du module timeit.
• -s : L’argument de configuration.
• -n : L’argument numérique.
• -r : L’argument répété (optionnel).
• 'code snippet' : l’extrait de code est écrit directement entre guillemets simples dans l’interface de ligne de commande.