Comment mesurer le temps pris entre les lignes de code en python ?

Question

Donc, en Java, on peut faire Comment mesurer le temps d'exécution d'une fonction ?

Mais comment le faire en python ? Pour mesurer l'heure de début et de fin entre les lignes de codes ? Quelque chose qui fait ça :

import some_time_library

starttime = some_time_library.some_module()
code_tobe_measured() 
endtime = some_time_library.some_module()

time_taken = endtime - starttime

Answer 1

Je cherchais un moyen de produire une heure formatée avec un minimum de code, voici donc ma solution. Beaucoup de gens utilisent Pandas de toute façon, donc dans certains cas, cela peut éviter d'importer des bibliothèques supplémentaires.

import pandas as pd
start = pd.Timestamp.now()
# code
print(pd.Timestamp.now()-start)

Sortie :

0 days 00:05:32.541600

Je recommande d'utiliser cette fonction si la précision du temps n'est pas la plus importante. time bibliothèque :

%timeit pd.Timestamp.now() sorties 3,29 µs ± 214 ns par boucle

%timeit time.time() sorties 154 ns ± 13.3 ns par boucle

Answer 2

Vous pouvez également essayer ceci :

from time import perf_counter

t0 = perf_counter()

...

t1 = perf_counter()
time_taken = t1 - t0

Answer 3

Utilisation du module time nous pouvons calculer le temps unix au début et à la fin d'une fonction. Voici à quoi pourrait ressembler le code :

from time import time as unix

Ce code importe time.time qui nous permet de calculer le temps unix.

from time import sleep

Ce n'est pas obligatoire, mais j'importe également time.sleep pour l'une des démonstrations.

START_TIME = unix()

C'est ce qui calcule le temps unix et le met dans une variable. Rappelez-vous, la fonction unix n'est pas une fonction réelle. J'ai importé time.time comme unix, donc si vous n'avez pas mis as unix lors de la première importation, vous devrez utiliser la fonction time.time() .

Après cela, nous mettons n'importe quelle fonction ou code que nous voulons. À la fin de l'extrait de code, on met

TOTAL_TIME = unix()-START_TIME

Cette ligne de code fait deux choses : Elle calcule le temps unix à la fin de la fonction, et en utilisant la variable START_TIME Comme précédemment, nous calculons le temps qu'il a fallu pour exécuter l'extrait de code.

Nous pouvons ensuite utiliser cette variable où bon nous semble, y compris pour une print() fonction.

print("The snippet took {} seconds to execute".format(TOTAL_TIME))

Ici j'ai écrit un code de démonstration rapide qui a deux expériences comme une démonstration. (Entièrement commenté)

from time import time as unix # Import the module to measure unix time
from time import sleep

# Here are a few examples:
# 1. Counting to 100 000
START_TIME = unix()
for i in range(0, 100001):
  print("Number: {}\r".format(i), end="")
TOTAL_TIME = unix() - START_TIME
print("\nFinal time (Expirement 1): {} s\n".format(TOTAL_TIME))

# 2. Precision of sleep
for i in range(10):
  START_TIME = unix()
  sleep(0.1)
  TOTAL_TIME = unix() - START_TIME
  print("Sleep(0.1): Index: {}, Time: {} s".format(i,TOTAL_TIME))

Voici mon résultat :

Number: 100000
Final time (Expirement 1): 16.666812419891357 s

Sleep(0.1): Index: 0, Time: 0.10014867782592773 s
Sleep(0.1): Index: 1, Time: 0.10016226768493652 s
Sleep(0.1): Index: 2, Time: 0.10202860832214355 s
Sleep(0.1): Index: 3, Time: 0.10015869140625 s
Sleep(0.1): Index: 4, Time: 0.10014724731445312 s
Sleep(0.1): Index: 5, Time: 0.10013675689697266 s
Sleep(0.1): Index: 6, Time: 0.10014677047729492 s
Sleep(0.1): Index: 7, Time: 0.1001439094543457 s
Sleep(0.1): Index: 8, Time: 0.10044598579406738 s
Sleep(0.1): Index: 9, Time: 0.10014700889587402 s
>

Answer 4

Utilisez timeit pour évaluer vos performances :

def test():
    print("test")
    emptyFunction()
    for i in [x for x in range(10000)]:
        i**i

def emptyFunction():
    pass

if __name__ == "__main__":
    import timeit
    print(timeit.timeit("test()", number = 5, globals = globals()))
    #print(timeit.timeit("test()", setup = "from __main__ import test",
    #    number = 5))

le premier paramètre définit le morceau de code que nous voulons exécuter test dans ce cas & number définit combien de fois vous voulez répéter la exécution .

Sortie :

test
test
test
test
test
36.81822113099952

Answer 5

Permettez-moi d'ajouter un peu plus à https://stackoverflow.com/a/63665115/7412781 solution.

• Suppression de la dépendance à l'égard de functools .
• Durée du processus utilisé time.process_time() au lieu du compteur absolu de time.perf_counter() car le processus peut être sorti du contexte via le noyau.
• J'ai également utilisé l'impression du pointeur de fonction brut pour obtenir le nom de classe correct.

C'est le code du décorateur.

import time

def decorator_time_taken(fnc):
    def inner(*args):
        start = time.process_time()
        ret = fnc(*args)
        end = time.process_time()
        print("{} took {} seconds".format(fnc, round((end - start), 6)))
        return ret
    return inner

Voici l'exemple de code d'utilisation. Il vérifie si 193939 est premier ou non.

class PrimeBrute:
    @decorator_time_taken
    def isPrime(self, a):
        for i in range(a-2):
           if a % (i+2) == 0: return False
        return True

inst = PrimeBrute()
print(inst.isPrime(193939))

Voici le résultat.

<function PrimeBrute.isPrime at 0x7fc0c6919ae8> took 0.015789 seconds
True