Comment puis-je obtenir l'heure d'exécution d'un programme Python?
J'ai un programme en ligne de commande en Python qui prend un certain temps à terminer. Je veux savoir le temps exact qu'il faut pour finir de courir.
J'ai consulté le module timeit, mais il semble que ce ne soit que pour de petits extraits de code. Je veux chronométrer tout le programme.
La manière la plus simple en Python:
import time
start_time = time.time()
main()
print("--- %s seconds ---" % (time.time() - start_time))
Cela suppose que votre programme prend au moins un dixième de seconde pour s'exécuter.
Impressions:
--- 0.764891862869 seconds ---
Je mets ce module timing.py dans mon propre répertoire site-packages et insère simplement import timing en haut de mon module:
import atexit
from time import clock
def secondsToStr(t):
return "%d:%02d:%02d.%03d" % \
reduce(lambda ll,b : divmod(ll[0],b) + ll[1:],
[(t*1000,),1000,60,60])
line = "="*40
def log(s, elapsed=None):
print line
print secondsToStr(clock()), '-', s
if elapsed:
print "Elapsed time:", elapsed
print line
print
def endlog():
end = clock()
elapsed = end-start
log("End Program", secondsToStr(elapsed))
def now():
return secondsToStr(clock())
start = clock()
atexit.register(endlog)
log("Start Program")
Je peux aussi appeler timing.log à partir de mon programme s'il y a des étapes importantes dans le programme que je veux montrer. Cependant, le fait d'inclure uniquement import timing imprimera les heures de début et de fin, ainsi que le temps écoulé global. (Pardonnez ma fonction obscure secondsToStr, elle formate simplement un nombre à virgule flottante de secondes en forme hh: mm: ss.sss.)
Remarque: Une version Python 3 du code ci-dessus peut être trouvée ici ou ici .
Sous Linux ou UNIX:
time python yourprogram.py
Dans Windows, voir cette discussion sur Stackoverflow: Comment mesurer le temps d'exécution de la commande en ligne de commande Windows?
import time
start_time = time.clock()
main()
print time.clock() - start_time, "seconds"
time.clock() renvoie le temps processeur, ce qui nous permet de calculer uniquement le temps utilisé par ce processus (de toute façon sous Unix). La documentation indique "dans tous les cas, c'est la fonction à utiliser pour évaluer les algorithmes Python ou de synchronisation"
J'aime beaucoup la réponse de Paul McGuire, mais j'utilise Python3. Donc pour ceux qui sont intéressés: voici une modification de sa réponse qui fonctionne avec Python 3 sur * nix (j'imagine, sous Windows, que clock () devrait être utilisé à la place de time ()):
#python3
import atexit
from time import time, strftime, localtime
from datetime import timedelta
def secondsToStr(elapsed=None):
if elapsed is None:
return strftime("%Y-%m-%d %H:%M:%S", localtime())
else:
return str(timedelta(seconds=elapsed))
def log(s, elapsed=None):
line = "="*40
print(line)
print(secondsToStr(), '-', s)
if elapsed:
print("Elapsed time:", elapsed)
print(line)
print()
def endlog():
end = time()
elapsed = end-start
log("End Program", secondsToStr(elapsed))
start = time()
atexit.register(endlog)
log("Start Program")
Si vous trouvez cela utile, vous devriez quand même voter pour sa réponse au lieu de celle-ci, comme il a fait la majeure partie du travail;).
Vous pouvez utiliser le profileur python cProfile pour mesurer le temps de calcul ainsi que le temps passé dans chaque fonction et le nombre d'appels de chaque fonction. Ceci est très utile si vous souhaitez améliorer les performances de votre script sans savoir par où commencer. Cette réponse à une autre SO question est très bonne. Il est toujours bon de jeter un coup d'œil dans la documentation aussi.
Voici un exemple de profilage d'un script à l'aide de cProfile à partir d'une ligne de commande:
$ python -m cProfile euler048.py
1007 function calls in 0.061 CPU seconds
Ordered by: standard name
ncalls tottime percall cumtime percall filename:lineno(function)
1 0.000 0.000 0.061 0.061 <string>:1(<module>)
1000 0.051 0.000 0.051 0.000 euler048.py:2(<lambda>)
1 0.005 0.005 0.061 0.061 euler048.py:2(<module>)
1 0.000 0.000 0.061 0.061 {execfile}
1 0.002 0.002 0.053 0.053 {map}
1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler objects}
1 0.000 0.000 0.000 0.000 {range}
1 0.003 0.003 0.003 0.003 {sum}
J'aime la sortie fournie par le module datetime, où les objets delta temporel affichent les jours, les heures, les minutes, etc. de manière lisible par l'homme.
Par exemple:
from datetime import datetime
start_time = datetime.now()
# do your work here
end_time = datetime.now()
print('Duration: {}'.format(end_time - start_time))
Exemple de sortie, par exemple.
Duration: 0:00:08.309267
ou
Duration: 1 day, 1:51:24.269711
Mise à jour: Comme J.F. Sebastian l’a mentionné, cette approche peut rencontrer des cas délicats avec l’heure locale, il est donc plus sûr d’utiliser:
import time
from datetime import timedelta
start_time = time.monotonic()
end_time = time.monotonic()
print(timedelta(seconds=end_time - start_time))
Encore mieux pour Linux: /usr/bin/time
$ /usr/bin/time -v python rhtest2.py
Command being timed: "python rhtest2.py"
User time (seconds): 4.13
System time (seconds): 0.07
Percent of CPU this job got: 91%
Elapsed (wall clock) time (h:mm:ss or m:ss): 0:04.58
Average shared text size (kbytes): 0
Average unshared data size (kbytes): 0
Average stack size (kbytes): 0
Average total size (kbytes): 0
Maximum resident set size (kbytes): 0
Average resident set size (kbytes): 0
Major (requiring I/O) page faults: 15
Minor (reclaiming a frame) page faults: 5095
Voluntary context switches: 27
Involuntary context switches: 279
Swaps: 0
File system inputs: 0
File system outputs: 0
Socket messages sent: 0
Socket messages received: 0
Signals delivered: 0
Page size (bytes): 4096
Exit status: 0
Normalement, time est un shell intégré plus simple qui masque le plus capable /usr/bin/time.
La solution de rogeriopvl fonctionne bien, mais si vous souhaitez des informations plus spécifiques, vous pouvez utiliser le profileur intégré à Python. Vérifiez cette page:
http://docs.python.org/library/profile.html
un profileur vous dit beaucoup d'informations utiles comme le temps passé dans chaque fonction
L'extrait suivant imprime le temps écoulé dans un format lisible de <HH:MM:SS> de Nice.
import time
from datetime import timedelta
start_time = time.time()
#
# Perform lots of computations.
#
elapsed_time_secs = time.time() - start_time
msg = "Execution took: %s secs (Wall clock time)" % timedelta(seconds=round(elapsed_time_secs))
print(msg)
from time import time
start_time = time()
...
end_time = time()
time_taken = end_time - start_time # time_taken is in seconds
hours, rest = divmod(time_taken,3600)
minutes, seconds = divmod(rest, 60)
time.clock ()
Déconseillé depuis la version 3.3: Le comportement de cette fonction dépend sur la plate-forme: utilisezperf_counter ()ouprocess_time ()à la place, en fonction de vos besoins, avoir un comportement bien défini.
time.perf_counter ()
Renvoie la valeur (en quelques secondes) d'un compteur de performance, c'est-à-dire une horloge avec la résolution la plus élevée disponible pour mesurer un court durée. Ilfaitcomprend le temps écoulé pendant le sommeil et est à l'échelle du système.
time.process_time ()
Renvoie la valeur (en fractions de secondes) de la somme du système et de temps de calcul utilisateur du processus en cours. Iln'inclut pasle temps écoulé pendant le sommeil.
start = time.process_time()
... do something
elapsed = (time.process_time() - start)
Ipython "timeit" n'importe quel script:
def foo():
%run bar.py
timeit foo()
J'ai consulté le module timeit, mais il semble que ce ne soit que pour de petits extraits de code. Je veux chronométrer tout le programme.
$ python -mtimeit -n1 -r1 -t -s "from your_module import main" "main()"
Il exécute la fonction your_module.main() une fois et imprime le temps écoulé à l'aide de la fonction time.time() en tant que minuterie.
Pour émuler /usr/bin/time en Python, voir Sous-processus Python avec/usr/bin/time: comment capturer des informations de minutage sans ignorer tous les autres résultats? .
Pour mesurer le temps processeur (par exemple, n'incluez pas le temps pendant time.sleep()) pour chaque fonction, vous pouvez utiliser le module profile (cProfile sur Python 2):
$ python3 -mprofile your_module.py
Vous pouvez passer la commande -p à la commande timeit ci-dessus si vous souhaitez utiliser le même minuteur que le module profile.
Utilisez simplement le module timeit. Cela fonctionne à la fois avec Python 2 et Python 3
import timeit
start = timeit.default_timer()
#ALL THE PROGRAM STATEMETNS
stop = timeit.default_timer()
execution_time = stop - start
print("Program Executed in "+execution_time) #It returns time in sec
Il revient en quelques secondes et vous pouvez avoir votre temps d'exécution. C'est simple mais vous devriez les écrire dans la fonction principale, qui lance l'exécution du programme. Si vous voulez obtenir le temps d'exécution même en cas d'erreur, prenez le paramètre "Démarrer" et calculez le comme
def sample_function(start,**kwargs):
try:
#your statements
Except:
#Except Statements
stop = timeit.default_timer()
execution_time = stop - start
print("Program Executed in "+execution_time)
J'aime aussi la réponse de Paul McGuire et j'ai créé un formulaire de gestionnaire de contexte qui répondait mieux à mes besoins.
import datetime as dt
import timeit
class TimingManager(object):
"""Context Manager used with the statement 'with' to time some execution.
Example:
with TimingManager() as t:
# Code to time
"""
clock = timeit.default_timer
def __enter__(self):
"""
"""
self.start = self.clock()
self.log('\n=> Start Timing: {}')
return self
def __exit__(self, exc_type, exc_val, exc_tb):
"""
"""
self.endlog()
return False
def log(self, s, elapsed=None):
"""Log current time and elapsed time if present.
:param s: Text to display, use '{}' to format the text with
the current time.
:param elapsed: Elapsed time to display. Dafault: None, no display.
"""
print s.format(self._secondsToStr(self.clock()))
if(elapsed is not None):
print 'Elapsed time: {}\n'.format(elapsed)
def endlog(self):
"""Log time for the end of execution with elapsed time.
"""
self.log('=> End Timing: {}', self.now())
def now(self):
"""Return current elapsed time as hh:mm:ss string.
:return: String.
"""
return str(dt.timedelta(seconds = self.clock() - self.start))
def _secondsToStr(self, sec):
"""Convert timestamp to h:mm:ss string.
:param sec: Timestamp.
"""
return str(dt.datetime.fromtimestamp(sec))
Il existe un module timeit qui peut être utilisé pour chronométrer les temps d'exécution des codes python . Il contient une documentation détaillée et des exemples dans python docs ( https://docs.python.org/2/library/timeit.html )
Utilisez line_profiler .
line_profiler déterminera la durée d'exécution de chaque ligne de code. Le profileur est implémenté en C via Cython afin de réduire les frais généraux de profilage.
from line_profiler import LineProfiler
import random
def do_stuff(numbers):
s = sum(numbers)
l = [numbers[i]/43 for i in range(len(numbers))]
m = ['hello'+str(numbers[i]) for i in range(len(numbers))]
numbers = [random.randint(1,100) for i in range(1000)]
lp = LineProfiler()
lp_wrapper = lp(do_stuff)
lp_wrapper(numbers)
lp.print_stats()
Les résultats seront:
Timer unit: 1e-06 s
Total time: 0.000649 s
File: <ipython-input-2-2e060b054fea>
Function: do_stuff at line 4
Line # Hits Time Per Hit % Time Line Contents
==============================================================
4 def do_stuff(numbers):
5 1 10 10.0 1.5 s = sum(numbers)
6 1 186 186.0 28.7 l = [numbers[i]/43 for i in range(len(numbers))]
7 1 453 453.0 69.8 m = ['hello'+str(numbers[i]) for i in range(len(numbers))]
Pour les utilisateurs de données utilisant Jupyter Notebooks
Dans une cellule, vous pouvez utiliser la commande magique %%time de Jupyter pour mesurer le temps d'exécution:
%%time
[ x**2 for x in range(10000)]
Sortie
Temps UC: utilisateur 4,54 ms, sys: 0 ns, total: 4,54 ms
Temps sur le mur: 4.12 ms
Cela ne capturera que le temps d'exécution d'une cellule particulière. Si vous souhaitez capturer l’heure d’exécution de tout le bloc-notes (programme), vous pouvez créer un nouveau bloc-notes dans le même répertoire et, dans le nouveau bloc-notes, exécuter toutes les cellules:
Supposons que le cahier ci-dessus s'appelle example_notebook.ipynb. Dans un nouveau carnet dans le même répertoire:
# Convert your notebook to a .py script:
!jupyter nbconvert --to script example_notebook.ipynb
# Run the example_notebook with -t flag for time
%run -t example_notebook
Sortie
Synchronisations du processeur IPython (estimation): Utilisateur: 0.00 s.
Système: 0.00 s.
Temps mural: 0.00 s.
C'est la réponse de Paul McGuire qui fonctionne pour moi. Juste au cas où quelqu'un aurait du mal à l'exécuter.
import atexit
from time import clock
def reduce(function, iterable, initializer=None):
it = iter(iterable)
if initializer is None:
value = next(it)
else:
value = initializer
for element in it:
value = function(value, element)
return value
def secondsToStr(t):
return "%d:%02d:%02d.%03d" % \
reduce(lambda ll,b : divmod(ll[0],b) + ll[1:],
[(t*1000,),1000,60,60])
line = "="*40
def log(s, elapsed=None):
print (line)
print (secondsToStr(clock()), '-', s)
if elapsed:
print ("Elapsed time:", elapsed)
print (line)
def endlog():
end = clock()
elapsed = end-start
log("End Program", secondsToStr(elapsed))
def now():
return secondsToStr(clock())
def main():
start = clock()
atexit.register(endlog)
log("Start Program")
appelez timing.main() à partir de votre programme après avoir importé le fichier.
Timeit est une classe en python utilisée pour calculer le temps d'exécution de petits blocs de code.
Default_timer est une méthode de cette classe utilisée pour mesurer le minutage de l'horloge murale et non le temps d'exécution de la CPU. Ainsi, une autre exécution de processus peut interférer avec cela. Cela est donc utile pour les petits blocs de code.
Un exemple du code est le suivant:
from timeit import default_timer as timer
start= timer()
#some logic
end = timer()
print("Time taken:", end-start)
J'ai utilisé une fonction très simple pour chronométrer une partie de l'exécution du code:
import time
def timing():
start_time = time.time()
return lambda x: print("[{:.2f}s] {}".format(time.time() - start_time, x))
Et pour l'utiliser, il suffit d'appeler avant le code à mesurer pour récupérer la fonction de minutage, puis d'appeler la fonction après le code avec les commentaires, et l'heure apparaît devant les commentaires, par exemple:
t = timing()
train = pd.read_csv('train.csv',
dtype={
'id': str,
'vendor_id': str,
'pickup_datetime': str,
'dropoff_datetime': str,
'passenger_count': int,
'pickup_longitude': np.float64,
'pickup_latitude': np.float64,
'dropoff_longitude': np.float64,
'dropoff_latitude': np.float64,
'store_and_fwd_flag': str,
'trip_duration': int,
},
parse_dates = ['pickup_datetime', 'dropoff_datetime'],
)
t("Loaded {} rows data from 'train'".format(len(train)))
Ensuite, le résultat ressemblera à ceci:
[9.35s] Loaded 1458644 rows data from 'train'
Je me sens un peu élégant de cette façon.
Pour utiliser réponse mise à jour de metakermit pour Python 2.7, vous aurez besoin du paquetage monotone .
Le code serait alors le suivant:
from datetime import timedelta
from monotonic import monotonic
start_time = monotonic()
end_time = monotonic()
print(timedelta(seconds=end_time - start_time))
L'heure de la mesure d'exécution d'un programme Python peut être incohérente selon:
- Le même programme peut être évalué en utilisant différents algorithmes
- Le temps d'exécution varie entre les algorithmes
- Le temps d'exécution varie selon les implémentations
- Le temps d'exécution varie entre les ordinateurs
- Le temps d'exécution n'est pas prévisible sur la base de petites entrées
En effet, le moyen le plus efficace consiste à utiliser "l'ordre de croissance" et à apprendre la grande notation "O" pour le faire correctement, https://en.wikipedia.org/wiki/Big_O_notation
Quoi qu’il en soit, vous pouvez essayer d’évaluer les performances de n’importe quel programme Python en incréments de comptage spécifiques par seconde à l’aide de cet algorithme simple: à adapter au programme à évaluer
import time
now = time.time()
future = now + 10
step = 4 # why 4 steps? because until here already 4 operations executed
while time.time() < future:
step += 3 # why 3 again? because while loop execute 1 comparison and 1 plus equal statement
step += 4 # why 3 more? because 1 comparison starting while when time is over plus final assignment of step + 1 and print statement
print(str(int(step / 10)) + " steps per second")
J'espère que cela vous aidera.
vous pouvez obtenir un moyen très simple en Python pas besoin de faire beaucoup de choses compliquées
import time
start = time.localtime()
end = time.localtime()
"""Total execution time in second$ """
print(end.tm_sec - start.tm_sec)
Si vous souhaitez mesurer le temps en microsecondes, vous pouvez utiliser la version suivante, entièrement basée sur les réponses de Paul McGuire et Nicojo - c'est un code Python3. J'ai aussi ajouté de la couleur:
import atexit
from time import time
from datetime import timedelta, datetime
def seconds_to_str(elapsed=None):
if elapsed is None:
return datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")
else:
return str(timedelta(seconds=elapsed))
def log(txt, elapsed=None):
colour_cyan = '\033[36m'
colour_reset = '\033[0;0;39m'
colour_red = '\033[31m'
print('\n ' + colour_cyan + ' [TIMING]> [' + seconds_to_str() + '] ----> ' + txt + '\n' + colour_reset)
if elapsed:
print("\n " + colour_red + " [TIMING]> Elapsed time ==> " + elapsed + "\n" + colour_reset)
def end_log():
end = time()
elapsed = end-start
log("End Program", seconds_to_str(elapsed))
start = time()
atexit.register(end_log)
log("Start Program")
log () => fonction qui affiche les informations de minutage.
txt ==> premier argument à consigner et chaîne pour marquer le timing.
atexit ==> module python pour enregistrer les fonctions que vous pouvez appeler lorsque le programme se termine.
C'est le moyen le plus simple d'obtenir le temps écoulé pour le programme: -
Écrivez le code suivant à la fin de votre programme.
import time
print(time.clock())