Python String to DateTime: Strings in DateTime-Objekte umwandeln

Einführung in das Python datetime Modul

Das Modul datetime, das in Python integriert ist, kann immer dann verwendet werden, wenn du in einer mit Python erstellten Anwendung mit Daten, Zeiten oder Zeitintervallen arbeiten musst. Es bietet praktische Klassen und Methoden zur Darstellung und Bearbeitung von Datums- und Zeitdaten.

Tabelle 1: Zusammenfassung der Klassen und Methoden im datetime-Modul

Wir wollen die wichtigsten Klassen dieses Moduls verstehen , da wir sie in datetime-Objekte umwandeln werden:

1. datetime.date

Diese Klasse stellt ein Datum (Jahr, Monat und Tag) dar und bietet Methoden für die Arbeit mit Datumsangaben, wie z. B. die Berechnung der Differenz zwischen zwei Datumsangaben und die Formatierung von Datumsangaben als Zeichenketten.

Angenommen, wir haben einen Datensatz mit den täglichen Aktienkursen eines Unternehmens. Wir können die Datumsklasse verwenden, um die Daten aus dem Datensatz zu extrahieren und die Aktienkurse im Zeitverlauf darzustellen.

Hier ist ein Schnipsel, der die Verwendung der Klasse date zeigt:

from datetime import date

# create a date object representing March 1, 2023
start_date = date(2023, 3, 1)

# extract information such as the year, month, and day
year = start_date.year
month = start_date.month
day = start_date.day

# get the day of the week (Note: Monday is coded as 0, and Sunday as 6)
weekday = start_date.weekday()

# the date can be formatted as a string if needed
date_str = start_date.strftime('%Y-%m-%d')

2. datetime.time

Diese Klasse stellt eine Tageszeit (Stunde, Minute, Sekunde und Mikrosekunde) dar und bietet Methoden für die Arbeit mit Zeiten, wie den Vergleich von Zeiten und die Formatierung von Zeiten als Strings.

Angenommen, wir haben einen Datensatz, der die Endzeit eines Rennens enthält. Wir können die Klasse time verwenden, um die Stunden und Minuten zu extrahieren, in denen jeder Teilnehmer das Rennen beendet hat.

from datetime import time

# create a time object with the microsecond granularity
end_time = time(15, 45, 30, 500000)

# get the hour and minute
hour = end_time.hour
minute = end_time.minute
second = end_time.second
microsecond = end_time.microsecond

3. datetime.datetime

Diese Klasse stellt ein Datum und eine Uhrzeit dar und bietet Methoden für die Arbeit mit beiden. Sie kombiniert die Funktionen der Datums- und Zeitklassen.

Sie wird häufig bei Datenanalysen eingesetzt, die Zeitreihendaten mit einer hohen zeitlichen Auflösung beinhalten, z. B. Daten auf Stunden- oder Minutenebene. Angenommen, wir haben einen Datensatz mit der stündlichen Stromnachfrage für eine Stadt. Mit der Klasse datetime können wir das Datum und die Uhrzeit aus dem Datensatz extrahieren und den Strombedarf über die Zeit darstellen.

from datetime import datetime

# create a datetime object representing March 1, 2023 at 9:30 AM
start_datetime = datetime(2023, 3, 1, 9, 30)

# get the year, month, day, hour, and minute
year = start_datetime.year
month = start_datetime.month
day = start_datetime.day
hour = start_datetime.hour
minute = start_datetime.minute

4. datetime.timedelta

Diese Klasse stellt eine Dauer oder ein Zeitintervall dar und bietet Methoden für die Arbeit mit Zeitintervallen, wie z. B. das Addieren oder Subtrahieren von Zeitintervallen von Daten oder Zeiten.

Angenommen, wir haben einen Datensatz mit den Start- und Endzeiten einer Reihe von Ereignissen und wollen die Gesamtdauer aller Ereignisse berechnen. Wir können die Klasse timedelta verwenden, um die Dauer jedes Ereignisses zu berechnen und sie zu summieren.

from datetime import timedelta

# create a timedelta object representing 3 hours and 15 minutes
event_duration = timedelta(hours=3, minutes=15)

# get the total duration in seconds
event_duration_seconds = event_duration.total_seconds()

# add the duration to a start time to get an end time
event_start_time = datetime(2023, 3, 1, 18, 15)
event_end_time = event_start_time + event_duration

In all diesen Fällen, die wir gezeigt haben, haben wir datetime Objekte verwendet, aber die realen Daten bleiben in der Praxis oft als String. Durch die Umwandlung in ein datetime Objekt werden alle oben genannten Funktionen freigeschaltet, die für datenwissenschaftliche Analysen und Anwendungen wichtig sind.

Einen String in ein datetime-Objekt in Python umwandeln mit datetime.strptime()

In Python können wir die Methode datetime.strptime() verwenden, um einen String in ein Datetime-Objekt umzuwandeln. Die Methode strptime() nimmt zwei Argumente entgegen: die zu konvertierende Zeichenfolge und eine Formatzeichenfolge, die das Format der Eingabezeichenfolge angibt.

