¿Cómo puedo traducir una cadena de fecha y hora ISO 8601 en un objeto de fecha y hora de Python? [duplicar]

StackOverflow https://stackoverflow.com/questions/969285

Pregunta

    

Esta pregunta ya tiene una respuesta aquí:

         

Me estoy poniendo una cadena de fecha y hora en un formato como "2009-05-28T16: 15: 00" (esto es la norma ISO 8601, creo). Una opción hacker parece ser la de analizar la cadena usando time.strptime y pasando los primeros seis elementos de la tupla en el constructor de fecha y hora, así como: 

datetime.datetime(*time.strptime("2007-03-04T21:08:12", "%Y-%m-%dT%H:%M:%S")[:6])

No he sido capaz de encontrar una manera "más limpia" de hacer esto. ¿Hay una?

¿Fue útil?

Solución

Yo prefiero usar la biblioteca dateutil para la manipulación de zona horaria y generalmente sólida fecha de análisis. Si se va a obtener una cadena ISO 8601 como: 2010-05-08T23: 41: 54.000Z que tendría un momento de diversión que analizar con strptime, especialmente si usted no sabe por adelantado si es o no se incluyó la zona horaria. pyiso8601 tiene un par de cuestiones (comprobar su tracker) que me encontré con mi durante el uso y no se ha actualizado en unos pocos años. dateutil, por el contrario, ha estado activo y ha trabajado para mí: 

import dateutil.parser
yourdate = dateutil.parser.parse(datestring)

Otros consejos

Como Python 3.7 y no hay bibliotecas externas: 

datetime.datetime.strptime('2019-01-04T16:41:24+0200', "%Y-%m-%dT%H:%M:%S%z")

Python 2 no es compatible con el especificador de formato %z, por lo que es mejor utilizar explícitamente hora universal en todas partes, si es posible: 

datetime.datetime.strptime("2007-03-04T21:08:12Z", "%Y-%m-%dT%H:%M:%SZ")

Debido a ISO 8601 permite muchas variaciones de dos puntos opcionales y guiones estar presente, básicamente CCYY-MM-DDThh:mm:ss[Z|(+|-)hh:mm]. Si desea utilizar strptime, es necesario que se deben eliminar esas variaciones en primer lugar.

El objetivo es generar un objeto UTC fecha y hora.

Si lo que desea es un caso básico que funciona para UTC con el sufijo Z como 2016-06-29T19:36:29.3453Z: 

datetime.datetime.strptime(timestamp.translate(None, ':-'), "%Y%m%dT%H%M%S.%fZ")

Si desea gestionar las compensaciones de zona horaria como 2016-06-29T19:36:29.3453-0400 o 2008-09-03T20:56:35.450686+05:00 utilizar el siguiente. Estos se convertirán todas las variaciones en algo sin delimitadores variables como 20080903T205635.450686+0500 por lo que es más consistente / más fácil de analizar. 

import re
# This regex removes all colons and all
# dashes EXCEPT for the dash indicating + or - utc offset for the timezone
conformed_timestamp = re.sub(r"[:]|([-](?!((\d{2}[:]\d{2})|(\d{4}))$))", '', timestamp)
datetime.datetime.strptime(conformed_timestamp, "%Y%m%dT%H%M%S.%f%z" )

Si su sistema no soporta la directiva %z strptime (que se ve algo así como ValueError: 'z' is a bad directive in format '%Y%m%dT%H%M%S.%f%z'), entonces usted necesita para compensar manualmente el tiempo de Z (UTC). Nota %z puede no funcionar en su sistema en versiones Python <3, ya que dependía del soporte de la biblioteca C que varía a través de sistema / Python tipo de generación (es decir, Jython , Cython , etc.). 

import re
import datetime

# This regex removes all colons and all
# dashes EXCEPT for the dash indicating + or - utc offset for the timezone
conformed_timestamp = re.sub(r"[:]|([-](?!((\d{2}[:]\d{2})|(\d{4}))$))", '', timestamp)

# Split on the offset to remove it. Use a capture group to keep the delimiter
split_timestamp = re.split(r"[+|-]",conformed_timestamp)
main_timestamp = split_timestamp[0]
if len(split_timestamp) == 3:
    sign = split_timestamp[1]
    offset = split_timestamp[2]
else:
    sign = None
    offset = None

# Generate the datetime object without the offset at UTC time
output_datetime = datetime.datetime.strptime(main_timestamp +"Z", "%Y%m%dT%H%M%S.%fZ" )
if offset:
    # Create timedelta based on offset
    offset_delta = datetime.timedelta(hours=int(sign+offset[:-2]), minutes=int(sign+offset[-2:]))

    # Offset datetime with timedelta
    output_datetime = output_datetime + offset_delta

Flecha parece prometedor para esto: 

>>> import arrow
>>> arrow.get('2014-11-13T14:53:18.694072+00:00').datetime
datetime.datetime(2014, 11, 13, 14, 53, 18, 694072, tzinfo=tzoffset(None, 0))
  

