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

Qual é o melhor para usar no timing no Python? time.clock () ou time.time ()? Qual 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)

A partir do 3.3, o time.clock () está obsoleto e é sugerido o uso de time.process_time () ou time.perf_counter () .

Anteriormente na 2.7, de acordo com os documentos do módulo de tempo :

Rélogio de ponto()

No Unix, retorne o tempo atual do processador como um número de ponto flutuante expresso em segundos. A precisão e, de fato, a própria definição do significado de “tempo do processador”, depende da função C com o mesmo nome, mas, em qualquer caso, esta é a função a ser usada para comparar algoritmos Python ou de tempo.

No Windows, essa função retorna os segundos do relógio de parede decorridos desde a primeira chamada para essa 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, existe o módulo timeit para comparações de snippets de código.

A resposta curta é: na maioria das vezes time.clock()será melhor. No entanto, se você estiver cronometrando algum hardware (por exemplo, algum algoritmo que você coloca na GPU), ele time.clock()se livra desse tempo 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 mudará, com que frequência ...), isso é pior com, time.time()mas também existe com time.clock(), portanto, você nunca deve executar apenas um teste de tempo, mas sempre execute uma série de testes e observe a média / variação dos tempos.

Outros responderam re: time.time()vs. time.clock().

No entanto, se você estiver programando a execução de um bloco de código para fins de comparação / criação de perfil, dê uma olhada no timeitmódulo .

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 de um determinado período de tempo, esse TC seria abortado para continuar com a próxima.

Às vezes, porém, era necessária uma etapa para alterar a hora do sistema (para verificar o módulo do planejador do aplicativo em teste); portanto, após definir a hora do sistema em algumas horas no futuro, o tempo limite do TC expirou e o caso de teste foi abortado. Eu tive que mudar de time.time()para time.clock()lidar com isso corretamente.

clock() -> número de ponto flutuante

Retorne o tempo da CPU ou o 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

Retorne 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 o tempo do sistema (ou seja, tempo real)

Depende do que você gosta. Se você quer dizer WALL TIME (como em, a hora no relógio na parede), time.clock () NÃO fornece precisão, pois pode gerenciar o tempo da CPU.

time()tem melhor precisão do que clock()no Linux. clock()só tem precisão menor que 10 ms. Enquanto time()dá precisão prefeito. 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

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

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

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

Como outros, conhecida time.clock()é depreciado em favor do time.perf_counter()ou time.process_time(), mas tempo de resolução Python 3.7 introduz nanossegundo com time.perf_counter_ns(), time.process_time_ns()e time.time_ns(), juntamente com 3 outras funções.

Estas 6 novas funções de resolução em nansegundos estão detalhadas no 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 Python.

Como outros também observaram, use o timeitmódulo para cronometrar funções e pequenos trechos de código.

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

Se você estiver escrevendo um código destinado apenas ao Windows, ambos funcionarão (embora você use os dois de maneira diferente - nenhuma subtração é necessária para time.clock ()). Se isso for executado em um sistema Unix ou você quiser um código que seja garantido como portátil, convém usar time.time ().

Resposta curta: use time.clock () para cronometrar 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 esta função, como um número de ponto flutuante.

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

De acordo com o meu entendimento, time.clock () tem a precisão que seu sistema permitir.

Eu uso esse código para comparar 2 métodos. Meu sistema operacional é o Windows 8, processador Core 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

resultado:

time () = 0.0993799996376

clock () = 0.0993572257367

Resposta certa: ambos têm o mesmo comprimento de uma fração.

Mas qual mais rápido se subjecté time?

Um 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 sou um laboratório suíço, mas eu testei ..

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

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

time.clock()foi removido no Python 3.8 porque tinha um comportamento dependente da plataforma :

• No Unix , retorne o tempo atual do processador como um número de ponto flutuante expresso em segundos.

• No Windows , essa função retorna os segundos do relógio de parede decorridos desde a primeira chamada para essa função, como um número de ponto flutuante

  print(time.clock()); time.sleep(10); print(time.clock())
  # Linux  :  0.0382  0.0384   # see Processor Time
  # Windows: 26.1224 36.1566   # see Wall-Clock Time

Então, qual função escolher?

• Tempo do processador : é quanto tempo esse processo específico passa sendo executado ativamente na CPU. Dormir, aguardar uma solicitação da Web ou o horário em que apenas outros processos são executados não contribuirá para isso.

  • Usar time.process_time()

• Hora do relógio de parede : refere-se a quanto tempo passou "em um relógio pendurado na parede", ou seja, fora do tempo real.

  • Usar time.perf_counter()

    • time.time() também mede o tempo do relógio de parede, mas pode ser redefinido, para que você possa voltar no tempo
    • time.monotonic() não pode ser redefinido (monotônico = avança apenas), mas tem menor precisão do que time.perf_counter()

Comparando o resultado do teste entre o Ubuntu Linux e o Windows 7.

No Ubuntu

>>> start = time.time(); time.sleep(0.5); (time.time() - start)
0.5005500316619873

No Windows 7

>>> start = time.time(); time.sleep(0.5); (time.time() - start)
0.5