Der Formatstring verwendet eine Kombination von Formatierungscodes, um die verschiedenen Komponenten von Datum und Uhrzeit darzustellen. Hier sind einige der am häufigsten verwendeten Formatierungscodes:

Tabelle 2: Gemeinsame Codes für die Datumsformatierung

Nachdem wir nun die strptime Direktiven verstanden haben, kann der Prozess der Umwandlung von Strings in Datetime-Objekte vereinfacht werden.

• Schritt 01: Analysiere die Datums-/Zeitzeichenfolge, die umgewandelt werden kann, auf Muster, die den Formatierungscodes entsprechen.
• Schritt 02: Erstelle das Datums-Zeit-Format aus den strptime()Direktiven.
• Schritt 03: Übergib die Zeichenkette und das Format an die Funktion und erhalte das Objekt als Ausgabe.

Lass uns diese Schritte in die Tat umsetzen.

Konvertieren eines Strings in einem bestimmten Format in ein Datetime-Objekt

from datetime import datetime

# Example with the standard date and time format
date_str = '2023-02-28 14:30:00'
date_format = '%Y-%m-%d %H:%M:%S'

date_obj = datetime.strptime(date_str, date_format)
print(date_obj)

# Example with a different format

date_str = '02/28/2023 02:30 PM'
date_format = '%m/%d/%Y %I:%M %p'

date_obj = datetime.strptime(date_str, date_format)
print(date_obj)

Im ersten Beispiel haben wir eine Zeichenkette, die ein Datum und eine Uhrzeit im Format "JJJJ-MM-TT HH:MM:SS" darstellt, und im zweiten Beispiel in einem anderen Format, "MM/TT/JJJJ HH:MM AM/PM".

In beiden Fällen geben wir den richtigen Format-String als zweites Argument an strptime() an, um das richtige Datetime-Objekt zu erhalten.

Konvertierung eines Strings mit Zeitzoneninformationen in ein datetime-Objekt

from datetime import datetime

date_str = '2023-02-28 14:30:00+05:30'
date_format = '%Y-%m-%d %H:%M:%S%z'

date_obj = datetime.strptime(date_str, date_format)
print(date_obj)

In diesem Beispiel haben wir eine Zeichenkette, die ein Datum und eine Uhrzeit mit Zeitzoneninformationen im Format "JJJJ-MM-TT HH:MM:SS+TZOFFSET" darstellt, wobei TZOFFSET die Zeitzonenabweichung in Stunden und Minuten von der UTC ist. Wir geben den Formatstring als zweites Argument an strptime() an, einschließlich des %z Formatierungscodes, um die Zeitzonenverschiebung zu analysieren.

Die Funktion, die wir oben gesehen haben, mag in der Theorie einfach erscheinen, aber sie kann auch eine Quelle der Frustration sein, wenn in der Praxis etwas schief läuft.

Datumsangaben ohne Formatstrings mit dateutil analysieren

Eine weitere flexible Option ist die Bibliothek dateutil, insbesondere die Funktion parser.parse(). Sie erkennt automatisch Datumsformate und ermöglicht es dir, Zeichenketten zu analysieren, ohne eine Formatzeichenfolge anzugeben.

from dateutil.parser import parse

# Automatically infers the format
date_obj = parse("March 1, 2023 9:30 AM")
print(date_obj)

Das ist besonders nützlich, wenn du es mit unvorhersehbaren oder inkonsistenten Datumsformaten zu tun hast.

Umgang mit Zeitzonen

Für den Umgang mit der Zeitzone bietet Python zwei beliebte Optionen:

• pytz (weit verbreitet und kompatibel mit älteren Versionen)

• zoneinfo (eingeführt in Python 3.9, Teil der Standardbibliothek)

from datetime import datetime
from zoneinfo import ZoneInfo

# Using zoneinfo
dt = datetime(2023, 3, 1, 9, 30, tzinfo=ZoneInfo("America/New_York"))
print(dt)

# Using pytz (alternative)
import pytz
dt_pytz = datetime(2023, 3, 1, 9, 30, tzinfo=pytz.timezone("America/New_York"))
print(dt_pytz)

Mit diesen Tools kannst du Zeitzonen zuweisen, zwischen ihnen umrechnen und die Sommerzeit automatisch berücksichtigen.

Überlegungen zur Sommerzeit

Bei der Arbeit mit zeitzonenspezifischen Datumsangaben kann die Sommerzeit zu Komplikationen führen - vor allem, wenn die Uhren vor- oder zurückgestellt werden.

Bibliotheken wie zoneinfo und pytz verwalten die Sommerzeitumstellung automatisch, wenn du die entsprechende Zeitzone zuweist:

from datetime import datetime
from zoneinfo import ZoneInfo

# Before and after DST starts
before_dst = datetime(2023, 3, 12, 1, 30, tzinfo=ZoneInfo("America/New_York"))
after_dst = datetime(2023, 3, 12, 3, 30, tzinfo=ZoneInfo("America/New_York"))

