Comment obtenir le temps d'exécution d'un programme Python ?

Question

J'ai un programme en ligne de commande en Python qui met un certain temps à se terminer. Je veux connaître le temps exact qu'il met pour finir de s'exécuter.

J'ai regardé les timeit mais il semble que ce soit uniquement pour les petits bouts de code. Je veux chronométrer l'ensemble du programme.

Answer 1

La méthode 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.

Imprimés :

--- 0.764891862869 seconds ---

Answer 2

Dans Linux ou Unix :

$ time python yourprogram.py

Sous Windows, voir cette question StackOverflow : Comment mesurer le temps d'exécution d'une commande sur la ligne de commande Windows ?

Pour une sortie plus verbeuse,

$ time -v python yourprogram.py
    Command being timed: "python3 yourprogram.py"
    User time (seconds): 0.08
    System time (seconds): 0.02
    Percent of CPU this job got: 98%
    Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.10
    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): 9480
    Average resident set size (kbytes): 0
    Major (requiring I/O) page faults: 0
    Minor (reclaiming a frame) page faults: 1114
    Voluntary context switches: 0
    Involuntary context switches: 22
    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

Answer 3

J'ai mis ce timing.py dans mon propre module site-packages et insérez 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 de mon programme s'il y a des étapes importantes dans le programme que je veux montrer. Mais le fait d'inclure import timing imprimera les heures de début et de fin, ainsi que le temps total écoulé. (Pardonnez mon obscurité secondsToStr il ne fait que formater un nombre de secondes en virgule flottante sous la forme hh:mm:ss.sss).

Remarque : une version Python 3 du code ci-dessus peut être trouvée aquí o aquí .

Answer 4

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 (sous Unix en tout cas). La documentation dit "dans tous les cas, c'est la fonction à utiliser pour benchmarker Python ou les algorithmes de chronométrage".

Answer 5

Vous pouvez utiliser le profileur Python cProfile pour mesurer Temps CPU ainsi que le temps passé dans chaque fonction et le nombre de fois où chaque fonction est appelée. Ceci est très utile si vous voulez améliorer les performances de votre script sans savoir par où commencer. Cette réponse à une autre question de Stack Overflow est plutôt bon. Il est toujours bon de jeter un coup d'oeil dans la documentation aussi.

Voici un exemple de la façon de profiler un script en utilisant cProfile depuis 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}