Python Language
Datum und Uhrzeit

Bemerkungen

Parsen einer Zeichenfolge in ein Zeitzonenobjekt mit Zeitzone

Python 3.2+ unterstützt das %z Format, wenn eine Zeichenfolge in ein datetime Objekt datetime wird.

UTC-Offset in der Form +HHMM oder -HHMM (leere Zeichenfolge, wenn das Objekt nicht aktiv ist).

import datetime
dt = datetime.datetime.strptime("2016-04-15T08:27:18-0500", "%Y-%m-%dT%H:%M:%S%z")

Für andere Python-Versionen können Sie eine externe Bibliothek wie dateutil , wodurch das Analysieren einer Zeichenfolge mit Zeitzone in ein datetime Objekt schnell ist.

import dateutil.parser
dt = dateutil.parser.parse("2016-04-15T08:27:18-0500")

Die Variable dt ist jetzt ein datetime Objekt mit dem folgenden Wert:

datetime.datetime(2016, 4, 15, 8, 27, 18, tzinfo=tzoffset(None, -18000))

Einfache Datumsberechnung

Termine existieren nicht isoliert. Es ist üblich, dass Sie die Zeit zwischen den Datumsangaben oder das Datum für morgen bestimmen müssen. Dies kann mit timedelta Objekten erreicht werden

import datetime

today = datetime.date.today()
print('Today:', today)

yesterday = today - datetime.timedelta(days=1)
print('Yesterday:', yesterday)

tomorrow = today + datetime.timedelta(days=1)
print('Tomorrow:', tomorrow)

print('Time between tomorrow and yesterday:', tomorrow - yesterday)

Dies führt zu ähnlichen Ergebnissen:

Today: 2016-04-15
Yesterday: 2016-04-14
Tomorrow: 2016-04-16
Difference between tomorrow and yesterday: 2 days, 0:00:00

Grundlegende Verwendung von datetime-Objekten

Das datetime-Modul enthält drei Haupttypen von Objekten - date, time und datetime.

import datetime

# Date object
today = datetime.date.today()
new_year = datetime.date(2017, 01, 01) #datetime.date(2017, 1, 1)

# Time object
noon = datetime.time(12, 0, 0) #datetime.time(12, 0)

# Current datetime
now = datetime.datetime.now()

# Datetime object
millenium_turn = datetime.datetime(2000, 1, 1, 0, 0, 0) #datetime.datetime(2000, 1, 1, 0, 0)

Arithmetische Operationen für diese Objekte werden nur innerhalb desselben Datentyps unterstützt. Wenn Sie eine einfache Arithmetik mit Instanzen verschiedener Typen ausführen, wird ein TypeError-Wert erzeugt.

# subtraction of noon from today
noon-today
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for -: 'datetime.time' and 'datetime.date'
However, it is straightforward to convert between types.

# Do this instead
print('Time since the millenium at midnight: ',
      datetime.datetime(today.year, today.month, today.day) - millenium_turn)

# Or this
print('Time since the millenium at noon: ',
      datetime.datetime.combine(today, noon) - millenium_turn)

Iteriere über Termine

Manchmal möchten Sie einen Datumsbereich von einem Startdatum bis zu einem Enddatum durchlaufen. Sie können dies mit einer datetime Bibliothek und einem timedelta tun:

import datetime

# The size of each step in days
day_delta = datetime.timedelta(days=1)

start_date = datetime.date.today()
end_date = start_date + 7*day_delta

for i in range((end_date - start_date).days):
    print(start_date + i*day_delta)

Was produziert:

2016-07-21
2016-07-22
2016-07-23
2016-07-24
2016-07-25
2016-07-26
2016-07-27

Analysieren einer Zeichenfolge mit einem kurzen Zeitzonennamen in ein Zeitzonenobjekt mit Datum und Uhrzeit

Wenn Sie die dateutil Bibliothek wie im vorherigen Beispiel zum Analysieren von Zeitzonen mit Zeitzonen verwenden , ist es auch möglich, Zeitmarken mit einem angegebenen "kurzen" Zeitzonennamen zu parsen.

Für Datumsangaben, die mit kurzen Zeitzonennamen oder Abkürzungen formatiert sind, die im Allgemeinen mehrdeutig sind (z. B. CST, z. B. Central Standard Time, China Standard Time, Cuba Standard Time usw.) - weitere Informationen finden Sie hier , ist es erforderlich, eine Zuordnung zwischen der Abkürzung für die Zeitzone und dem tzinfo Objekt tzinfo .

from dateutil import tz
from dateutil.parser import parse

