from - python datetime to timestamp

datetime to Unix marca de tiempo con milisegundos de precisión

Question

Estoy tratando de hacer algo realmente simple, convertir un objeto de datetime y datetime tres días en el futuro en una marca de tiempo UTC de Unix:

import datetime, time
then = datetime.datetime.now() + datetime.timedelta(days=3)
# Method 1
print then.strftime("%s")
# Method 2
print time.mktime(then.timetuple())
# Method 3 
print time.mktime(then.timetuple()) * 1000

Los métodos 1 y 2 me dan el tiempo de Unix en segundos , no milisegundos, y el método 3 me da milisegundos sin una precisión real de milisegundos.

Cuando simplemente imprimo, obtengo datetime.datetime(2011, 11, 19, 15, 16, 8, 278271) , así que sé que la precisión está disponible por milisegundos. ¿Cómo puedo obtener una marca de tiempo Unix con una precisión real de milisegundos? Si se devuelve como flotador y tengo que aplanarlo a un int , eso está bien. ¿Hay una solución que estoy buscando que haga esto?

Answer 1

El día es siempre 86400 segundos en el tiempo POSIX. Para obtener la marca de tiempo POSIX 3 días en el futuro como un flotador (con fracción de segundo):

import time

DAY = 86400 # seconds
future = time.time() + 3 * DAY

Se supone que time.gmtime(0) es 1970 (POSIX Época).

Si ya tiene un objeto de fecha y hora ingenuo que representa la hora en la zona horaria local, entonces la marca de hora puede ser ambigua durante las transiciones DST. Para evitar la ambigüedad, puede utilizar un objeto de fecha y hora que tenga en cuenta la zona horaria o un objeto de fecha y hora ingenuo que represente la hora en UTC.

Para convertir un dt fecha local a segundos desde la Época:

from datetime import datetime
from time import mktime

timestamp = dt.timestamp() # Python 3.3+
timestamp = mktime(dt.timetuple()) + dt.microsecond / 1e6 # Python 2.7

Puede fallar si la zona horaria local tenía un desplazamiento utc diferente en el pasado y la implementación de la time no tiene acceso a la base de datos de zona horaria en el sistema. Usa pytz para manejar tales casos.

Para convertir UTC datetime utc_dt a POSIX timestamp:

timestamp = (utc_dt - datetime(1970, 1, 1)).total_seconds()

Para obtener milisegundos, simplemente multiplique el número de segundos flotantes por 1e3.

Answer 2

En Python 3.3 y superior, que admiten el método datetime.timestamp() , puedes hacer esto:

from datetime import datetime, timezone, timedelta

(datetime.now(timezone.utc) + timedelta(days=3)).timestamp() * 1e3

Answer 3

Los objetos de fecha y hora tienen un campo llamado microsecond . Así que una forma de lograr lo que necesitas es:

time.mktime(then.timetuple())*1e3 + then.microsecond/1e3

Esto devuelve milisegundos desde la época de UNIX con la precisión requerida.

Answer 4

Si está usando Python 2.7 o 3.2+, puede usar timedelta.total_seconds() para obtener esto con bastante facilidad:

import datetime, time
print time.time() + datetime.timedelta(days=3).total_seconds()

Answer 5

Si se adhiere a los tiempos de datos en UTC, puede continuar con esa abstracción y aprovechar timedelta:

from datetime import datetime, timedelta

epoch = datetime.utcfromtimestamp(0)

def dt_from_ms(ms):
    return datetime.utcfromtimestamp(ms / 1000.0)

def dt_to_ms(dt):
    delta = dt - epoch
    return int(delta.total_seconds() * 1000)

entonces:

now = datetime.utcnow()
now
-> datetime.datetime(2017, 1, 25, 1, 30, 42, 765846)  # note microsecond precision

dt_to_ms(now)
-> 1485307842765

dt_from_ms(1485307842765)
-> datetime.datetime(2017, 1, 25, 1, 30, 42, 765000)  # note millisecond precision

then = now + timedelta(days=3)
dt_to_ms(then)
-> 1485567042765

(1485567042765 - 1485307842765) / (24*60*60*1000.0)
-> 3.0

Answer 6

long((time.time() + 0.5) * 1000)

Esto tiene milisegundos de precisión.