it-swarm-pt.tech

Precisão time.clock () vs. time.time () do Python?

Qual é melhor usar para cronometrar em Python? time.clock () ou time.time ()? Qual deles fornece mais precisão?

por exemplo:

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

vs.

start = time.time()
... do something
elapsed = (time.time() - start)
410
Corey Goldberg

A partir de 3.3, time.clock () está obsoleto , e é sugerido usar tempo .process_time () ou time.perf_counter () em vez disso.

Anteriormente em 2.7, de acordo com os docs do módulo de tempo:

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, mas em qualquer caso, esta é a função a ser usada para o benchmarking de algoritmos Python ou de tempo

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.

Além disso, há o módulo timeit para trechos de código de referência.

147
Jason Navarrete

A resposta curta é: a maior parte do tempo time.clock() será melhor. No entanto, se você estiver cronometrando algum hardware (por exemplo, algum algoritmo que você colocar na GPU), então time.clock() irá se livrar dessa hora e time.time() é a única solução que resta.

Nota: qualquer que seja o método usado, o tempo dependerá de fatores que você não pode controlar (quando o processo irá mudar, com que frequência, ...), isso é pior com time.time() mas também existe com time.clock(), então você nunca deve executar um teste de tempo apenas, mas sempre execute uma série de testes e observe a média/variância dos tempos.

45
PierreBdR

Outros ter respondido re: time.time() vs. time.clock().

No entanto, se você está cronometrando a execução de um bloco de código para fins de benchmarking/profiling, você deve dar uma olhada no timeit module .

25
dF.

Uma coisa a ter em mente: Alterar a hora do sistema afeta time.time() mas não time.clock().

Eu precisava controlar algumas execuções de testes automáticos. Se uma etapa do caso de teste levasse mais do que uma determinada quantidade de tempo, essa TC foi abortada para continuar com a próxima.

Mas às vezes uma etapa precisava alterar a hora do sistema (para verificar o módulo do planejador do aplicativo em teste), portanto, depois de definir o horário do sistema algumas horas no futuro, o tempo limite do TC expirou e o caso de teste foi interrompido. Eu tive que mudar de time.time() para time.clock() para lidar com isso corretamente.

19
Seba

clock() -> número de ponto flutuante

Retorna o tempo da CPU ou em tempo real desde o início do processo ou desde a primeira chamada para clock(). Isso tem tanta precisão quanto os registros do sistema.

time() -> número de ponto flutuante

Retorna o tempo atual em segundos desde a época. Frações de segundo podem estar presentes se o relógio do sistema as fornecer.

Geralmente time() é mais preciso, porque os sistemas operacionais não armazenam o tempo de execução do processo com a precisão que armazenam a hora do sistema (ou seja, a hora real)

18
Vinko Vrsalovic

Depende do que você gosta. Se você quer dizer TEMPO DE PAREDE (como em, a hora no relógio em sua parede), time.clock () não fornece precisão porque pode gerenciar o tempo de CPU.

17
user15910

Para o meu próprio practice. time() tem melhor precisão que clock() no Linux. clock() só tem precisão menor que 10 ms. Enquanto time() dá precisão perfeita. Meu teste está no CentOS 6.4, python 2.6

using time():

1 requests, response time: 14.1749382019 ms
2 requests, response time: 8.01301002502 ms
3 requests, response time: 8.01491737366 ms
4 requests, response time: 8.41021537781 ms
5 requests, response time: 8.38804244995 ms

using clock():

1 requests, response time: 10.0 ms
2 requests, response time: 0.0 ms 
3 requests, response time: 0.0 ms
4 requests, response time: 10.0 ms
5 requests, response time: 0.0 ms 
6 requests, response time: 0.0 ms
7 requests, response time: 0.0 ms 
8 requests, response time: 0.0 ms
13
bestwolf1983

A diferença é muito específica da plataforma.

clock () é muito diferente no Windows do que no Linux, por exemplo.

Para o tipo de exemplos que você descreve, você provavelmente quer o módulo "timeit".

6
Justin Sheehy

