Eu tenho um datetime
objeto Python que desejo converter em tempo unix ou segundos / milissegundos desde a época de 1970.
Como eu faço isso?
$ python -c 'import time; print(time.time())'
que deu:1584487455.698623
Eu tenho um datetime
objeto Python que desejo converter em tempo unix ou segundos / milissegundos desde a época de 1970.
Como eu faço isso?
$ python -c 'import time; print(time.time())'
que deu:1584487455.698623
Respostas:
Parece-me que a maneira mais simples de fazer isso é
import datetime
epoch = datetime.datetime.utcfromtimestamp(0)
def unix_time_millis(dt):
return (dt - epoch).total_seconds() * 1000.0
%s
é dependente do SO! Portanto, qualquer pessoa deseja que o código funcione de forma confiável, independentemente de qual SO, NUNCA deve usar %s
. Para 2,3 <py ver <2,7. Um pode simplesmente construir um total_seconds()
como este:delta.days*86400+delta.seconds+delta.microseconds/1e6
dt
deve estar no UTC (não local). Veja resposta semelhante com o suporte ao Python 2.6 / 3
utcfromtimestamp(0)
pode causar apenas se 'tz' 'tz' compensar não é 0. Isso ocorre porque dt
no dt- epoch
tem 'tz' calculado nele onde, como época é UTC tempo. A melhor maneira de calcular a época é epoch = datetime.datetime(1970, 1, 1)
onde o fuso horário está em consideração.
datetime.utcfromtimestamp(0)
retornar um datetime sem tzinfo? Está bem ali no nome do método, utc fromtimestamp. Para torná-lo não ingênuo, tenho que fazer algo parecido datetime.utcfromtimestamp(0).replace(tzinfo=pytz.UTC)
. Isto é necessário se dt
é fuso horário consciente ou então você vai terTypeError: can't subtract offset-naive and offset-aware datetimes
No Python 3.3, foi adicionado um novo método timestamp
:
import datetime
seconds_since_epoch = datetime.datetime.now().timestamp()
Sua pergunta afirmou que você precisava de milissegundos, que você pode obter assim:
milliseconds_since_epoch = datetime.datetime.now().timestamp() * 1000
Se você usar timestamp
um objeto de data e hora ingênuo, será assumido que ele está no fuso horário local. Use objetos de data e hora com reconhecimento de fuso horário se não for o que você pretende que isso aconteça.
.timestamp()
método supõe que um horário de entrada de entrada ingênuo esteja no fuso horário local (e o horário local pode ser ambíguo). Se ele estiver em UTC, em seguida, usar dt.replace(tzinfo=timezone.utc).timestamp()
vez .
datetime.datetime.timestamp(datetime.datetime.now())
datetime.datetime.now(pytz.timezone('Europe/Paris')).timestamp() == datetime.datetime.now(pytz.utc).timestamp() == datetime.datetime.utcnow().timestamp()
mas não (sempre) igual datetime.datetime.now().timestamp()
(somente este último é igual ao resto, se o tz local é UTC ...)
fromtimestamp
( docs.python.org/3/library/… )
>>> import datetime
>>> # replace datetime.datetime.now() with your datetime object
>>> int(datetime.datetime.now().strftime("%s")) * 1000
1312908481000
Ou a ajuda do módulo de hora (e sem formatação de data):
>>> import datetime, time
>>> # replace datetime.datetime.now() with your datetime object
>>> time.mktime(datetime.datetime.now().timetuple()) * 1000
1312908681000.0
Respondida com ajuda de: http://pleac.sourceforge.net/pleac_python/datesandtimes.html
Documentação:
.timetuple()
retorna tm_isdst=-1
força mktime()
a adivinhar. Pode adivinhar errado durante o horário de verão (50% de chance de erro +/- hora). Ambos '% s' e mktime()
podem usar o deslocamento incorreto do utc para datas do passado. Você precisa de um fuso horário histórica db, como fornecido pelo pytz
módulo para converter de forma confiável hora local para POSIX timestamp (a menos OS já provê um db)
time.mktime(ts.timetuple())
onde ts é de python datetime objeto
mktime/timetuple
. Também timetuple()
retira frações de segundo e o objetivo da pergunta é obter o registro de data e hora com precisão de milissegundos.
Você pode usar o Delorean para viajar no espaço e no tempo!
import datetime
import delorean
dt = datetime.datetime.utcnow()
delorean.Delorean(dt, timezone="UTC").epoch
É assim que eu faço:
from datetime import datetime
from time import mktime
dt = datetime.now()
sec_since_epoch = mktime(dt.timetuple()) + dt.microsecond/1000000.0
millis_since_epoch = sec_since_epoch * 1000
Recomendações dos documentos do Python 2.7 para otime
módulo
time
módulo, mas o OP perguntou sobre o datetime
módulo. FWIW, a época atual mais simples éint(time.time())
from datetime import datetime
from calendar import timegm
# Note: if you pass in a naive dttm object it's assumed to already be in UTC
def unix_time(dttm=None):
if dttm is None:
dttm = datetime.utcnow()
return timegm(dttm.utctimetuple())
print "Unix time now: %d" % unix_time()
print "Unix timestamp from an existing dttm: %d" % unix_time(datetime(2014, 12, 30, 12, 0))
timegm()
funciona apenas com utc time. Ele não usa, tm_isdst
portanto, você poderia usar em utcnow.timetuple()
vez de utcnow.utctimetuple()
. Nota: o uso naive_local_datetime.utctimetuple()
estaria errado aqui. Não traduz a hora local para utc. timetuple()
Chame também tiras de frações de segundo do resultado (se isso depende ou não da aplicação). Também a pergunta é sobre * milli * segundos, não segundos
utctimetuple()
retira frações de segundo. Multiplicar por 1000
não os recuperará.
>>> import datetime
>>> import time
>>> import calendar
>>> #your datetime object
>>> now = datetime.datetime.now()
>>> now
datetime.datetime(2013, 3, 19, 13, 0, 9, 351812)
>>> #use datetime module's timetuple method to get a `time.struct_time` object.[1]
>>> tt = datetime.datetime.timetuple(now)
>>> tt
time.struct_time(tm_year=2013, tm_mon=3, tm_mday=19, tm_hour=13, tm_min=0, tm_sec=9, tm_wday=1, tm_yday=78, tm_isdst=-1)
>>> #If your datetime object is in utc you do this way. [2](see the first table on docs)
>>> sec_epoch_utc = calendar.timegm(tt) * 1000
>>> sec_epoch_utc
1363698009
>>> #If your datetime object is in local timeformat you do this way
>>> sec_epoch_loc = time.mktime(tt) * 1000
>>> sec_epoch_loc
1363678209.0
[1] http://docs.python.org/2/library/datetime.html#datetime.date.timetuple
Aqui está outra forma de solução com a normalização do seu objeto de tempo:
def to_unix_time(timestamp):
epoch = datetime.datetime.utcfromtimestamp(0) # start of epoch time
my_time = datetime.datetime.strptime(timestamp, "%Y/%m/%d %H:%M:%S.%f") # plugin your time object
delta = my_time - epoch
return delta.total_seconds() * 1000.0
import time
seconds_since_epoch = time.mktime(your_datetime.timetuple()) * 1000
* 1000
, no entanto, você obtémseconds_since_epoch
. Promovendo esta resposta porque não me importo com milissegundos no momento.
Aqui está uma função que eu fiz com base na resposta acima
def getDateToEpoch(myDateTime):
res = (datetime.datetime(myDateTime.year,myDateTime.month,myDateTime.day,myDateTime.hour,myDateTime.minute,myDateTime.second) - datetime.datetime(1970,1,1)).total_seconds()
return res
Você pode agrupar o valor retornado assim: str (int (res)) Para retorná-lo sem um valor decimal para ser usado como string ou apenas int (sem o str)
Esta outra solução para datetime secreto para unixtimestampmillis.
private static readonly DateTime UnixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
public static long GetCurrentUnixTimestampMillis()
{
DateTime localDateTime, univDateTime;
localDateTime = DateTime.Now;
univDateTime = localDateTime.ToUniversalTime();
return (long)(univDateTime - UnixEpoch).TotalMilliseconds;
}