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

Si vous voulez mesurer le temps CPU, vous pouvez utiliser time.process_time() pour Python 3.3 et plus :

import time
start = time.process_time()
# your code here    
print(time.process_time() - start)

Le premier appel met le minuteur en marche, et le second vous indique combien de secondes se sont écoulées.

Il existe également une fonction time.clock() mais c'est déprécié depuis Python 3.3 et sera supprimée dans Python 3.8.

Il existe de meilleurs outils de profilage comme timeit y profile Cependant, time.process_time() mesurera le temps CPU et c'est ce que vous demandez.

Si vous souhaitez plutôt mesurer l'heure de l'horloge murale, utilisez time.time() .

Answer 2

Vous pouvez également utiliser time bibliothèque :

import time

start = time.time()

# your code

# end

print(f'Time: {time.time() - start}')

Answer 3

Avec l'aide d'une petite classe de commodité, vous pouvez mesurer le temps passé dans les lignes en retrait comme ça :

with CodeTimer():
   line_to_measure()
   another_line()
   # etc...

Qui affichera ce qui suit après que la ou les lignes indentées aient fini de s'exécuter :

Code block took: x.xxx ms

UPDATE : Vous pouvez maintenant obtenir la classe avec pip install linetimer et ensuite from linetimer import CodeTimer . Voir ce projet GitHub .

Le code de la classe ci-dessus :

import timeit

class CodeTimer:
    def __init__(self, name=None):
        self.name = " '"  + name + "'" if name else ''

    def __enter__(self):
        self.start = timeit.default_timer()

    def __exit__(self, exc_type, exc_value, traceback):
        self.took = (timeit.default_timer() - self.start) * 1000.0
        print('Code block' + self.name + ' took: ' + str(self.took) + ' ms')

Vous pourriez alors nommer les blocs de code que vous voulez mesurer :

with CodeTimer('loop 1'):
   for i in range(100000):
      pass

with CodeTimer('loop 2'):
   for i in range(100000):
      pass

Code block 'loop 1' took: 4.991 ms
Code block 'loop 2' took: 3.666 ms

Et nid les :

with CodeTimer('Outer'):
   for i in range(100000):
      pass

   with CodeTimer('Inner'):
      for i in range(100000):
         pass

   for i in range(100000):
      pass

Code block 'Inner' took: 2.382 ms
Code block 'Outer' took: 10.466 ms

Concernant timeit.default_timer() il utilise le meilleur timer en fonction du système d'exploitation et de la version de Python, cf. cette réponse .

Answer 4

Mettre le code dans une fonction, puis utiliser un décorateur pour la synchronisation est une autre option. ( Source : ) L'avantage de cette méthode est que vous définissez le timer une seule fois et l'utilisez avec une simple ligne supplémentaire pour chaque fonction.

Tout d'abord, définissez timer décorateur :

import functools
import time

def timer(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start_time = time.perf_counter()
        value = func(*args, **kwargs)
        end_time = time.perf_counter()
        run_time = end_time - start_time
        print("Finished {} in {} secs".format(repr(func.__name__), round(run_time, 3)))
        return value

    return wrapper

Ensuite, utilisez le décorateur lors de la définition de la fonction :

@timer
def doubled_and_add(num):
    res = sum([i*2 for i in range(num)])
    print("Result : {}".format(res))

Essayons :

doubled_and_add(100000)
doubled_and_add(1000000)

Sortie :

Result : 9999900000
Finished 'doubled_and_add' in 0.0119 secs
Result : 999999000000
Finished 'doubled_and_add' in 0.0897 secs

Note : Je ne suis pas sûr de savoir pourquoi utiliser time.perf_counter au lieu de time.time . Les commentaires sont les bienvenus.

Answer 5

Je préfère toujours vérifier l'heure au format heures, minutes et secondes (%H:%M:%S) :

from datetime import datetime
start = datetime.now()
# your code
end = datetime.now()
time_taken = end - start
print('Time: ',time_taken) 

sortie :

Time:  0:00:00.000019