Obter tempo atual em milissegundos em Python?

Como posso obter o horário atual em milissegundos em Python?

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

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) 

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.

Apenas código de exemplo:

import time
timestamp = int(time.time()*1000.0)

Saída: 1534343781311

Outra solução é a função que você pode incorporar nos seus próprios utils.py

import time as time_ #make sure we don't override time
def millis():
    return int(round(time_.time() * 1000))

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

A maneira mais simples de encontrar a hora atual do UTC em milissegundos é:

# timeutil.py
import datetime


def get_epochtime_ms():
    return round(datetime.datetime.utcnow().timestamp() * 1000)

# sample.py
import timeutil


timeutil.get_epochtime_ms()

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

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.

Apenas outra solução usando o datetimemódulo para Python 3.

datetime.datetime.timestamp(datetime.datetime.now())