Wie zu analysieren, Termine mit Zeitzone -0400 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 fields | 2009-07-09

102

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 beantwortet, dateutil2.0 geschrieben für Python 3.0 und funktioniert nicht mit Python 2.x. Für Python 2.x dateutil1.5 verwendet werden muss.

Dies funktioniert nicht dateutil version 2.0 auf Python 2.6
Dies funktioniert gut für mich (dateutil 2.1) mit Python 2.7.2; Python 3 ist nicht erforderlich. Beachten Sie, dass wenn Sie die Installation von pip, der name des Pakets ist python-dateutil.

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

Dies bewirkt, dass ein ValueError: 'z' is a bad directive in format '%Y-%m-%d %M:%H:%S.%f %z' in meinem Fall (Python 2.7).
es soll nicht die Arbeit auf Python 2.7-Look ganz oben die Antwort.
seltsam übrigens, dass das überhaupt NICHT erwähnt, auf Python 2.7 docs: docs.python.org/2.7/library/...

InformationsquelleAutor jfs

20

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 GMT, die es erlauben würde, Datumsberechnungen, ohne sich Gedanken über Zeitzonen.

Ich mag das, wenn Sie Sie brauchen, um 'Sekunden' , 'Minuten='.
danke @Dave, es behoben
das entspricht GMT... wenn es das ist, was Sie wirklich wollen...
Nur als Anmerkung, wenn Sie wollte eine Zeitzone in einen string konvertieren und die datetime in UTC, würde die gegenüber der Logik hier aufgelistet. Wenn die Zeitzone +, subtrahieren Sie die timedelta-und Umgekehrt.
Die Umwandlung der UTC-war falsch, wenn es eine + Charakter der timedelta sollte abgezogen, und Umgekehrt. Ich habe editiert und korrigiert den code.

InformationsquelleAutor 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 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 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" 🙂

Ich glaube nicht, dass es gut ist zu nennen, ein externes programm für diese. Und der nächste Schwachpunkt: eval(): Falls man jetzt, dass ein webserver führt diesen code, die Sie tun könnten die Ausführung von beliebigem code auf dem server!!!
Es hängt alles vom Kontext ab: wenn das, was wir suchen, ist nur eine schreiben-und-Wegwerf-Skript, dann werden diese Schwachstellen sind nur irrelevant 🙂
Down-voting das, weil: 1) Es macht einen system-Aufruf für etwas trivial, 2) Es injiziert strings direkt in einer shell aufrufen, 3) Aufrufe von eval(), und 4) Es hat eine Ausnahme catch-all. Im Grunde ist dies ein Beispiel, wie nicht, Dinge zu tun.
vereinbarten @benjaoming!
Gut, wieder, dieses "eval is evil" - motto hängt wirklich davon ab, Ihren Kontext (die nicht bereits von der OP). Wenn ich Skripte schreiben, die für meinen eigenen Gebrauch, ich benutze eval liberal, und es ist genial. Python ist eine tolle Sprache für Klebstoff-Skripte ! Natürlich können Sie roll-out gewundenen general-case-over-engineered-Lösungen wie in einigen Antworten oben, und dann behaupten, es ist-der-einzige-richtige-Weg-zu-tun-ist es, ala Java. Aber für viele Anwendungsfälle eine quick-and-dirty-Lösung ist nur so gut.

InformationsquelleAutor Gyom

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.