Python timedelta: Arbeiten mit Zeitintervallen in Python

Viele reale Datensätze enthalten Datums- und Zeitangaben, und eine gängige Operation in der Datenwissenschaft ist die Berechnung der Zeitdifferenz zwischen zwei Zeitpunkten.

Die Einheiten, die wir zur Messung von Daten und Zeiten verwenden (Jahre, Monate, Tage, Stunden, Minuten, Sekunden), sind nicht ganz einfach zu handhaben, vor allem wenn diese Einheiten unregelmäßige Längen haben.

Der Datentyp timedelta von Python, der Teil des Moduls datetime ist, kümmert sich jedoch um die Komplexität der Berechnung von Zeitintervallen.

Beginnen wir mit einer kurzen Antwort auf die Frage, was Pythons timedelta ist und fahren dann mit weiteren Details fort.

Wenn du mehr über Datums- und Zeitangaben in Python erfahren möchtest, schau dir diesen Kurs über das Arbeiten mit Datums- und Zeitangaben in Python an.

Kurze Antwort: Was ist das Timedelta von Python?

Die beiden wichtigsten und am häufigsten verwendeten Datentypen aus dem Modul datetime sind timedelta und datetime. Während datetime Objekte bestimmte Zeitpunkte darstellen (z. B. den 1. Januar 2024 um 10:30 Uhr), repräsentieren timedelta Objekte Zeiträume oder Intervalle zwischen zwei Punkten. Betrachte es als den Unterschied zwischen der Frage "Wann?" (datetime) und "Wie lange?" (timedelta).

Betrachte zwei Daten, die wir mit zwei datetime Objekten darstellen können. Wenn du ein Datum von einem anderen subtrahierst, entsteht ein timedelta Objekt, das das Zeitintervall zwischen den beiden Daten darstellt:

import datetime

first_date = datetime.datetime(year=2024, month=1, day=1)
second_date = datetime.datetime(year=2024, month=5, day=27)
interval = second_date - first_date
print(interval)Bereitgestellt von

147 days, 0:00:00Bereitgestellt von

Die Ausgabe zeigt, dass die beiden Daten genau 147 Tage auseinander liegen. Im folgenden Beispiel verwenden wir das Datum und die Uhrzeit, wenn der Code ausgeführt wird, indem wir datetime.datetime.now() aufrufen:

first_date = datetime.datetime(year=2024, month=1, day=1)
second_date = datetime.datetime.now()
interval = second_date - first_date

print(second_date)
print(interval)Bereitgestellt von

2024-05-28 08:32:44.871646
148 days, 8:32:44.871646Bereitgestellt von

Das Objekt timedelta zeigt nun die Zeit an, die zwischen dem Beginn des Jahres 2024 und dem Datum und der Uhrzeit der Ausführung des Codes verstrichen ist.

In diesem Artikel werden wir Pythons timedelta genauer unter die Lupe nehmen.

Timedelta-Objekte erstellen

Im vorherigen Abschnitt haben wir ein timedelta Objekt aus zwei datetime Objekten erstellt, aber wir können auch direkt ein Zeitintervall erstellen, indem wir den timedelta() Konstruktor aufrufen:

interval = datetime.timedelta(days=10, seconds=3600)
print(interval)Bereitgestellt von

10 days, 1:00:00Bereitgestellt von

Das Intervall ist zehn Tage und eine Stunde lang. Wir können auch andere Zeiteinheiten verwenden, wenn wir eine timedelta Instanz erstellen:

interval = datetime.timedelta(weeks=1, days=3, hours=1)
print(interval)Bereitgestellt von

10 days, 1:00:00Bereitgestellt von

Beim Aufruf von timedelta() ist jede der folgenden Zeiteinheiten gültig:

• Wochen
• Tage
• Stunden
• Minuten
• Sekunden
• Millisekunden
• microseconds

In diesem Lernprogramm wird genauer untersucht, wie Zeitintervalle in einem timedelta Objekt gespeichert werden.

Grundlegende Arithmetik mit timedelta

