Utiliser Python Timeit pour chronométrer votre code

Dans ce didacticiel, vous apprendrez à utiliser la fonction timeit du module timeit de Python. Vous apprendrez à chronométrer des expressions et des fonctions simples en Python.

La synchronisation de votre code peut vous aider à obtenir une estimation du temps d'exécution d'un morceau de code et également à identifier les sections du code qui doivent être optimisées.

Nous allons commencer par apprendre la syntaxe de Python timeit une fonction. Et puis nous coderons des exemples pour comprendre comment l'utiliser pour chronométrer des blocs de code et des fonctions dans votre module Python. Commençons.

How to Use the Python timeit Function

Les timeit module fait partie de la bibliothèque standard Python, et vous pouvez l'importer :

import timeit

La syntaxe à utiliser timeit fonction du timeit module est comme indiqué ci-dessous:

timeit.timeit(stmt, setup, number)

Ici:

• stmt est le morceau de code dont on veut mesurer le temps d'exécution. Vous pouvez le spécifier sous la forme d'une simple chaîne Python ou d'une chaîne multiligne, ou transmettre le nom de l'appelable.
• Comme son nom l'indique, setup désigne le morceau de code qui ne doit être exécuté qu'une seule fois, souvent comme condition préalable à la stmt courir. Par exemple, supposons que vous calculiez le temps d'exécution pour la création d'un tableau NumPy. Dans ce cas, l'importation numpy est setup code et la création réelle est la déclaration à chronométrer.
• Le paramètre number désigne le nombre de fois que stmt est exécuté. La valeur par défaut de number est de 1 million (1000000), mais vous pouvez également définir ce paramètre sur toute autre valeur de votre choix.

Maintenant que nous avons appris la syntaxe pour utiliser le timeit() fonction, commençons à coder quelques exemples.

Timing Simple Python Expressions

Dans cette section, nous allons essayer de mesurer le temps d'exécution d'expressions Python simples à l'aide de timeit.

Démarrez un REPL Python et exécutez les exemples de code suivants. Ici, nous calculons le temps d'exécution de l'exponentiation et division de l'étage opérations pour 10000 et 100000 passages.

Remarquez que nous passer dans la déclaration à chronométrer comme une chaîne Python et utilisez un point-virgule pour séparer les différentes expressions dans l'instruction.

>>> import timeit
>>> timeit.timeit('3**4;3//4',number=10000)
0.0004020999999738706

>>> timeit.timeit('3**4;3//4',number=100000)
0.0013780000000451764

Exécution de Python timeit en ligne de commande

Vous pouvez également utiliser timeit à la ligne de commande. Voici l'équivalent en ligne de commande de l'appel de la fonction timeit :

$ python-m timeit -n [number] -s [setup] [stmt]

• python -m timeit représente que nous courons timeit comme module principal.
• n est une option de ligne de commande qui indique le nombre de fois que le code doit s'exécuter. Cela équivaut à la number argument dans le timeit() appel de fonction.
• Vous pouvez utiliser l'option -s pour définir le code de configuration.

Ici, nous réécrivons l'exemple précédent en utilisant l'équivalent en ligne de commande :

$ python -m timeit -n 100000 '3**4;3//4'
100000 loops, best of 5: 35.8 nsec per loop

Dans cet exemple, nous calculons le temps d'exécution de la fonction intégrée len() une fonction. L'initialisation de la chaîne est le code de configuration transmis à l'aide de la s option.

$ python -m timeit -n 100000 -s "string_1 = 'coding'" 'len(string_1)'
100000 loops, best of 5: 239 nsec per loop

Dans la sortie, notez que nous obtenons le temps d'exécution pour meilleur de 5 court. Qu'est-ce que ça veut dire? Quand tu cours timeit en ligne de commande, le repeat option r est réglé sur la défaut valeur de 5. Cela signifie que l'exécution de la stmt pour le spécifié number of times est répété cinq fois, et le meilleur des temps d'exécution est renvoyé.

Analysis of String Reversal Methods Using timeit

Lorsque vous travaillez avec Chaînes Python, vous voudrez peut-être les inverser. Les deux approches les plus courantes de l'inversion de chaîne sont les suivantes :

• Utilisation du découpage de chaîne
• Le reversed() fonction et le join() méthode

Inverser les chaînes Python à l'aide du découpage de chaînes

Voyons comment fonctionne le découpage de chaîne et comment vous pouvez l'utiliser pour inverser une chaîne Python. Utilisation de la syntaxe some-string[start:stop] renvoie une tranche de la chaîne commençant à l'index start et s'étendant jusqu'à l'indice stop-1. Prenons un exemple.

Considérez la chaîne suivante 'Python'. La chaîne est de longueur 6 et la liste des indices est de 0, 1, 2 jusqu'à 5.

>>> string_1 = 'Python'

Lorsque vous spécifiez à la fois le start les nouveautés stop valeurs, vous obtenez une tranche de chaîne qui s'étend de start à stop-1. Par conséquent, string_1[1:4] renvoie 'yth'.

>>> string_1 = 'Python'
>>> string_1[1:4]
'yth'

Lorsque vous ne spécifiez pas le start valeur, la valeur par défaut start la valeur zéro est utilisée, et la tranche commence à l'index zéro et s'étend jusqu'à stop - 1.

Ici le stop valeur est 3, donc la tranche commence à l'index 0 et monte jusqu'à l'index 2.

>>> string_1[:3]
'Pyt'

Lorsque vous n'incluez pas le stop index, vous voyez que la tranche commence à partir de l'index start index (1) et s'étend jusqu'à la fin de la chaîne.

>>> string_1[1:]
'ython'

Ignorant à la fois les start les nouveautés stop valeurs renvoie une tranche de la chaîne entière.