No Unix time.clock () mede a quantidade de tempo de CPU que foi usado pelo processo atual, então não é bom para medir o tempo decorrido de algum ponto no passado. No Windows, ele medirá segundos relógio de parede decorridos desde a primeira chamada para a função. Em ambos os sistemas, time.time () retornará segundos passados ​​desde a Época.

Se você está escrevendo código que serve apenas para o Windows, ou funcionará (embora você use os dois diferentemente - nenhuma subtração é necessária para time.clock ()). Se isso for executado em um sistema Unix ou se você desejar um código que seja garantido como portátil, será necessário usar time.time ().

3
auspace

Resposta curta: use time.clock () para tempo em Python.

Nos sistemas * nix, clock () retorna o tempo do processador como um número de ponto flutuante, expresso em segundos. No Windows, ele retorna os segundos decorridos desde a primeira chamada para essa função, como um número de ponto flutuante.

time () retorna os segundos desde o Epoch, em UTC, como um número de ponto flutuante. Não há garantia de que você obterá uma precisão melhor que 1 segundo (mesmo que time () retorne um número de ponto flutuante). Observe também que, se o relógio do sistema tiver sido retrocedido entre duas chamadas para essa função, a segunda chamada de função retornará um valor mais baixo.

2
Babak

Eu uso este código para comparar 2 métodos. Meu sistema operacional é o Windows 8, processador de núcleo i5, RAM 4GB

import time

def t_time():
    start=time.time()
    time.sleep(0.1)
    return (time.time()-start)


def t_clock():
    start=time.clock()
    time.sleep(0.1)
    return (time.clock()-start)




counter_time=0
counter_clock=0

for i in range(1,100):
    counter_time += t_time()

    for i in range(1,100):
        counter_clock += t_clock()

print "time() =",counter_time/100
print "clock() =",counter_clock/100

saída:

tempo () = 0.0993799996376

relógio () = 0.0993572257367

2
Nurul Akter Towhid

Como outros notaram, time.clock() está obsoleto em favor de time.perf_counter() ou time.process_time(), mas o Python 3.7 introduz um tempo de resolução de nanossegundos com time.perf_counter_ns() , time.process_time_ns() , e time.time_ns() , junto com outras 3 funções.

Estas 6 novas funções de resolução de nanosegundos estão detalhadas em PEP 564 :

time.clock_gettime_ns(clock_id)

time.clock_settime_ns(clock_id, time:int)

time.monotonic_ns()

time.perf_counter_ns()

time.process_time_ns()

time.time_ns()

Essas funções são semelhantes à versão sem o sufixo _ns, mas retornam um número de nanossegundos como um int do Python.

Como outros também notaram, use o timeit module para funções de tempo e pequenos trechos de código.

2
Chris_Rands

Pelo que entendi, o time.clock () tem tanta precisão quanto o seu sistema permite.

2
Jake

Resposta certa: Eles são ambos o mesmo comprimento de uma fração.

Mas qual é mais rápido se subject for time?

m pequeno caso de teste:

import timeit
import time

clock_list = []
time_list = []

test1 = """
def test(v=time.clock()):
    s = time.clock() - v
"""

test2 = """
def test(v=time.time()):
    s = time.time() - v
"""
def test_it(Range) :
    for i in range(Range) :
        clk = timeit.timeit(test1, number=10000)
        clock_list.append(clk)
        tml = timeit.timeit(test2, number=10000)
        time_list.append(tml)

test_it(100)

print "Clock Min: %f Max: %f Average: %f" %(min(clock_list), max(clock_list), sum(clock_list)/float(len(clock_list)))
print "Time  Min: %f Max: %f Average: %f" %(min(time_list), max(time_list), sum(time_list)/float(len(time_list)))

Eu não trabalho em um laboratório suíço, mas eu testei ..

Com base nesta pergunta: time.clock() é melhor que time.time()

Editar: time.clock() é contador interno, portanto, não pode usar fora, tem limitações max 32BIT FLOAT, não pode continuar contando se não armazenar primeiro/último valor. Não é possível mesclar outro contador ...

1
dsgdfg