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




measure of (15)

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)

Answers

No Unix time.clock () mede a quantidade de tempo de CPU que foi usado pelo processo atual, portanto não é bom 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 ().


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.


Use o time.time () é o preferido.


A partir de 3.3, time.clock () está obsoleto e sugere-se usar time.process_time() ou time.perf_counter() .

Anteriormente em 2.7, de acordo com o módulo de horário docs :

Rélogio de ponto()

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 com o mesmo nome, mas em qualquer caso, essa é a função a ser usada para fazer benchmarking em 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 comparar os snippets de código.


Others responderam 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 módulo timeit .


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() , juntamente com outras 3 funções.

Estas 6 novas funções de resolução de nanosegundos 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 do Python.

Como outros já observaram, use o módulo timeit para funções de tempo e pequenos trechos de código.


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.


Para estender os resultados do @ Hill, aqui está um teste usando o python 3.4.3 no Xubuntu 16.04 através do wine:
(timeit.default_timer usará time.clock () porque ele vê o sistema operacional como 'win32')

ao usar o Windows, o clock () é geralmente mais preciso, mas este não é o caso do vinho ...
você pode ver aqui que time () é mais preciso que clock (), que normalmente é o caso do Linux e Mac.


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

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


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 o 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.

Normalmente, o 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, o tempo real)


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

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 a época, 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.


Para minha própria practice. time() 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

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


Index:
      ------------>
  0   1   2   3   4
+---+---+---+---+---+
| a | b | c | d | e |
+---+---+---+---+---+
  0  -4  -3  -2  -1
      <------------

Slice:
    <---------------|
|--------------->
:   1   2   3   4   :
+---+---+---+---+---+
| a | b | c | d | e |
+---+---+---+---+---+
:  -4  -3  -2  -1   :
|--------------->
    <---------------|

Espero que isso ajude você a modelar a lista em Python.

Referência: http://wiki.python.org/moin/MovingToPythonFromOtherLanguages





python time