>>> string_1[::]
'Python'

Créons une tranche avec le step évaluer. Met le start, stopet au step valeurs à 1, 5 et 2, respectivement. Nous obtenons une tranche de la chaîne commençant à 1 s'étendant jusqu'à 4 (à l'exclusion du point final 5) contenant chaque deuxième caractère.

>>> string_1[1:5:2]
'yh'

Lorsque vous utilisez une étape négative, vous pouvez obtenir une tranche commençant à la fin de la chaîne. Avec le pas réglé sur -2, string_1[5:2:-2] donne la tranche suivante :

>>> string_1[5:2:-2]
'nh'

Donc, pour obtenir une copie inversée de la chaîne, nous sautons le start , stop valeurs et définissez le pas sur -1, comme indiqué :

>>> string_1[::-1]
'nohtyP'

En résumé: string[::-1] renvoie une copie inversée de la chaîne.

Inversion de chaînes à l'aide de fonctions intégrées et de méthodes de chaîne

Le intégré reversed() La fonction en Python renverra un itérateur inverse sur les éléments de la chaîne.

>>> string_1 = 'Python'
>>> reversed(string_1)
<reversed object at 0x00BEAF70>

Ainsi, vous pouvez parcourir l'itérateur inverse à l'aide d'un pour la boucle:

for char in reversed(string_1):
    print(char)

Et accédez aux éléments de la chaîne dans l'ordre inverse.

# Output
n
o
h
t
y
P

Ensuite, vous pouvez alors appeler le join() méthode sur l'itérateur inverse avec la syntaxe : <sep>.join(reversed(some-string)).

L'extrait de code ci-dessous montre quelques exemples où le séparateur est un tiret et un espace, respectivement.

>>> '-'.join(reversed(string1))
'n-o-h-t-y-P'
>>> ' '.join(reversed(string1))
'n o h t y P'

Ici, nous ne voulons aucun séparateur ; définissez donc le séparateur sur une chaîne vide pour obtenir une copie inversée de la chaîne :

>>> ''.join(reversed(string1))
'nohtyP'

En utilisant ''.join(reversed(some-string)) renvoie une copie inversée de la chaîne.

Comparaison des temps d'exécution à l'aide de timeit

Jusqu'à présent, nous avons appris deux approches pour inverser les chaînes Python. Mais lequel d'entre eux est le plus rapide ? Découvrons-le.

Dans un exemple précédent où nous avons chronométré des expressions Python simples, nous n'avions pas setup code. Ici, nous inversons la chaîne Python. Pendant que l'opération d'inversion de chaîne s'exécute le nombre de fois spécifié par number, setup code est l'initialisation de la chaîne qui ne s'exécutera qu'une seule fois.

>>> import timeit
>>> timeit.timeit(stmt = 'string_1[::-1]', setup = "string_1 = 'Python'", number = 100000)
0.04951830000001678
>>> timeit.timeit(stmt = "''.join(reversed(string_1))", setup = "string_1 = 'Python'", number = 100000)
0.12858760000000302

Pour le même nombre d'exécutions pour inverser la chaîne donnée, le tranchage de ficelle approche est plus rapide que d'utiliser la join() méthode et reversed() la fonction.

Vous pouvez également lire comment inverser une liste en Python pour la faire tourner à l'envers.

Timing Python Functions Using timeit

Dans cette section, apprenons à chronométrer les fonctions Python avec la fonction timeit. Étant donné une liste de chaînes, la fonction suivante hasDigit renvoie la liste des chaînes qui ont au moins un chiffre.

def hasDigit(somelist):
     str_with_digit = []
     for string in somelist:
         check_char = [char.isdigit() for char in string]
         if any(check_char):
            str_with_digit.append(string)
     return str_with_digit

Maintenant, nous aimerions mesurer le temps d'exécution de cette fonction Python hasDigit() en utilisant timeit.

Identifions d'abord l'instruction à chronométrer (stmt). C'est l'appel à la fonction hasDigit() avec une liste de chaînes comme argument. Ensuite, définissons le installation code. Pouvez-vous deviner ce que setup code devrait être?

Pour que l'appel de fonction s'exécute correctement, le code d'installation doit inclure les éléments suivants :

• La définition de la fonction hasDigit()
• L'initialisation de la liste d'arguments des chaînes

Définissons le code de configuration dans le setup chaîne, comme indiqué ci-dessous :

setup = """
def hasDigit(somelist):
    str_with_digit = []
    for string in somelist:
      check_char = [char.isdigit() for char in string]
      if any(check_char):
        str_with_digit.append(string)
    return str_with_digit
thislist=['puffin3','7frost','blue']
     """

Ensuite, nous pouvons utiliser le timeit fonction et obtenir le temps d'exécution de la hasDigit() fonction pour 100000 XNUMX exécutions.

import timeit
timeit.timeit('hasDigit(thislist)',setup=setup,number=100000)

# Output
0.2810094920000097

Conclusion

Vous avez appris à utiliser La fonction timeit de Python aux expressions temporelles, fonctions et autres callables. Cela peut vous aider à comparer votre code, à comparer les temps d'exécution de différentes implémentations de la même fonction, etc.

Passons en revue ce que nous avons appris dans ce tutoriel. Vous pouvez utiliser le timeit() fonction avec la syntaxe timeit.timeit(stmt=...,setup=...,number=...). Alternativement, vous pouvez exécuter timeit sur la ligne de commande pour chronométrer les extraits de code court.

Dans une prochaine étape, vous pourrez explorer comment utiliser d'autres packages de profilage Python tels que line-profiler et memprofiler pour profiler votre code en fonction du temps et de la mémoire, respectivement.

Ensuite, apprenez à calculer le décalage horaire en Python.