Kurs
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)
147 days, 0:00:00
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)
2024-05-28 08:32:44.871646
148 days, 8:32:44.871646
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)
10 days, 1:00:00
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)
10 days, 1:00:00
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)
3526 days, 0:00:00
2970 days, 0:00:00
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))
2009-03-13 00:00:00
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)
Difference between gap 1 and gap 2
556 days, 0:00:00
Sum of gap 1 and gap 2
6496 days, 0:00:00
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)
Multiply time interval by 3:
10578 days, 0:00:00
Divide time interval by 3:
1175 days, 8:00:00
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)
True
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 = }")
interval = datetime.timedelta(days=7, seconds=37321, microseconds=42000)
interval.days = 7
interval.seconds = 37321
interval.microseconds = 42000
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())
Total time interval in seconds:
642121.042
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)
Total time interval in days:
7.431956504629629
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},
],
}
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)
[datetime.datetime(2024, 4, 21, 13, 23, 45), datetime.datetime(2024, 2, 13, 10, 54, 12), datetime.datetime(2024, 1, 8, 20, 32, 24)]
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)
103 days, 16:51:21
103
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)
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)
2024-01-01 00:00:00+00:00
2024-01-01 00:00:00-05:00
5:00:00
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() = }")
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)
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)
Actual time difference between the first and second time:
1:00:00
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:
Ich habe Physik und Mathematik auf UG-Ebene an der Universität Malta studiert. Dann zog ich nach London und machte meinen Doktor in Physik am Imperial College. Ich habe an neuartigen optischen Techniken zur Abbildung der menschlichen Netzhaut gearbeitet. Jetzt konzentriere ich mich darauf, über Python zu schreiben, über Python zu kommunizieren und Python zu unterrichten.
Lerne Python mit diesen Kursen!
Kurs
Arbeiten mit Daten und Zeiten in Python
Kurs