ti-enxame.com

Medindo o tempo decorrido com o módulo Tempo

Com o módulo Time em python é possível medir o tempo decorrido? Se sim, como faço isso?

Eu preciso fazer isso para que, se o cursor estiver em um widget por uma certa duração, um evento aconteça.

275
rectangletangle
start_time = time.time()
# your code
elapsed_time = time.time() - start_time

Você também pode escrever um simples decorador para simplificar a medição do tempo de execução de várias funções:

import time
from functools import wraps

PROF_DATA = {}

def profile(fn):
    @wraps(fn)
    def with_profiling(*args, **kwargs):
        start_time = time.time()

        ret = fn(*args, **kwargs)

        elapsed_time = time.time() - start_time

        if fn.__not in PROF_DATA:
            PROF_DATA[fn.__name__] = [0, []]
        PROF_DATA[fn.__name__][0] += 1
        PROF_DATA[fn.__name__][1].append(elapsed_time)

        return ret

    return with_profiling

def print_prof_data():
    for fname, data in PROF_DATA.items():
        max_time = max(data[1])
        avg_time = sum(data[1]) / len(data[1])
        print "Function %s called %d times. " % (fname, data[0]),
        print 'Execution time max: %.3f, average: %.3f' % (max_time, avg_time)

def clear_prof_data():
    global PROF_DATA
    PROF_DATA = {}

Uso:

@profile
def your_function(...):
    ...

Você pode criar mais de uma função ao mesmo tempo. Então, para imprimir as medições, basta chamar o print_prof_data ():

427
Vadim Shender

time.time() fará o trabalho.

import time

start = time.time()
# run your code
end = time.time()

elapsed = end - start

Você pode querer olhar para this question, mas não acho que seja necessário.

88
lalli

Para usuários que querem melhor formatação,

import time
start_time = time.time()
# your script
elapsed_time = time.time() - start_time
time.strftime("%H:%M:%S", time.gmtime(elapsed_time))

será impresso por 2 segundos:

'00:00:02'

e por 7 minutos um segundo:

'00:07:01'

note que a unidade mínima de tempo com gmtime é de segundos. Se você precisar de microssegundos, considere o seguinte:

import datetime
start = datetime.datetime.now()
# some code
end = datetime.datetime.now()
elapsed = end - start
print(elapsed)
# or
print(elapsed.seconds,":",elapsed.microseconds) 

strftime documentação

49
Rutger Hofste

Para a melhor medida do tempo decorrido (desde o Python 3.3), use time.perf_counter() .

Retorna o valor (em segundos fracionários) de um contador de desempenho, ou seja, um relógio com a maior resolução disponível para medir uma duração curta. Isso inclui o tempo decorrido durante o sono e é todo o sistema. O ponto de referência do valor retornado é indefinido, de modo que somente a diferença entre os resultados de chamadas consecutivas é válida.

Para medições na ordem de horas/dias, você não se preocupa com a resolução de sub-segundo, então use time.monotonic() .

Retorna o valor (em segundos fracionários) de um relógio monotônico, ou seja, um relógio que não pode retroceder. O relógio não é afetado pelas atualizações do relógio do sistema. O ponto de referência do valor retornado é indefinido, de modo que somente a diferença entre os resultados de chamadas consecutivas é válida.

Em muitas implementações, estas podem realmente ser a mesma coisa.

Antes de 3.3, você está preso com time.clock() .

No Unix, retorne a hora atual do processador como um número de ponto flutuante expresso em segundos. A precisão e, na verdade, a própria definição do significado de “tempo do processador” depende da função C do mesmo nome.

No Windows, esta função retorna segundos relógio de parede decorridos desde a primeira chamada para esta função, como um número de ponto flutuante, com base na função Win32 QueryPerformanceCounter (). A resolução é normalmente melhor que um microssegundo.


Atualização para o Python 3.7

Novo no Python 3.7 é PEP 564 - Adicione novas funções de hora com resolução de nanossegundos.

O uso desses recursos pode eliminar ainda mais os erros de arredondamento e ponto flutuante, especialmente se você estiver medindo períodos muito curtos, ou se seu aplicativo (ou computador Windows) estiver em execução há muito tempo.

A resolução começa a quebrar em perf_counter() após cerca de 100 dias. Assim, por exemplo, após um ano de tempo de atividade, o intervalo mais curto (maior que 0) que ele pode medir será maior do que quando começou.

31
OrangeDog

Você precisa importar tempo e usar o método time.time () para saber a hora atual.

import time

start_time=time.time() #taking current time as starting time

#here your code

elapsed_time=time.time()-start_time #again taking current time - starting time 
6
Nurul Akter Towhid

Por um longo período.

import time
start_time = time.time()
...
e = int(time.time() - start_time)
print('{:02d}:{:02d}:{:02d}'.format(e // 3600, (e % 3600 // 60), e % 60))

imprimiria

00:03:15

se mais de 24 horas

25:33:57

Isso é inspirado pela resposta de Rutger Hofste. Obrigado Rutger!

5
Tora

A resposta de Vadim Shender é ótima. Você também pode usar um decorador mais simples como abaixo:

import datetime
def calc_timing(original_function):                            
    def new_function(*args,**kwargs):                        
        start = datetime.datetime.now()                     
        x = original_function(*args,**kwargs)                
        elapsed = datetime.datetime.now()                      
        print("Elapsed Time = {0}".format(elapsed-start))     
        return x                                             
    return new_function()  

@calc_timing
def a_func(*variables):
    print("do something big!")
1
Mohammad