Comment puis-je obtenir le temps d'exécution D'un programme Python?
j'ai un programme en ligne de commande en Python qui prend du temps à finir. Je veux savoir combien de temps il faut pour finir de courir.
j'ai regardé le module timeit , mais il semble que c'est seulement pour les petits bouts de code. Je veux chronométrer tout le programme.
24 réponses
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.
Imprime:
--- 0.764891862869 seconds ---
j'ai mis ce module timing.py dans mon propre répertoire site-packages , et il suffit d'insérer 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 de mon programme s'il y a des étapes importantes dans le programme que je veux montrer. Mais juste inclure import timing permettra d'imprimer les heures de début et de fin, et le temps total écoulé. (Pardonnez mon obscur secondsToStr fonction, il formate juste un nombre de virgule flottante de secondes à hh: mm:SS.formulaire sss.)
Note: 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 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 le temps utilisé par ce processus (sur Unix). La documentation dit "dans tous les cas, c'est la fonction à utiliser pour comparer les algorithmes Python ou timing"
j'aime vraiment 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é au lieu 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 toujours voter sa réponse à la place de celle-ci, comme il a fait la plupart du travail ;).
vous pouvez utiliser le profileur python cProfile pour mesurer CPU time et en plus combien de temps est passé à l'intérieur de chaque fonction et combien de fois chaque fonction est appelée. Ceci est très utile si vous voulez améliorer la performance de votre script sans savoir où commencer. Cette réponse à l'autre DONC, la question est très bonne. Il est toujours bon d'avoir un regard dans le docs aussi.
voici un exemple comment profiler un script en utilisant 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 de la datetime module fournit, où le temps delta objets montrent des jours, heures, minutes, etc. pour nécessaire dans une 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))
sortie D'échantillon, p.ex.
Duration: 0:00:08.309267
ou
Duration: 1 day, 1:51:24.269711
mise à jour: comme J. F. Sebastian l'a mentionné, cette approche pourrait rencontrer certains cas difficiles avec l'heure locale, il est donc plus sûr de use:
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, juste time est un interpréteur de commandes plus simple que shadows the more capable /usr/bin/time .
la solution de rogeriopvl fonctionne très bien, mais si vous voulez des informations plus spécifiques, vous pouvez utiliser le profileur python intégré. Vérifier 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 par l'homme <HH:MM:SS> .
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)
j'ai regardé le module timeit, mais il semble que c'est seulement pour les petits bouts de code. Je veux chronométrer tout le programme.
$ python -mtimeit -n1 -r1 -t -s "from your_module import main" "main()"
il exécute your_module.main() fonction une fois et imprimer le temps écoulé En utilisant time.time() fonction comme une minuterie.
D'émuler /usr/bin/time en Python voir Python sous-processus avec la commande /usr/bin/temps: comment faire pour capturer le délai d'informations, mais ignorer toutes les autres sorties? .
pour mesurer le temps CPU (par exemple, ne pas inclure le temps pendant time.sleep() ) pour chaque fonction, vous pouvez utiliser profile module ( cProfile sur Python 2):
$ python3 -mprofile your_module.py
vous pouvez passer -p à la commande timeit ci-dessus si vous voulez utiliser le même minuteur que le module profile utilise.
Ipython "timeit" aucun script:
def foo():
%run bar.py
timeit foo()
du temps.horloge()
déprécié depuis la version 3.3: le comportement de cette fonction dépend sur la plateforme: utiliser perf_counter () ou process_time () à la place, selon vos besoins, à avoir un comportement défini.
du temps.perf_counter ()
retourner la valeur (en fraction de seconde) d'un compteur de performances, c'est-à-dire une horloge avec la plus haute résolution disponible pour mesurer un court durée. ne inclure le temps écoulé pendant le sommeil et est à l'échelle du système.
du temps.process_time ()
renvoie la valeur (en fraction de seconde) de la somme de: le système et temps CPU de L'utilisateur du processus courant. It ne comprend pas temps écoulé pendant le sommeil.
start = time.process_time()
... do something
elapsed = (time.process_time() - start)
il suffit d'utiliser timeit module. Il 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 retourne en quelques secondes et vous pouvez avoir votre temps d'exécution. Simple mais vous devez les écrire dans la fonction principale qui commence l'exécution du programme. Si vous voulez obtenir le temps d'Exécution, même lorsque vous obtenez l'erreur puis prenez votre paramètre "Start" et le calculer 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)
il existe un module timeit qui peut être utilisé pour chronométrer les temps d'exécution des codes python.
Il a une documentation détaillée et des exemples dans python docs ( https://docs.python.org/2/library/timeit.html )
J'aime aussi la réponse de Paul McGuire et j'ai trouvé un formulaire de gestionnaire de contexte qui convenait davantage à 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))
C'est la réponse de Paul McGuire qui fonctionne pour moi. Juste au cas où quelqu'un avait de la difficulté à l'exécution de celui-là.
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() de votre programme après avoir importé le fichier.
Timeit est une classe de python utilisée pour calculer le temps d'exécution de petits blocs de code.
Default_timer est une méthode de cette classe qui est utilisée pour mesurer le timing de l'horloge murale et non le temps D'exécution CPU. Ainsi, l'exécution d'autres processus pourrait interférer avec cela. Il est donc utile pour les petits blocs de code.
un échantillon du code est le suivant:
from timeit import default_timer as timer
start= timer()
#some logic
end = timer()
print("Time taken:", end-start)
Utiliser line_profiler .
line_profiler va établir le profil des lignes de temps de code individuelles à exécuter. 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 données les gens à l'aide Jupyter Cahiers
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 CPU: utilisateur 4.54 ms, sys: 0 ns, total: 4.54 ms
Durée du mur: 4.12 ms
Cela ne capture le temps d'exécution d'une cellule particulière. Si vous souhaitez capturer l' le temps d'exécution de l'ensemble de l'ordinateur portable (programme), vous pouvez créer un nouveau bloc-notes dans le même répertoire et dans le nouveau carnet d'exécuter toutes les cellules:
supposons que le carnet 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
IPython CPU timings (estimé):
Utilisateur: 0.00 S.
Système: 0.00 S.
Durée de paroi: 0.00 S.
pour utiliser réponse mise à jour de metakermit pour python 2.7, vous aurez besoin du paquet 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))
le temps d'une mesure D'exécution D'un programme Python peut être incohérent selon:
- un même programme peut être évalué à l'aide d'algorithmes différents
- le temps d'exécution varie entre les algorithmes
- durée d'exécution varie entre les implémentations
- le temps D'exécution varie d'un ordinateur à l'autre
- temps d'Exécution n'est pas prévisible sur les petites entrées
c'est parce que le moyen le plus efficace est d'utiliser "L'ordre de croissance" et d'apprendre le Grand "O" notation pour le faire correctement, https://en.wikipedia.org/wiki/Big_O_notation
de toute façon, vous pouvez essayer d'évaluer la performance de n'importe quel programme Python en étapes de comptage machine spécifiques par seconde en utilisant cet algorithme simple: adaptez ceci au programme que vous voulez é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.
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 à utiliser, il suffit de l'appeler avant le code de mesure de récupérer la fonction de synchronisation, puis appeler la fonction après le code avec des commentaires, et le temps apparaissent 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)))
alors la sortie ressemblera à ceci:
[9.35s] Loaded 1458644 rows data from 'train'
je me sens un peu élégant de cette façon.