Como faço para traduzir uma seqüência de data e hora ISO 8601 em um Python datetime objeto? [duplicado]

https://stackoverflow.com/questions/969285

13-09-2019
|

Pergunta

Esta questão já tem uma resposta aqui:

Como posso analisar uma data ISO 8601-formatado? 25 respostas

Estou recebendo uma seqüência de data e hora em um formato como "2009-05-28T16: 15: 00" (este é ISO 8601, eu acredito). Uma opção hackish parece ser a de analisar a cadeia utilizando time.strptime e passando os seis primeiros elementos da tupla para o construtor de data e hora, como:

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

Eu não tenho sido capaz de encontrar uma maneira mais "limpo" de fazer isso. Existe um?

Solução

Eu prefiro usar a biblioteca dateutil para manipulação fuso horário e, geralmente sólida data de análise. Se você fosse para obter uma seqüência ISO 8601 como: 2010-05-08T23: 41: 54.000Z você teria uma análise divertida tempo que, com strptime, especialmente se você não sabe de antemão se ou não o fuso horário foi incluído. pyiso8601 tem um par de questões (verificar seu rastreador) que eu tive durante a minha uso e não foi atualizado em poucos anos. dateutil, pelo contrário, tem sido ativa e funcionou para mim:

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

Outras dicas

Desde Python 3.7 e há bibliotecas externas:

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

Python 2 não suporta o especificador de formato %z, por isso é melhor usar explicitamente tempo Zulu em todos os lugares, se possível:

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

Como ISO 8601 permite muitas variações de dois pontos e traços opcionais estar presente, basicamente CCYY-MM-DDThh:mm:ss[Z|(+|-)hh:mm]. Se você quiser usar strptime, você precisa retirar essas variações em primeiro lugar.

O objetivo é gerar um UTC datetime objeto.

Se você quer apenas um caso básico que trabalho para UTC com o sufixo Z como 2016-06-29T19:36:29.3453Z:

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

Se você quiser lidar com deslocamentos de fuso horário como 2016-06-29T19:36:29.3453-0400 ou utilização 2008-09-03T20:56:35.450686+05:00 o seguinte. Estes irão converter todas as variações em algo sem delimitadores variáveis ??como 20080903T205635.450686+0500 tornando-se mais consistente / mais fácil de analisar.

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" )

Se o seu sistema não suporta a directiva %z strptime (você ver algo como ValueError: 'z' is a bad directive in format '%Y%m%dT%H%M%S.%f%z'), então você precisa para compensar manualmente a hora de Z (UTC). Nota %z pode não funcionar no seu sistema em versões Python <3, uma vez que dependia do apoio de biblioteca C que varia entre sistema / Python tipo de compilação (ou seja, 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

Seta parece promissor para isso:

>>> 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))

Arrow é uma biblioteca Python que fornece uma maneira sensata e inteligente de criar, manipular, formatação e as datas e horários de conversão. Seta é simples, leve e fortemente inspirado por moment.js e solicitações .

Você deve manter um olho sobre a informação de fuso horário, como você pode entrar em apuros quando se comparam datetimes-não-tz conscientes com os tz-aware.

É provavelmente o melhor para sempre torná-los tz-aware (mesmo que apenas como UTC), a menos que você realmente sabe por que ele não seria de qualquer utilidade para fazê-lo.

#-----------------------------------------------
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
#-----------------------------------------------

Eu não tentei ainda, mas pyiso8601 promessas para suportar isto.

ISODate parece ter o mais completo suporte.

As duas maneiras:

Epoch em tempos ISO:

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

tempo ISO para 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

Isto também inclui a zona de milissegundos e tempo.

Se o tempo é '2012-09-30T15: 31: 50,262-08: 00'., Este irá converter em tempo de é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 deve lidar com isso. Ele também entende fusos horários, Python 2 e Python 3, e tem uma cobertura razoável do resto ISO 8601 , se você precisar dele.

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

Aqui está uma maneira super simples de fazer este tipo de conversões. Nenhuma análise ou bibliotecas extra necessária. Ele é limpo, simples e 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 em: CC-BY-SA com atribuição

Não afiliado a StackOverflow