Wir können auch arithmetische Operationen mit timedelta Objekten durchführen. Betrachte die folgenden drei datetime Objekte, die die Veröffentlichungsdaten für Python 1.0, Python 2.0 und Python 3.0 darstellen. Wenn du die Objekte von datetime voneinander subtrahierst, entsteht ein timedelta Objekt:

release_date_python_1 = datetime.datetime(year=1991, month=2, day=20)
release_date_python_2 = datetime.datetime(year=2000, month=10, day=16)
release_date_python_3 = datetime.datetime(year=2008, month=12, day=3)

​time_between_1_and_2 = release_date_python_2 - release_date_python_1
time_between_2_and_3 = release_date_python_3 - release_date_python_2

​print(time_between_1_and_2)
print(time_between_2_and_3)Bereitgestellt von

3526 days, 0:00:00
2970 days, 0:00:00Bereitgestellt von

Die Ausgabe zeigt die Anzahl der Tage zwischen den Veröffentlichungen von Python 1.0 und 2.0 und zwischen den Veröffentlichungen von Python 2.0 und 3.0. Die Zeitintervalle sind timedelta Objekte.

Es ist auch möglich, Additionen und Subtraktionen zwischen timedelta Objekten und datetime Objekten durchzuführen. Fügen wir eine timedelta mit days=100 zu release_date_python_3 hinzu:

print(release_date_python_3 + datetime.timedelta(days=100))Bereitgestellt von

2009-03-13 00:00:00Bereitgestellt von

Python 3.0 wurde am 3. Dezember 2008 veröffentlicht. Wenn wir zu diesem Datum hundert Tage hinzuzählen, kommen wir auf den 13. März 2009.

Wir können aber auch direkt mit den timedelta Objekten Rechenoperationen durchführen:

print("Difference between gap 1 and gap 2")
print(time_between_1_and_2 - time_between_2_and_3)

print("Sum of gap 1 and gap 2")
print(time_between_1_and_2 + time_between_2_and_3)Bereitgestellt von

Difference between gap 1 and gap 2
556 days, 0:00:00

Sum of gap 1 and gap 2
6496 days, 0:00:00Bereitgestellt von

Die Ausgabe bestätigt, dass es möglich ist, timedelta Objekte zu subtrahieren und zu addieren. Auch Multiplikation und Division sind möglich:

print("Multiply time interval by 3:")
print(time_between_1_and_2 * 3)

print("Divide time interval by 3:")
print(time_between_1_and_2 / 3)Bereitgestellt von

Multiply time interval by 3:
10578 days, 0:00:00

Divide time interval by 3:
1175 days, 8:00:00Bereitgestellt von

Wir können auch timedelta Objekte vergleichen:

print("Check if gap 1 is greater than gap 2")
print(time_between_1_and_2 > time_between_2_and_3)Bereitgestellt von

TrueBereitgestellt von

Die Ausgabe bestätigt, dass der Abstand zwischen den Veröffentlichungsdaten von Python 1.0 und Python 2.0 größer ist als der Abstand zwischen Python 2.0 und Python 3.0.

Wichtigste timedelta Attribute und Methoden

Ein timedelta Objekt stellt ein Zeitintervall dar, indem es die Anzahl der Tage, Sekunden und Mikrosekunden speichert. Diese drei Einheiten sind die einzigen Zeiteinheiten, die durch Attribute in der Klasse timedelta dargestellt werden:

interval = datetime.timedelta(
    weeks=1,
    hours=10,
    minutes=22,
    milliseconds=1042,
)

print(f"{interval = }")
print(f"{interval.days = }")
print(f"{interval.seconds = }")
print(f"{interval.microseconds = }")Bereitgestellt von

interval = datetime.timedelta(days=7, seconds=37321, microseconds=42000)
interval.days = 7
interval.seconds = 37321
interval.microseconds = 42000Bereitgestellt von

Auch wenn der Aufruf von timedelta() Argumente für Wochen, Stunden, Minuten und Millisekunden enthält, wandelt der Konstruktor diese Einheiten in Tage, Sekunden und Mikrosekunden um. Die print() Aufrufe enthalten f-Strings mit einem Gleichheitszeichen =, um den Variablennamen und seinen Wert anzuzeigen. Mehr über f-Strings erfährst du in diesem Tutorial über die Formatierung von f-Strings in Python.

