Ottieni tick di timer in Python

Question

Sto solo cercando di cronometrare un pezzo di codice. Lo pseudocodice è simile a:

start = get_ticks()
do_long_code()
print "It took " + (get_ticks() - start) + " seconds."

Come appare in Python?

Più specificamente, come posso ottenere il numero di tick dalla mezzanotte (o comunque Python organizza tale tempistica)?

Answer 1

Nel modulo time , ci sono due funzioni di temporizzazione: time e clock . time ti dà " wall " tempo, se questo è ciò che ti interessa.

Tuttavia, i python docs dicono che clock dovrebbe essere utilizzato per il benchmarking. Nota che clock si comporta diversamente in sistemi separati:

• su MS Windows, utilizza la funzione Win32 QueryPerformanceCounter (), con una risoluzione "tipicamente migliore di un microsecondo". Non ha un significato speciale, è solo un numero (inizia a contare la prima volta che chiami clock nel tuo processo).

    # ms windows
    t0= time.clock()
    do_something()
    t= time.clock() - t0 # t is wall seconds elapsed (floating point)

• su * nix, clock riporta il tempo della CPU. Ora, questo è diverso, e molto probabilmente il valore che desideri, dal momento che il tuo programma quasi mai è l'unico processo che richiede il tempo della CPU (anche se non hai altri processi, il kernel usa di tanto in tanto il tempo della CPU). Quindi, questo numero, che in genere è più piccolo & # 185; rispetto al tempo di wall (ovvero time.time () - t0), è più significativo quando si esegue il benchmarking del codice:

    # linux
    t0= time.clock()
    do_something()
    t= time.clock() - t0 # t is CPU seconds elapsed (floating point)

A parte tutto ciò, il modulo timeit ha il Timer che dovrebbe usare ciò che è meglio per il benchmarking dalla funzionalità disponibile.

& # 185; a meno che il threading non ostacoli & # 8230;

& # 178; Python & # 8805; 3.3: ci sono time.perf_counter () e time.process_time () . perf_counter è utilizzato dal modulo timeit .

Answer 2

Ciò di cui hai bisogno è la funzione time () dal modulo time :

import time
start = time.time()
do_long_code()
print "it took", time.time() - start, "seconds."

Puoi utilizzare il modulo timeit per ulteriori opzioni.

Answer 3

Ecco una soluzione che ho iniziato a utilizzare di recente:

class Timer:
    def __enter__(self):
        self.begin = now()

    def __exit__(self, type, value, traceback):
        print(format_delta(self.begin, now()))

Lo usi in questo modo (devi almeno Python 2.5):

with Timer():
    do_long_code()

Al termine del codice, Timer stampa automaticamente il tempo di esecuzione. Dolce! Se sto provando a mettere rapidamente in pan qualcosa nell'interprete Python, questo è il modo più semplice di procedere.

Ed ecco un'implementazione di esempio di 'now' e 'format_delta', anche se sentiti libero di usare il tuo metodo di formattazione e tempismo preferito.

import datetime

def now():
    return datetime.datetime.now()

# Prints one of the following formats*:
# 1.58 days
# 2.98 hours
# 9.28 minutes # Not actually added yet, oops.
# 5.60 seconds
# 790 milliseconds
# *Except I prefer abbreviated formats, so I print d,h,m,s, or ms. 
def format_delta(start,end):

    # Time in microseconds
    one_day = 86400000000
    one_hour = 3600000000
    one_second = 1000000
    one_millisecond = 1000

    delta = end - start

    build_time_us = delta.microseconds + delta.seconds * one_second + delta.days * one_day

    days = 0
    while build_time_us > one_day:
        build_time_us -= one_day
        days += 1

    if days > 0:
        time_str = "%.2fd" % ( days + build_time_us / float(one_day) )
    else:
        hours = 0
        while build_time_us > one_hour:
            build_time_us -= one_hour
            hours += 1
        if hours > 0:
            time_str = "%.2fh" % ( hours + build_time_us / float(one_hour) )
        else:
            seconds = 0
            while build_time_us > one_second:
                build_time_us -= one_second
                seconds += 1
            if seconds > 0:
                time_str = "%.2fs" % ( seconds + build_time_us / float(one_second) )
            else:
                ms = 0
                while build_time_us > one_millisecond:
                    build_time_us -= one_millisecond
                    ms += 1
                time_str = "%.2fms" % ( ms + build_time_us / float(one_millisecond) )
    return time_str

Per favore fatemi sapere se avete un metodo di formattazione preferito o se esiste un modo più semplice per fare tutto questo!

Answer 4

Il modulo orario in python ti dà accesso all'orologio () funzione, che restituisce il tempo in secondi come virgola mobile.

Sistemi diversi avranno un'accuratezza diversa in base alla configurazione dell'orologio interno (tick al secondo) ma in genere è almeno inferiore a 20 millisecondi e in alcuni casi migliore di alcuni microsecondi.

-Adam

Answer 5

import datetime

start = datetime.datetime.now()
do_long_code()
finish = datetime.datetime.now()
delta = finish - start
print delta.seconds

Da mezzanotte:

import datetime

midnight = datetime.datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
now = datetime.datetime.now()
delta = now - midnight
print delta.seconds

Answer 6

Se hai molte affermazioni che desideri, potresti usare qualcosa del genere:

class Ticker:
    def __init__(self):
        self.t = clock()

    def __call__(self):
        dt = clock() - self.t
        self.t = clock()
        return 1000 * dt

Quindi il tuo codice potrebbe apparire come:

tick = Ticker()
# first command
print('first took {}ms'.format(tick())
# second group of commands
print('second took {}ms'.format(tick())
# third group of commands
print('third took {}ms'.format(tick())

In questo modo non è necessario digitare t = time () prima di ogni blocco e 1000 * (time () - t) dopo di esso, mantenendo comunque controllo sulla formattazione (anche se potresti facilmente inserirlo anche in Ticket ).

È un guadagno minimo, ma penso che sia abbastanza conveniente.