print(before_dst)
print(after_dst)

So wird sichergestellt, dass die Zeitberechnungen auch bei einer Sommerzeitumstellung korrekt bleiben.

Pandas für Datetime-Konvertierung verwenden

Das in Python eingebaute Modul datetime ist zwar sehr leistungsfähig, aber viele Datenwissenschaftler bevorzugen die Pandas-Bibliothek für Datumsumwandlungen, weil sie einfach ist und ganze Spalten mit Daten effizient verarbeiten kann.

import pandas as pd

# Converting a column of strings to datetime objects
date_series = pd.to_datetime(['2023-02-28', '2023-03-01', '2023-03-02'])
print(date_series)

Pandas leitet automatisch Formate ab und geht mit häufigen Inkonsistenzen elegant um, was es zur ersten Wahl bei der Arbeit mit tabellarischen Daten macht.

Datetime-Objekte mit strftime() in Strings formatieren

Wenn du Strings in Datetime-Objekte umgewandelt und die gewünschten Operationen durchgeführt hast, musst du sie eventuell wieder in Strings umwandeln. Du kannst datetime.strftime() für diesen Zweck verwenden.

from datetime import datetime

now = datetime.now()
formatted = now.strftime('%Y-%m-%d %H:%M:%S')
print(formatted)

Mit dieser Methode hast du die volle Kontrolle darüber, wie dein Datetime-Objekt in String-Form angezeigt wird.

Fehlersuche bei häufigen strptime()-Fehlern

Hier sind einige häufige Fehler, auf die du stoßen kannst, und wie du sie beheben kannst:

ValueError: Zeitdaten 'date_string' entsprechen nicht dem Format '%Y-%m-%d %H:%M:%S'

Der häufigste Fehler tritt auf, wenn der Eingabestring nicht mit dem Formatstring übereinstimmt. Bitte überprüfe, ob die Eingabezeichenfolge und die Formatzeichenfolge genau übereinstimmen.

import datetime

# When input has two-digit year instead of four-digit year
date_str = '23-03-01'
date_obj = datetime.datetime.strptime(date_str, '%y-%m-%d')
# Raises ValueError: time data '23-03-01' does not match format '%y-%m-%d'

# When the input has missing leading zeros for hour and minute
time_str = '8:30'
time_obj = datetime.datetime.strptime(time_str, '%H:%M')
# Raises ValueError: time data '8:30' does not match format '%H:%M'

TypeError: strptime() Argument 1 muss str sein, nicht 'int'

Der nächste häufige Fehler tritt auf, wenn du an datetime.strptime() oder time.strptime() eine ganze Zahl statt einer Zeichenkette übergibst. Stelle sicher, dass alle Werte, die du der Funktion übergibst, Strings sind.

# Example 1: Integer instead of string
date_int = 20230301
date_obj = datetime.datetime.strptime(date_int, '%Y%m%d')
# Raises TypeError: strptime() argument 1 must be str, not int

# Example 2: List instead of string
date_list = [2023, 3, 1]
date_obj = datetime.datetime.strptime(date_list, '%Y-%m-%d')
# Raises TypeError: strptime() argument 1 must be str, not list

ValueError: unkonvertierte Daten bleiben: ':00'

Dieser Fehler tritt auf, wenn in der Eingabezeichenfolge Restzeichen vorhanden sind, die von der Formatzeichenfolge nicht erfasst werden. Dieser Fehler tritt zum Beispiel auf, wenn der Formatstring nur das Jahr, den Monat und den Tag angibt, der Eingabe-String aber auch die Tageszeit enthält. Um diesen Fehler zu beheben, vergewissere dich, dass der Formatstring mit dem gesamten Eingabe-String übereinstimmt.

# when input string contains time of day
date_str = '2023-03-01 12:30:00'
date_obj = datetime.datetime.strptime(date_str, '%Y-%m-%d')
# Raises ValueError: unconverted data remains:  12:30:00

# When input string contains extra characters
date_str = '2023-03-01T00:00:00Z'
date_obj = datetime.datetime.strptime(date_str, '%Y-%m-%d')
# Raises ValueError: unconverted data remains: T00:00:00Z

Fazit

Die Methode datetime.strptime() bietet eine flexible und leistungsstarke Möglichkeit, Strings in Python in Datetime-Objekte umzuwandeln und kann für eine Vielzahl von Datums- und Zeitformaten verwendet werden. Warum nimmst du dir nicht unser Cheatsheet für Termine und Zeiten zur Hand?

Nachdem du die Daten und Zeiten verstanden hast, ist der nächste Schritt, sie in einem Projekt zu üben. Wir empfehlen dir, eine davon auszuwählen und dein Wissen zu festigen:

• Finanzprognosen in Python
• Intermediate Python for Finance

Wir sind uns einig, dass Datums- und Zeitdaten in der realen Welt kompliziert sind, aber du musst nur die Formate und Muster verstehen, die hinter jeder Art von Datum und Uhrzeit in deinen Daten stehen, und die Bibliotheken, die du hast, klug einsetzen.