Ein weiteres nützliches Werkzeug der Klasse timedelta ist die Methode total_seconds(). Diese Methode gibt das gesamte Zeitintervall in Sekunden zurück:

print("Total time interval in seconds:")
print(interval.total_seconds())Bereitgestellt von

Total time interval in seconds:
642121.042Bereitgestellt von

Dieser Wert stellt das gesamte Zeitintervall in Sekunden dar. Es ist nicht dasselbe wie der Wert von .seconds, der nur die Sekundenkomponente des Intervalls anzeigt, ohne die Tage und Mikrosekunden zu berücksichtigen.

Wir können den von .total_seconds() zurückgegebenen Wert verwenden, um das Zeitintervall in eine beliebige andere Einheit umzurechnen:

print("Total time interval in days:")
print(interval.total_seconds() / 3600 / 24)Bereitgestellt von

Total time interval in days:
7.431956504629629Bereitgestellt von

Die Ausgabe zeigt das Zeitintervall in Tagen, da der von .total_seconds() zurückgegebene Wert durch die Anzahl der Sekunden in einer Stunde und die Anzahl der Stunden in einem Tag geteilt wird.

timedelta Beispiel: Wachstum berechnen

Schauen wir uns ein Beispiel an. Der Online-Store eines Unternehmens, das Python-Bücher verkauft, protokolliert alle Verkäufe. Hier sind die Daten für einen Kunden:

data = {
    "customer_id": 3542,
    "sales": [
        {"date": "2024-04-21T13:23:45", "price": 24.99, "quantity": 1},
        {"date": "2024-02-13T10:54:12", "price": 24.99, "quantity": 2},
        {"date": "2024-01-08T20:32:24", "price": 18.99, "quantity": 1},
    ],
}
Bereitgestellt von

Wir müssen den Zeitunterschied zwischen der ersten und der letzten Bestellung eines Kunden berechnen. Die Bestellungen sind in der Liste mit allen Verkäufen immer in chronologischer Reihenfolge.

Unser erster Schritt besteht darin, die Daten aus dieser verschachtelten Struktur zu extrahieren und sie in datetime Objekte umzuwandeln. Zum Glück sind die Zeitstempel im Standardformat ISO 8601 (JJJJ-MM-TTTHH:MM:SS), so dass wir die bequeme Methode fromisoformat() verwenden können:

sales = data["sales"]
dates = []
for item in sales:
    date = datetime.datetime.fromisoformat(item["date"])
    dates.append(date)

print(dates)
Bereitgestellt von

[datetime.datetime(2024, 4, 21, 13, 23, 45), datetime.datetime(2024, 2, 13, 10, 54, 12), datetime.datetime(2024, 1, 8, 20, 32, 24)]Bereitgestellt von

Die Liste dates enthält datetime Objekte mit den Daten der einzelnen Bestellungen. Schließlich können wir den Zeitabstand zwischen der ersten und der letzten Bestellung berechnen:

time_span = dates[0] - dates[-1]
print(time_span)
print(time_span.days)Bereitgestellt von

103 days, 16:51:21
103Bereitgestellt von

Die Differenz zwischen dem ersten und dem letzten Datum ergibt ein timedelta Objekt. Der Code zeigt time_span an, der die Anzahl der Tage, Stunden, Minuten und Sekunden angibt. Wir zeigen auch time_span.days an, um nur die ganze Anzahl der Tage anzuzeigen.

Wenn du mehr über die Umwandlung von Strings in Datetime erfahren möchtest, schau dir dieses Tutorial zu Python String to Datetime an.

Schnelle Tipps für die Verwendung von timedelta

Es gibt ein paar Dinge, die du bei der Verwendung von timedelta in Python beachten solltest:

1. Es ist am besten, Schlüsselwortargumente zu verwenden, wenn du timedelta() aufrufst, um Fehler bei den Einheiten zu vermeiden:

interval = datetime.timedelta(weeks=1, days=3, hours=1, milliseconds=1354)Bereitgestellt von