ET = tz.gettz('US/Eastern')
CT = tz.gettz('US/Central')
MT = tz.gettz('US/Mountain')
PT = tz.gettz('US/Pacific')

us_tzinfos = {'CST': CT, 'CDT': CT,
              'EST': ET, 'EDT': ET,
              'MST': MT, 'MDT': MT,
              'PST': PT, 'PDT': PT}

dt_est = parse('2014-01-02 04:00:00 EST', tzinfos=us_tzinfos)
dt_pst = parse('2016-03-11 16:00:00 PST', tzinfos=us_tzinfos)

Nach dem Ausführen dieses:

dt_est
# datetime.datetime(2014, 1, 2, 4, 0, tzinfo=tzfile('/usr/share/zoneinfo/US/Eastern'))
dt_pst
# datetime.datetime(2016, 3, 11, 16, 0, tzinfo=tzfile('/usr/share/zoneinfo/US/Pacific'))

Es ist erwähnenswert, dass bei Verwendung einer pytz Zeitzone mit dieser Methode diese nicht richtig lokalisiert wird:

from dateutil.parser import parse
import pytz

EST = pytz.timezone('America/New_York')
dt = parse('2014-02-03 09:17:00 EST', tzinfos={'EST': EST})

Dadurch wird einfach die pytz Zeitzone an die datetime angehängt:

dt.tzinfo # Will be in Local Mean Time!
# <DstTzInfo 'America/New_York' LMT-1 day, 19:04:00 STD>

Wenn Sie diese Methode verwenden, sollten Sie nach dem Parsen wahrscheinlich den naiven Teil der datetime neu localize :

dt_fixed = dt.tzinfo.localize(dt.replace(tzinfo=None))
dt_fixed.tzinfo # Now it's EST.
# <DstTzInfo 'America/New_York' EST-1 day, 19:00:00 STD>)

Zeitzonenbasierte Datenzeiten erstellen

Standardmäßig sind alle datetime Objekte nicht aktiv. Um sie tzinfo zu machen, müssen Sie ein tzinfo Objekt anhängen, das den UTC-Offset und die Zeitzonenabkürzung als Funktion von Datum und Uhrzeit bereitstellt.

Versetzte Zeitzonen korrigiert

Für Zeitzonen, die einen festen Versatz von UTC haben, stellt das Modul datetime in Python 3.2 und datetime die timezone bereit, eine konkrete Implementierung von tzinfo , die ein Zeit- timedelta und einen (optionalen) Namensparameter benötigt:

from datetime import datetime, timedelta, timezone
JST = timezone(timedelta(hours=+9))

dt = datetime(2015, 1, 1, 12, 0, 0, tzinfo=JST)
print(dt)
# 2015-01-01 12:00:00+09:00

print(dt.tzname())
# UTC+09:00

dt = datetime(2015, 1, 1, 12, 0, 0, tzinfo=timezone(timedelta(hours=9), 'JST'))
print(dt.tzname)
# 'JST'

Für Python-Versionen vor 3.2 ist es erforderlich, eine Drittanbieter-Bibliothek wie dateutil . dateutil stellt eine äquivalente Klasse, tzoffset , zur tzoffset , die (ab Version 2.5.3) Argumente der Form dateutil.tz.tzoffset(tzname, offset) , wobei der offset in Sekunden angegeben wird:

from datetime import datetime, timedelta
from dateutil import tz

JST = tz.tzoffset('JST', 9 * 3600) # 3600 seconds per hour
dt = datetime(2015, 1, 1, 12, 0, tzinfo=JST)
print(dt)
# 2015-01-01 12:00:00+09:00
print(dt.tzname)
# 'JST'

Zonen mit Sommerzeit

Für Zonen mit Sommerzeit stellen Python-Standardbibliotheken keine Standardklasse bereit. Daher ist die Verwendung einer Drittanbieter-Bibliothek erforderlich. pytz und dateutil sind beliebte Bibliotheken, die Zeitzonenklassen anbieten.

Neben statischen Zeitzonen bietet dateutil Zeitzonen-Klassen, die Sommerzeit verwenden (siehe Dokumentation zum tz Modul ). Mit der Methode tz.gettz() Sie ein Zeitzonenobjekt datetime , das direkt an den datetime Konstruktor übergeben werden kann:

from datetime import datetime
from dateutil import tz
local = tz.gettz() # Local time
PT = tz.gettz('US/Pacific') # Pacific time

