Come ottengo il tempo di esecuzione di un programma Python?

Ho un programma da riga di comando in Python che richiede un po 'di tempo per finire. Voglio sapere il tempo esatto necessario per terminare la corsa.

Ho guardato il timeitmodulo, ma sembra che sia solo per piccoli frammenti di codice. Voglio cronometrare l'intero programma.

Il modo più semplice in Python:

import time
start_time = time.time()
main()
print("--- %s seconds ---" % (time.time() - start_time))

Ciò presuppone che l'esecuzione del programma richieda almeno un decimo di secondo.

stampe:

--- 0.764891862869 seconds ---

Ho inserito questo timing.pymodulo nella mia site-packagesdirectory e ho inserito import timingnella parte superiore del mio modulo:

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")

Posso anche chiamare timing.logdal mio programma se ci sono fasi significative all'interno del programma che voglio mostrare. Ma solo includendo import timingverranno stampati gli orari di inizio e fine e il tempo complessivo trascorso. (Perdona la mia oscura secondsToStrfunzione, formatta solo un numero in virgola mobile di secondi in hh: mm: ss.sss form.)

Nota: una versione di Python 3 del codice sopra è disponibile qui o qui .

In Linux o Unix:

$ time python yourprogram.py

In Windows, vedi questa domanda StackOverflow: come misurare il tempo di esecuzione di un comando sulla riga comandi di Windows?

Per un output più dettagliato,

$ 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

Mi piace molto la risposta di Paul McGuire , ma uso Python 3. Quindi per coloro che sono interessati: ecco una modifica della sua risposta che funziona con Python 3 su * nix (immagino, sotto Windows, che clock()dovrebbe essere usato al posto di 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")

Se lo trovi utile, dovresti comunque votare la sua risposta invece di questa, come ha fatto la maggior parte del lavoro;).

import time

start_time = time.clock()
main()
print time.clock() - start_time, "seconds"

time.clock()restituisce il tempo del processore, che ci consente di calcolare solo il tempo utilizzato da questo processo (su Unix comunque). La documentazione dice "in ogni caso, questa è la funzione da utilizzare per il benchmarking di Python o algoritmi di temporizzazione"

Mi piace l'output datetimefornito dal modulo, in cui gli oggetti delta del tempo mostrano giorni, ore, minuti, ecc. Secondo necessità in modo leggibile dall'uomo.

Per esempio:

from datetime import datetime
start_time = datetime.now()
# do your work here
end_time = datetime.now()
print('Duration: {}'.format(end_time - start_time))

Esempio di output ad es

Duration: 0:00:08.309267

o

Duration: 1 day, 1:51:24.269711

Come menzionato da JF Sebastian, questo approccio potrebbe incontrare alcuni casi difficili con l'ora locale, quindi è più sicuro usare:

import time
from datetime import timedelta
start_time = time.monotonic()
end_time = time.monotonic()
print(timedelta(seconds=end_time - start_time))

È possibile utilizzare il profiler cProfile di Python per misurare il tempo della CPU e inoltre quanto tempo viene impiegato all'interno di ciascuna funzione e quante volte viene chiamata ciascuna funzione. Questo è molto utile se vuoi migliorare le prestazioni del tuo script senza sapere da dove cominciare. Questa risposta a un'altra domanda Stack Overflow è abbastanza buona. È sempre utile dare un'occhiata anche alla documentazione .

Ecco un esempio di come profilare uno script usando cProfile da una riga di comando:

$ 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}

Ancora meglio per Linux: time

$ 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

time.clock ()

Obsoleto dalla versione 3.3: il comportamento di questa funzione dipende dalla piattaforma: utilizzare perf_counter () o process_time () invece, a seconda delle proprie esigenze, per avere un comportamento ben definito.

time.perf_counter ()

Restituisce il valore (in secondi frazionari) di un contatore delle prestazioni, ovvero un orologio con la massima risoluzione disponibile per misurare una breve durata. Esso non comprende il tempo trascorso durante il sonno ed è a livello di sistema.

time.process_time ()

Restituisce il valore (in secondi frazionari) della somma del sistema e il tempo della CPU dell'utente del processo corrente. Essa non include il tempo trascorso durante il sonno.

start = time.process_time()
... do something
elapsed = (time.process_time() - start)

Usa semplicemente il timeitmodulo. Funziona con Python 2 e Python 3.

import timeit