Flecha es una biblioteca de Python que proporciona una manera sensata e inteligente de crear, manipular, el formato y la conversión de fechas y horas. Arrow es simple, ligero y fuertemente inspirado por moment.js y Pide .

Se debe mantener un ojo en la información de zona horaria, como se puede meter en problemas al comparar datetimes no TZ-conscientes con los TZ-conscientes.

Es probablemente el mejor para hacer siempre los tz-conscientes (aunque sólo sea como UTC), a menos que realmente sabe por qué no sería de ninguna utilidad para hacerlo. 

#-----------------------------------------------
import datetime
import pytz
import dateutil.parser
#-----------------------------------------------

utc = pytz.utc
BERLIN = pytz.timezone('Europe/Berlin')
#-----------------------------------------------

def to_iso8601(when=None, tz=BERLIN):
  if not when:
    when = datetime.datetime.now(tz)
  if not when.tzinfo:
    when = tz.localize(when)
  _when = when.strftime("%Y-%m-%dT%H:%M:%S.%f%z")
  return _when[:-8] + _when[-5:] # Remove microseconds
#-----------------------------------------------

def from_iso8601(when=None, tz=BERLIN):
  _when = dateutil.parser.parse(when)
  if not _when.tzinfo:
    _when = tz.localize(_when)
  return _when
#-----------------------------------------------

No he probado todavía, pero pyiso8601 promete apoyar esto.

ISODate parece tener el apoyo más completo.

Los dos maneras:

Epoch a tiempo ISO: 

isoTime = time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime(epochTime))

tiempo ISO a Epoch: 

epochTime = time.mktime(time.strptime(isoTime, '%Y-%m-%dT%H:%M:%SZ'))

import datetime, time
def convert_enddate_to_seconds(self, ts):
    """Takes ISO 8601 format(string) and converts into epoch time."""
    dt = datetime.datetime.strptime(ts[:-7],'%Y-%m-%dT%H:%M:%S.%f')+\
                datetime.timedelta(hours=int(ts[-5:-3]),
                minutes=int(ts[-2:]))*int(ts[-6:-5]+'1')
    seconds = time.mktime(dt.timetuple()) + dt.microsecond/1000000.0
    return seconds

Esto también incluye la zona de milisegundos y el tiempo.

Si el tiempo es '2012-09-30T15: 31: 50,262 a 08: 00'., Esto va a convertir en el tiempo época 

>>> import datetime, time
>>> ts = '2012-09-30T15:31:50.262-08:00'
>>> dt = datetime.datetime.strptime(ts[:-7],'%Y-%m-%dT%H:%M:%S.%f')+ datetime.timedelta(hours=int(ts[-5:-3]), minutes=int(ts[-2:]))*int(ts[-6:-5]+'1')
>>> seconds = time.mktime(dt.timetuple()) + dt.microsecond/1000000.0
>>> seconds
1348990310.26

aniso8601 debe manejar esto. También entiende zonas horarias, Python 2 y Python 3, y tiene una cobertura razonable del resto de ISO 8601 , si alguna vez lo necesita. 

import aniso8601
aniso8601.parse_datetime('2007-03-04T21:08:12')

Esta es una manera muy simple de hacer este tipo de conversiones. Sin análisis, o bibliotecas adicionales requeridos. Es limpio, sencillo y rápido. 

import datetime
import time

################################################
#
# Takes the time (in seconds),
#   and returns a string of the time in ISO8601 format.
# Note: Timezone is UTC
#
################################################

def TimeToISO8601(seconds):
   strKv = datetime.datetime.fromtimestamp(seconds).strftime('%Y-%m-%d')
   strKv = strKv + "T"
   strKv = strKv + datetime.datetime.fromtimestamp(seconds).strftime('%H:%M:%S')
   strKv = strKv +"Z"
   return strKv

################################################
#
# Takes a string of the time in ISO8601 format,
#   and returns the time (in seconds).
# Note: Timezone is UTC
#
################################################

def ISO8601ToTime(strISOTime):
   K1 = 0
   K2 = 9999999999
   K3 = 0
   counter = 0
   while counter < 95:
     K3 = (K1 + K2) / 2
     strK4 = TimeToISO8601(K3)
     if strK4 < strISOTime:
       K1 = K3
     if strK4 > strISOTime:
       K2 = K3
     counter = counter + 1
   return K3

################################################
#
# Takes a string of the time in ISO8601 (UTC) format,
#   and returns a python DateTime object.
# Note: returned value is your local time zone.
#
################################################

def ISO8601ToDateTime(strISOTime):
   return time.gmtime(ISO8601ToTime(strISOTime))


#To test:
Test = "2014-09-27T12:05:06.9876"
print ("The test value is: " + Test)
Ans = ISO8601ToTime(Test)
print ("The answer in seconds is: " + str(Ans))
print ("And a Python datetime object is: " + str(ISO8601ToDateTime(Test)))
Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top