dt_l = datetime(2015, 1, 1, 12, tzinfo=local) # I am in EST
dt_pst = datetime(2015, 1, 1, 12, tzinfo=PT)
dt_pdt = datetime(2015, 7, 1, 12, tzinfo=PT) # DST is handled automatically
print(dt_l)
# 2015-01-01 12:00:00-05:00
print(dt_pst)
# 2015-01-01 12:00:00-08:00
print(dt_pdt)
# 2015-07-01 12:00:00-07:00

VORSICHT : Seit Version 2.5.3 verarbeitet dateutil mehrdeutige Datumsangaben nicht korrekt und verwendet immer das spätere Datum. Es ist nicht möglich, ein Objekt mit einer dateutil Zeitzone zu dateutil , die beispielsweise 2015-11-01 1:30 EDT-4 , da dies während einer Sommerzeitumstellung erfolgt.

Bei Verwendung von pytz alle Kantenfälle ordnungsgemäß pytz . pytz Zeitzonen sollten jedoch nicht direkt durch den Konstruktor an Zeitzonen angehängt werden. Stattdessen sollte eine pytz Zeitzone mit der localize Methode der Zeitzone angefügt werden:

from datetime import datetime, timedelta
import pytz

PT = pytz.timezone('US/Pacific')
dt_pst = PT.localize(datetime(2015, 1, 1, 12))
dt_pdt = PT.localize(datetime(2015, 11, 1, 0, 30))
print(dt_pst)
# 2015-01-01 12:00:00-08:00
print(dt_pdt)
# 2015-11-01 00:30:00-07:00

Beachten Sie, dass Sie, wenn Sie eine Datums-Zeit-Arithmetik in einer pytz aware-Zeitzone durchführen, entweder die Berechnungen in UTC durchführen müssen (wenn Sie absolut abgelaufene Zeit wünschen) oder das Ergebnis mit normalize() aufrufen:

dt_new = dt_pdt + timedelta(hours=3) # This should be 2:30 AM PST
print(dt_new)
# 2015-11-01 03:30:00-07:00
dt_corrected = PT.normalize(dt_new)
print(dt_corrected)
# 2015-11-01 02:30:00-08:00

Fuzzy-Datetime-Analyse (Extrahieren von Datetime aus einem Text)

Es ist möglich, ein Datum aus einem Text mit dem dateutil Parser in einem "Fuzzy" -Modus zu extrahieren, wobei Komponenten der Zeichenfolge, die nicht als Teil eines Datums erkannt werden, ignoriert werden.

from dateutil.parser import parse

dt = parse("Today is January 1, 2047 at 8:21:00AM", fuzzy=True)
print(dt)

dt ist jetzt ein datetime Objekt, und datetime.datetime(2047, 1, 1, 8, 21) gedruckt.

Zwischen Zeitzonen wechseln

Um zwischen Zeitzonen zu wechseln, benötigen Sie datetime-Objekte, die Zeitzonen berücksichtigen.

from datetime import datetime
from dateutil import tz

utc = tz.tzutc()
local = tz.tzlocal()

utc_now = datetime.utcnow()
utc_now # Not timezone-aware.

utc_now = utc_now.replace(tzinfo=utc)
utc_now # Timezone-aware.

local_now = utc_now.astimezone(local)
local_now # Converted to local time.

Parsen eines beliebigen ISO 8601-Zeitstempels mit minimalen Bibliotheken

Python unterstützt die Analyse von Zeitstempeln nach ISO 8601 nur eingeschränkt. Für strptime Sie genau wissen, in welchem ​​Format es sich befindet. Als Komplikation ist die Stringifizierung einer datetime ein Zeitstempel nach ISO 8601 mit Leerzeichen als Trennzeichen und 6-stelligem Bruch:

str(datetime.datetime(2016, 7, 22, 9, 25, 59, 555555))
# '2016-07-22 09:25:59.555555'

Ist der Bruch 0, wird kein Bruchteil ausgegeben

str(datetime.datetime(2016, 7, 22, 9, 25, 59, 0))
# '2016-07-22 09:25:59'

Diese beiden Formulare benötigen jedoch ein anderes Format für die strptime . Darüber hinaus unterstützt strptime' does not support at all parsing minute timezones that have a Folgendes enthalten: in it, thus 2016-07-22 09: 25: 59 + 0300 can be parsed, but the standard format 2016-07-22 09:25:59 +03: 00` kann nicht.

Es gibt eine Einzeldateibibliothek namens iso8601 die nur Zeitstempel von ISO 8601 und nur sie richtig analysiert.

Es unterstützt Brüche und Zeitzonen und das T Trennzeichen mit einer einzigen Funktion:

import iso8601
iso8601.parse_date('2016-07-22 09:25:59')
# datetime.datetime(2016, 7, 22, 9, 25, 59, tzinfo=<iso8601.Utc>)
iso8601.parse_date('2016-07-22 09:25:59+03:00')
# datetime.datetime(2016, 7, 22, 9, 25, 59, tzinfo=<FixedOffset '+03:00' ...>)
iso8601.parse_date('2016-07-22 09:25:59Z')
# datetime.datetime(2016, 7, 22, 9, 25, 59, tzinfo=<iso8601.Utc>)
iso8601.parse_date('2016-07-22T09:25:59.000111+03:00')
# datetime.datetime(2016, 7, 22, 9, 25, 59, 111, tzinfo=<FixedOffset '+03:00' ...>)

Wenn keine Zeitzone eingestellt ist, wird der iso8601.parse_date auf UTC gesetzt. Die Standardzone kann mit default_zone Schlüsselwortargument default_zone geändert werden. Bemerkenswert ist , wenn dies None anstelle des Standard, dann werden diese Zeitstempel , die stattdessen als naive Datetimes keine explizite Zeitzone haben werden zurückgegeben:

iso8601.parse_date('2016-07-22T09:25:59', default_timezone=None)
# datetime.datetime(2016, 7, 22, 9, 25, 59)
iso8601.parse_date('2016-07-22T09:25:59Z', default_timezone=None)
# datetime.datetime(2016, 7, 22, 9, 25, 59, tzinfo=<iso8601.Utc>)

Zeitstempel in Datumszeit konvertieren

Das datetime Modul kann einen POSIX- timestamp in ein ITC- datetime Objekt datetime .

Die Epoche ist am 1. Januar 1970 um Mitternacht.

import time
from datetime import datetime
seconds_since_epoch=time.time()  #1469182681.709

utc_date=datetime.utcfromtimestamp(seconds_since_epoch) #datetime.datetime(2016, 7, 22, 10, 18, 1, 709000)

Monate genau von einem Datum abziehen

Verwenden des calendar

import calendar
from datetime import date

def monthdelta(date, delta):
    m, y = (date.month+delta) % 12, date.year + ((date.month)+delta-1) // 12
    if not m: m = 12
    d = min(date.day, calendar.monthrange(y, m)[1])
    return date.replace(day=d,month=m, year=y)

next_month = monthdelta(date.today(), 1) #datetime.date(2016, 10, 23)

Verwenden des dateutils Moduls

import datetime
import dateutil.relativedelta

d = datetime.datetime.strptime("2013-03-31", "%Y-%m-%d")
d2 = d - dateutil.relativedelta.relativedelta(months=1)  #datetime.datetime(2013, 2, 28, 0, 0)

Zeitunterschiede berechnen

Das timedelta Modul ist nützlich, um Unterschiede zwischen den Zeiten zu berechnen:

from datetime import datetime, timedelta
now = datetime.now()
then = datetime(2016, 5, 23)     # datetime.datetime(2016, 05, 23, 0, 0, 0)

Die Angabe der Uhrzeit ist optional, wenn ein neues datetime Objekt erstellt wird

delta = now-then

delta ist vom Typ timedelta

print(delta.days)
# 60
print(delta.seconds)
# 40826

Um einen Tag nach dem Tag und einen Tag vor dem Datum zu erhalten, könnten wir Folgendes verwenden:

n Tag nach dem Datum:

def get_n_days_after_date(date_format="%d %B %Y", add_days=120):

    date_n_days_after = datetime.datetime.now() + timedelta(days=add_days)
    return date_n_days_after.strftime(date_format)

n Tage vor dem Datum:

 def get_n_days_before_date(self, date_format="%d %B %Y", days_before=120):

        date_n_days_ago = datetime.datetime.now() - timedelta(days=days_before)
        return date_n_days_ago.strftime(date_format)

Erhalten Sie einen Zeitstempel nach ISO 8601

Ohne Zeitzone mit Mikrosekunden

from datetime import datetime

datetime.now().isoformat()
# Out: '2016-07-31T23:08:20.886783'

Mit Zeitzone, mit Mikrosekunden

from datetime import datetime
from dateutil.tz import tzlocal

datetime.now(tzlocal()).isoformat()
# Out: '2016-07-31T23:09:43.535074-07:00'

Mit Zeitzone, ohne Mikrosekunden

from datetime import datetime
from dateutil.tz import tzlocal

datetime.now(tzlocal()).replace(microsecond=0).isoformat()
# Out: '2016-07-31T23:10:30-07:00'

Siehe ISO 8601 für weitere Informationen über die ISO 8601 - Format.