start = timeit.default_timer()

# All the program statements
stop = timeit.default_timer()
execution_time = stop - start

print("Program Executed in "+str(execution_time)) # It returns time in seconds

Ritorna in pochi secondi e puoi avere il tuo tempo di esecuzione. È semplice, ma dovresti scriverli nella funzione principale w che avvia l'esecuzione del programma. Se vuoi ottenere il tempo di esecuzione anche quando ricevi un errore, prendi il tuo parametro "Start" e calcola lì come:

def sample_function(start,**kwargs):
     try:
         # Your statements
     except:
         # except statements run when your statements raise an exception
         stop = timeit.default_timer()
         execution_time = stop - start
         print("Program executed in " + str(execution_time))

Il frammento seguente stampa il tempo trascorso in un bel <HH:MM:SS>formato leggibile dall'uomo .

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)

In IPython , "timeit" qualsiasi script:

def foo():
    %run bar.py
timeit foo()

Ho guardato il modulo timeit, ma sembra che sia solo per piccoli frammenti di codice. Voglio cronometrare l'intero programma.

$ python -mtimeit -n1 -r1 -t -s "from your_module import main" "main()"

Esegue la your_module.main()funzione una volta e stampa il tempo trascorso usando la time.time()funzione come timer.

Per emulare /usr/bin/timein Python vedi sottoprocesso di Python con / usr / bin / time: come catturare le informazioni di temporizzazione ma ignorare tutti gli altri output? .

Per misurare il tempo della CPU (ad esempio, non includere il tempo durante time.sleep()) per ciascuna funzione, è possibile utilizzare il profilemodulo ( cProfilesu Python 2):

$ python3 -mprofile your_module.py

È possibile passare -pal timeitcomando sopra se si desidera utilizzare lo stesso timer profileutilizzato dal modulo.

Vedi Come puoi profilare uno script Python?

Mi è piaciuta anche la risposta di Paul McGuire e ho ideato un modulo per la gestione del contesto che si adattava di più alle mie esigenze.

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))

Per la gente dei dati che utilizza Jupyter Notebook

In una cella, puoi usare il %%timecomando magico di Jupyter per misurare il tempo di esecuzione:

%%time
[ x**2 for x in range(10000)]

Produzione

CPU times: user 4.54 ms, sys: 0 ns, total: 4.54 ms
Wall time: 4.12 ms

Questo acquisirà solo il tempo di esecuzione di una determinata cella. Se desideri acquisire il tempo di esecuzione dell'intero blocco note (ad es. Programma), puoi creare un nuovo blocco appunti nella stessa directory e nel nuovo blocco appunti eseguire tutte le celle:

Supponiamo che il notebook sopra sia chiamato example_notebook.ipynb. In un nuovo blocco appunti nella stessa directory:

# 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

Produzione

IPython CPU timings (estimated):
  User   :       0.00 s.
  System :       0.00 s.
Wall time:       0.00 s.

C'è un timeitmodulo che può essere usato per cronometrare i tempi di esecuzione del codice Python.

Ha una documentazione dettagliata ed esempi nella documentazione di Python, 26.6. timeit - Misura il tempo di esecuzione di piccoli frammenti di codice .

Usa line_profiler .

line_profiler indicherà il tempo impiegato dalle singole righe di codice per l'esecuzione. Il profiler è implementato in C via Cython al fine di ridurre le spese generali di profilazione.

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()

I risultati saranno:

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))]

Ho usato una funzione molto semplice per cronometrare una parte dell'esecuzione del codice:

import time
def timing():
    start_time = time.time()
    return lambda x: print("[{:.2f}s] {}".format(time.time() - start_time, x))

E per usarlo, basta chiamarlo prima del codice per misurare per recuperare il timing della funzione, quindi chiamare la funzione dopo il codice con commenti. Il tempo apparirà davanti ai commenti. Per esempio:

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)))

Quindi l'output sarà simile al seguente:

[9.35s] Loaded 1458644 rows data from 'train'

Avevo lo stesso problema in molti posti, quindi ho creato un pacchetto di convenienza horology. Puoi installarlo con pip install horologye poi farlo in modo elegante:

from horology import Timing

with Timing(name='Important calculations: '):
    prepare()
    do_your_stuff()
    finish_sth()

produrrà:

Important calculations: 12.43 ms

O ancora più semplice (se hai una funzione):

from horology import timed

@timed
def main():
    ...

