Como posso obter o horário atual em milissegundos em Python?
time.time()
pode fornecer uma precisão pior do que datetime.utcnow()
em algumas plataformas e versões python.
Como posso obter o horário atual em milissegundos em Python?
time.time()
pode fornecer uma precisão pior do que datetime.utcnow()
em algumas plataformas e versões python.
Respostas:
Para o que eu precisava, aqui está o que eu fiz, com base no comentário de @samplebias acima:
import time
millis = int(round(time.time() * 1000))
print millis
Rápido e fácil. Obrigado a todos, desculpe pelo peido do cérebro.
Para reutilização:
import time
current_milli_time = lambda: int(round(time.time() * 1000))
Então:
>>> current_milli_time()
1378761833768
round
? Parece que int(time.time() * 1000)
é o suficiente?
.utcnow()
usa GetSystemTimeAsFileTime()
no CPython recente no Windows . Não iria time.clock()
ligar para ( QueryPerformanceCounter()
) introduzir mais ruído do que poderia reduzir? Ver Precisão não é o mesmo que precisão .
time.time()
pode apenas dar resolução ao segundo, a abordagem preferida por milissegundos é datetime
.
from datetime import datetime
dt = datetime.now()
dt.microsecond
def TimestampMillisec64():
return int((datetime.datetime.utcnow() - datetime.datetime(1970, 1, 1)).total_seconds() * 1000)
.total_seconds()
produzir (possivelmente) melhor precisão: (td.microseconds + (td.seconds + td.days * 86400) * 10**6) / 10**3
(com a divisão verdadeira ativada) Ou, se desejar truncar os milissegundos, use // 10**3
.
A partir da versão 3.7, você pode usar time.time_ns()
para obter tempo como nano segundos passados da época. Então você pode fazer
ms = time.time_ns() // 1000000
para obter tempo em mili-segundos como inteiro.
Se você deseja um método simples no seu código que retorne os milissegundos com data e hora:
from datetime import datetime
from datetime import timedelta
start_time = datetime.now()
# returns the elapsed milliseconds since the start of the program
def millis():
dt = datetime.now() - start_time
ms = (dt.days * 24 * 60 * 60 + dt.seconds) * 1000 + dt.microseconds / 1000.0
return ms
start_time
= datetime (1970,1,1)
.utcnow()
vez disso ou se você não precisar do tempo absoluto, poderá usá-lo time.monotonous()
. Nota: há uma diferença sutil devido à aritmética de ponto flutuante entre some_int + dt.microseconds/ 1000.0
e a fórmula ( ) / 10**3
com a divisão verdadeira ativada. Veja a fórmula explícita e o link para total_seconds()
na resposta relacionada
Se você estiver preocupado em medir o tempo decorrido, use o relógio monotônico (python 3) . Esse relógio não é afetado pelas atualizações do relógio do sistema, como você veria se uma consulta NTP ajustasse a hora do sistema, por exemplo.
>>> import time
>>> millis = round(time.monotonic() * 1000)
Ele fornece um tempo de referência em segundos que pode ser usado para comparar posteriormente para medir o tempo decorrido.
Se você usar meu código (abaixo), o tempo aparecerá em segundos e, depois de um decimal, milissegundos. Eu acho que existe uma diferença entre o Windows e o Unix - por favor, comente se houver.
from time import time
x = time()
print(x)
meu resultado (no Windows) foi:
1576095264.2682993
EDIT : Não há diferença :) Obrigado tc0nn
/usr/local/opt/python/bin/python3.7 scratch.py 1577212639.882543
python3 scratch.py 1577212763.9136133
Essas multiplicações para 1.000 por milissegundos podem ser decentes para resolver ou tornar aceitável algum pré-requisito. Pode ser usado para preencher uma lacuna no seu banco de dados que realmente nunca o utiliza. Embora, para situações reais que exijam um timing preciso, acabaria por falhar. Eu não sugeriria que alguém usasse esse método para operações de missão crítica que exigem ações ou processamento em horários específicos.
Por exemplo: pings de ida e volta sendo de 30 a 80ms nos EUA ... Você não pode simplesmente arredondar isso e usá-lo com eficiência.
Meu próprio exemplo requer tarefas a cada segundo, o que significa que, se eu arredondar para cima após a resposta das primeiras tarefas, ainda incorrerei no tempo de processamento multiplicado a cada ciclo do loop principal. Isso acabou sendo uma chamada de função total a cada 60 segundos. isso é ~ 1440 por dia .. não é muito preciso.
Apenas um pensamento para as pessoas que procuram um raciocínio mais preciso, além de solucionar uma lacuna no banco de dados que nunca a utiliza de verdade.
import time; ms = time.time()*1000.0