Wie analysiert man Daten mit -0400 Zeitzonen-String in Python?

Ich habe ein Datum-string der form '2009/05/13 19:19:30 -0400'. Es scheint, dass die früheren Versionen von Python, kann unterstützen Sie %z-format-tag in der strptime für die nachfolgende Zeitzone Spezifikation, aber 2.6.x scheint entfernt zu haben.

Was ist die richtige Art und Weise zu analysieren, diesen string in ein datetime-Objekt?

InformationsquelleAutor der Frage fields | 2009-07-09

98

Können Sie mithilfe der parse-Funktion von dateutil:
```
>>> from dateutil.parser import parse
>>> d = parse('2009/05/13 19:19:30 -0400')
>>> d
datetime.datetime(2009, 5, 13, 19, 19, 30, tzinfo=tzoffset(None, -14400))
```
Diese Weise erhalten Sie ein datetime-Objekt, das Sie dann verwenden können.

Als beantwortetdateutil2.0 geschrieben für Python 3.0 und funktioniert nicht mit Python 2.x. Für Python 2.x dateutil1.5 verwendet werden muss.

InformationsquelleAutor der Antwort txwikinger

%z unterstützt in Python 3.2+:

>>> from datetime import datetime
>>> datetime.strptime('2009/05/13 19:19:30 -0400', '%Y/%m/%d %H:%M:%S %z')
datetime.datetime(2009, 5, 13, 19, 19, 30,
                  tzinfo=datetime.timezone(datetime.timedelta(-1, 72000)))

Auf früheren Versionen:

from datetime import datetime

date_str = '2009/05/13 19:19:30 -0400'
naive_date_str, _, offset_str = date_str.rpartition(' ')
naive_dt = datetime.strptime(naive_date_str, '%Y/%m/%d %H:%M:%S')
offset = int(offset_str[-4:-2])*60 + int(offset_str[-2:])
if offset_str[0] == "-":
   offset = -offset
dt = naive_dt.replace(tzinfo=FixedOffset(offset))
print(repr(dt))
# -> datetime.datetime(2009, 5, 13, 19, 19, 30, tzinfo=FixedOffset(-240))
print(dt)
# -> 2009-05-13 19:19:30-04:00

wo FixedOffset ist eine Klasse basierend auf das code Beispiel aus den docs:

from datetime import timedelta, tzinfo

class FixedOffset(tzinfo):
    """Fixed offset in minutes: `time = utc_time + utc_offset`."""
    def __init__(self, offset):
        self.__offset = timedelta(minutes=offset)
        hours, minutes = divmod(offset, 60)
        #NOTE: the last part is to remind about deprecated POSIX GMT+h timezones
        #  that have the opposite sign in the name;
        #  the corresponding numeric value is not used e.g., no minutes
        self.__name = '<%+03d%02d>%+d' % (hours, minutes, -hours)
    def utcoffset(self, dt=None):
        return self.__offset
    def tzname(self, dt=None):
        return self.__name
    def dst(self, dt=None):
        return timedelta(0)
    def __repr__(self):
        return 'FixedOffset(%d)' % (self.utcoffset().total_seconds() / 60)

InformationsquelleAutor der Antwort jfs

Hier ist ein fix der "%z" Problem für Python 2.7 und früheren

Anstelle von:

datetime.strptime(t,'%Y-%m-%dT%H:%M %z')

Verwenden Sie die timedelta zu berücksichtigen, für die Zeitzone, wie diese:

from datetime import datetime,timedelta
def dt_parse(t):
    ret = datetime.strptime(t[0:16],'%Y-%m-%dT%H:%M')
    if t[18]=='+':
        ret-=timedelta(hours=int(t[19:22]),minutes=int(t[23:]))
    elif t[18]=='-':
        ret+=timedelta(hours=int(t[19:22]),minutes=int(t[23:]))
    return ret

Beachten Sie, dass die Daten umgewandelt werden würde, um GMTdie es erlauben würde, Datumsberechnungen, ohne sich Gedanken über Zeitzonen.

InformationsquelleAutor der Antwort Uri Goren

Das problem bei der Verwendung dateutil ist, dass Sie können nicht die gleichen format-string für die Serialisierung und Deserialisierung, wie dateutil hat eine begrenzte Formatierung Optionen (nur dayfirst und yearfirst).

In meiner Anwendung speichern, das format string .INI-Datei, und jede Implementierung kann ein eigenes format. Also, ich weiß wirklich nicht, wie die dateutil-Ansatz.

Hier ist eine alternative Methode, die verwendet pytz statt:

from datetime import datetime, timedelta

from pytz import timezone, utc
from pytz.tzinfo import StaticTzInfo

class OffsetTime(StaticTzInfo):
    def __init__(self, offset):
        """A dumb timezone based on offset such as +0530, -0600, etc.
        """
        hours = int(offset[:3])
        minutes = int(offset[0] + offset[3:])
        self._utcoffset = timedelta(hours=hours, minutes=minutes)

def load_datetime(value, format):
    if format.endswith('%z'):
        format = format[:-2]
        offset = value[-5:]
        value = value[:-5]
        return OffsetTime(offset).localize(datetime.strptime(value, format))

    return datetime.strptime(value, format)

def dump_datetime(value, format):
    return value.strftime(format)

value = '2009/05/13 19:19:30 -0400'
format = '%Y/%m/%d %H:%M:%S %z'

assert dump_datetime(load_datetime(value, format), format) == value
assert datetime(2009, 5, 13, 23, 19, 30, tzinfo=utc) \
    .astimezone(timezone('US/Eastern')) == load_datetime(value, format)

InformationsquelleAutor der Antwort sayap

1

One-liner für die alten Pythons gibt. Sie können multiplizieren eine timedelta durch 1/-1, je nach Vorzeichen, in:
```
datetime.strptime(s[:19], '%Y-%m-%dT%H:%M:%S') + timedelta(hours=int(s[20:22]), minutes=int(s[23:])) * (-1 if s[19] == '+' else 1)
```
InformationsquelleAutor der Antwort Eric Sellin

-9

Wenn Sie auf Linux sind, dann können Sie das externe date Befehl dwim:

import commands, datetime

def parsedate(text):
  output=commands.getoutput('date -d "%s" +%%s' % text )
  try:
      stamp=eval(output)
  except:
      print output
      raise
  return datetime.datetime.frometimestamp(stamp)

Dies ist natürlich weniger tragbar als dateutil ist, aber etwas flexibler, da date akzeptiert auch Eingaben wie "gestern" oder "letztes Jahr" 🙂

InformationsquelleAutor der Antwort Gyom

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.