produrrà:

main: 7.12 h

Si prende cura delle unità e degli arrotondamenti. Funziona con Python 3.6 o versioni successive.

Questa è la risposta di Paul McGuire che funziona per me. Nel caso in cui qualcuno avesse problemi a gestirlo.

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")

Chiama timing.main()dal tuo programma dopo aver importato il file.

Timeit è una classe in Python utilizzata per calcolare il tempo di esecuzione di piccoli blocchi di codice.

Default_timer è un metodo in questa classe che viene utilizzato per misurare il timing del wall clock, non il tempo di esecuzione della CPU. Pertanto, l'esecuzione di altri processi potrebbe interferire con questo. Pertanto è utile per piccoli blocchi di codice.

Un esempio del codice è il seguente:

from timeit import default_timer as timer

start= timer()

# Some logic

end = timer()

print("Time taken:", end-start)

Più tardi rispondo, ma io uso timeit:

import timeit
code_to_test = """
a = range(100000)
b = []
for i in a:
    b.append(i*2)
"""
elapsed_time = timeit.timeit(code_to_test, number=500)
print(elapsed_time)
# 10.159821493085474

• Avvolgi tutto il tuo codice, comprese tutte le importazioni che potresti avere, all'interno code_to_test.
• number L'argomento specifica il numero di volte in cui il codice deve essere ripetuto.
• dimostrazione

Il tempo della misura di esecuzione di un programma Python potrebbe essere incoerente a seconda di:

• Lo stesso programma può essere valutato utilizzando algoritmi diversi
• Il tempo di esecuzione varia tra gli algoritmi
• Il tempo di esecuzione varia tra le implementazioni
• Il tempo di esecuzione varia tra i computer
• Il tempo di esecuzione non è prevedibile in base a piccoli input

Questo perché il modo più efficace è usare l '"Ordine di crescita" e imparare la notazione "O" per farlo correttamente.

Ad ogni modo, puoi provare a valutare le prestazioni di qualsiasi programma Python in specifici passaggi di conteggio macchina al secondo usando questo semplice algoritmo: adatta questo al programma che vuoi valutare

import time

now = time.time()
future = now + 10
step = 4 # Why 4 steps? Because until here already four operations executed
while time.time() < future:
    step += 3 # Why 3 again? Because a while loop executes one comparison and one plus equal statement
step += 4 # Why 3 more? Because one comparison starting while when time is over plus the final assignment of step + 1 and print statement
print(str(int(step / 10)) + " steps per second")

Lo fai semplicemente in Python. Non è necessario complicarlo.

import time

start = time.localtime()
end = time.localtime()
"""Total execution time in seconds$ """
print(end.tm_sec - start.tm_sec)

Simile alla risposta di @rogeriopvl ho aggiunto una leggera modifica per convertire in ore minuti secondi usando la stessa libreria per lavori di lunga durata.

import time
start_time = time.time()
main()
seconds = time.time() - start_time
print('Time Taken:', time.strftime("%H:%M:%S",time.gmtime(seconds)))

Uscita campione

Time Taken: 00:00:08

Innanzitutto, installa il pacchetto di tipo umano aprendo il prompt dei comandi (CMD) come amministratore e digita lì - pip install humanfriendly

Codice:

from humanfriendly import format_timespan
import time
begin_time = time.time()
# Put your code here
end_time = time.time() - begin_time
print("Total execution time: ", format_timespan(end_time))

Produzione:

Per utilizzare la risposta aggiornata di metakermit per Python 2.7, è necessario il pacchetto monotonico .

Il codice sarebbe quindi il seguente:

from datetime import timedelta
from monotonic import monotonic

start_time = monotonic()
end_time = monotonic()
print(timedelta(seconds=end_time - start_time))

Ho provato e trovato la differenza di orario usando i seguenti script.

import time

start_time = time.perf_counter()
[main code here]
print (time.perf_counter() - start_time, "seconds")

Se vuoi misurare il tempo in microsecondi, puoi utilizzare la seguente versione, basata completamente sulle risposte di Paul McGuire e Nicojo : è il codice Python 3. Ho anche aggiunto un po 'di colore ad esso:

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 () => funzione che stampa le informazioni di temporizzazione.

txt ==> primo argomento da registrare e relativa stringa per contrassegnare i tempi.

atexit ==> Modulo Python per registrare funzioni che puoi chiamare quando il programma esce.