2. Wenn du ein Zeitintervall zwischen zwei Daten in verschiedenen Zeitzonen ermitteln willst, konvertiert timedelta die Daten in UTC-Daten, bevor die Zeitdifferenz berechnet wird:

import zoneinfo

some_date = datetime.datetime.fromisoformat("2024-01-01T00:00:00")

some_date_lon = some_date.replace(tzinfo=zoneinfo.ZoneInfo("Europe/London"))
some_date_nyc = some_date.replace(tzinfo=zoneinfo.ZoneInfo("America/New_York"))

print(some_date_lon)
print(some_date_nyc)
print(some_date_nyc - some_date_lon)Bereitgestellt von

2024-01-01 00:00:00+00:00
2024-01-01 00:00:00-05:00
5:00:00Bereitgestellt von

Das Datum auf some_date zeigt den Beginn des neuen Jahres an. Dies ist ein naives datetime Objekt, da es keine Informationen über die Zeitzone hat. some_date_lon und some_date_nyc sind jedoch bewusst datetime Objekte, da sie den Beginn des neuen Jahres in London bzw. New York darstellen.

Die timedelta, die sich aus der Subtraktion der beiden bewussten datetime Objekte ergibt, zeigt ein fünfstündiges Zeitintervall, das der UTC-Zeitdifferenz entspricht.

3. Die Sommerzeitumstellung wird von timedelta nicht berücksichtigt:

nyc = zoneinfo.ZoneInfo("America/New_York")

first_time = datetime.datetime.strptime("2024-03-10 1:00am", "%Y-%m-%d %I:%M%p")
first_time = first_time.replace(tzinfo=nyc)

second_time = datetime.datetime.strptime("2024-03-10 3:00am", "%Y-%m-%d %I:%M%p")
second_time = second_time.replace(tzinfo=nyc)

time_difference = second_time - first_time
print("Time difference between the first and second time:")
print(time_difference)

print("Checking the DST status of the first and second time:")
print(f"{first_time.dst() = }")
print(f"{second_time.dst() = }")Bereitgestellt von

Time difference between the first and second time:
2:00:00

Checking the DST status of the first and second time:
first_time.dst() = datetime.timedelta(0)
second_time.dst() = datetime.timedelta(seconds=3600)Bereitgestellt von

Die beiden Zeiten entsprechen 1:00 Uhr und 3:00 Uhr am 3. März 2024 in New York. Die Sommerzeit begann um 2:00 Uhr morgens an dem Tag, an dem die Uhren auf 3:00 Uhr morgens umgestellt wurden. Die Differenz zwischen den beiden Zeiten ergibt eine timedelta, die zwei Stunden entspricht, obwohl wegen des Beginns der Sommerzeit nur eine Stunde zwischen den beiden Zeiten vergangen ist.

Wir können in UTC konvertieren, wenn wir die tatsächlich vergangene Zeit benötigen:

first_time_utc = first_time.astimezone(zoneinfo.ZoneInfo("UTC"))
second_time_utc = second_time.astimezone(zoneinfo.ZoneInfo("UTC"))
time_difference_utc = second_time_utc - first_time_utc

print("Actual time difference between the first and second time:")
print(time_difference_utc)Bereitgestellt von

Actual time difference between the first and second time:
1:00:00Bereitgestellt von

Die Umrechnung in UTC vor der Subtraktion der datetime Objekte ergibt die tatsächliche Zeit zwischen den beiden datetime Objekten.

Fazit

Die Klasse timedelta von Python bietet einfache Methoden für den Umgang mit Zeitintervallen, die es einfacher machen, mit Zeiträumen in verschiedenen Einheiten zu arbeiten. Wir haben uns angeschaut, wie man timedelta Objekte erstellt und mit ihnen Rechenoperationen wie Addition, Subtraktion, Multiplikation und Division durchführt.

Mehr über den Umgang mit Daten und Zeiten erfährst du in den folgenden Artikeln:

• Arbeiten mit Datum und Uhrzeit in Python Spickzettel
• Python String to DateTime: Wie man in Python Strings in DateTime-Objekte umwandelt
• Arbeiten mit Daten und Zeiten in Python