Python-Zeichenkette in DateTime: Wie man Zeichenfolgen in DateTime-Objekte umwandelt

Einführung in das Python-Modul „datetime“

Das Modul „ datetime “, das in Python eingebaut ist, kannst du immer dann nutzen, wenn du mit Datumsangaben, Uhrzeiten oder Zeitintervallen für eine mit Python erstellte Anwendung arbeiten musst. Es bietet praktische Klassen und Methoden zum Darstellen und Bearbeiten von Datums- und Zeitdaten.

Tabelle 1: Zusammenfassung der Klassen und Methoden im Modul „datetime“

Schauen wir uns mal die wichtigsten Klassen in diesem Modul an , weil wir sie in Datums- und Uhrzeitobjekte umwandeln werden:

1. datetime.date

Diese Klasse zeigt ein Datum (Jahr, Monat und Tag) an und hat Methoden, um mit Daten zu arbeiten, wie zum Beispiel die Differenz zwischen zwei Daten zu berechnen und Daten als Zeichenfolgen zu formatieren.

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

Hier ist ein Ausschnitt, der zeigt, wie man die Klasse „ date “ benutzt:

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 zeigt die Tageszeit an (Stunde, Minute, Sekunde und Mikrosekunde) und hat Methoden, um mit Zeiten zu arbeiten, wie zum Beispiel Zeiten zu vergleichen und als Zeichenfolgen zu formatieren.

Nehmen wir mal an, wir haben einen Datensatz mit den Zielzeiten eines Rennens. Mit der Klasse „ time “ können wir die Stunden und Minuten jedes Teilnehmers extrahieren, der 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 zeigt ein Datum und eine Uhrzeit an und hat Methoden, um mit beiden zu arbeiten. Es vereint die Funktionen der Klassen für Datum und Uhrzeit.

Es wird oft bei Datenanalysen benutzt, die Zeitreihendaten mit einer hohen zeitlichen Auflösung beinhalten, wie zum Beispiel stündliche oder minütliche Daten. Nehmen wir mal an, wir haben einen Datensatz, der den stündlichen Strombedarf einer Stadt zeigt. Wir können die Klasse „ datetime “ nutzen, um Datum und Uhrzeit aus dem Datensatz zu holen und den Strombedarf im Zeitverlauf darzustellen.

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 steht für eine Dauer oder ein Zeitintervall und hat Methoden, um mit Zeitintervallen zu arbeiten, wie zum Beispiel Zeitintervalle zu Datums- oder Zeitangaben hinzuzufügen oder davon abzuziehen.

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 “ nutzen, um die Dauer jedes Ereignisses zu berechnen und sie zusammenzurechnen.

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 allen gezeigten Fällen haben wir „ datetime “-Objekte benutzt, aber in der Praxis bleiben die echten Daten oft als Zeichenfolge. Und wenn du es in ein „ datetime “-Objekt umwandelst, kannst du alle oben genannten Funktionen nutzen, die für Datenanalysen und Anwendungen echt nützlich sind.

Verwendung von datetime.strptime() für die Datums- und Uhrzeitkonvertierung

In Python können wir die Methode „ datetime.strptime() “ nutzen, um eine Zeichenfolge in ein Datums-/Zeitobjekt umzuwandeln. Die Methode „ strptime() “ braucht zwei Argumente: die zu konvertierende Zeichenfolge und eine Formatzeichenfolge, die das Format der Eingabezeichenfolge angibt.

Der Formatstring nutzt eine Mischung aus Formatierungscodes, um die verschiedenen Teile von Datum und Uhrzeit darzustellen. Hier sind ein paar der am häufigsten verwendeten Formatierungscodes:

Tabelle 2: Häufige Formatierungscodes für Datum und Uhrzeit

Jetzt, wo wir die Anweisungen „ strptime “ verstehen, können wir das Umwandeln von Strings in Datums- und Uhrzeitobjekte einfacher machen.

• Schritt 01: Analysiere die Datums- und Zeitzeichenfolge, die konvertiert werden kann, auf Muster, die mit den Formatierungscodes übereinstimmen.

• Schritt 02: Mach das Datums- und Zeitformat aus den Anweisungen „ strptime()“.

• Schritt 03: Gib die Zeichenfolge und das Format an die Funktion weiter und erhalte das Objekt als Ausgabe.

Lass uns diese Schritte umsetzen.

Eine Zeichenfolge in einem bestimmten Format in ein Datums-/Zeitobjekt umwandeln

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 Zeichenfolge, die ein Datum und eine Uhrzeit im Format „JJJJ-MM-TT HH:MM:SS“ darstellt, und im zweiten Beispiel ein anderes Format, „MM/TT/JJJJ HH:MM AM/PM“.

In beiden Fällen geben wir die richtige Formatzeichenfolge als zweites Argument für „ strptime() “ an, um das richtige Datums-/Zeitobjekt zu bekommen.

Eine Zeichenfolge mit Zeitzoneninfos in ein Datums-/Zeitobjekt umwandeln

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 Zeichenfolge, die ein Datum und eine Uhrzeit mit Zeitzoneninfos im Format „YYYY-MM-DD HH:MM:SS+TZOFFSET“ darstellt, wobei „ TZOFFSET “ der Zeitzonenversatz in Stunden und Minuten gegenüber UTC ist. Wir geben die Formatzeichenfolge als zweites Argument für „ strptime() “ an, einschließlich des Formatierungscodes „ %z “, um den Zeitzonen-Offset zu analysieren.

Auch wenn die Funktion, die wir oben gesehen haben, in der Theorie einfach aussieht, kann sie in der Praxis echt frustrierend sein, wenn was schiefgeht.

Daten ohne Formatzeichenfolgen mit dateutil analysieren

Eine weitere flexible Option ist die Bibliothek „ dateutil “, vor allem die Funktion „ parser.parse() “. Es erkennt automatisch Datumsformate, sodass du Zeichenfolgen analysieren kannst, 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 praktisch, wenn man mit unvorhersehbaren oder uneinheitlichen Datumsformaten zu tun hat.

Umgang mit Zeitzonen

Für die zeitzonenbewusste Verarbeitung von Datums- und Zeitangaben bietet Python zwei beliebte Optionen:

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

• 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 festlegen, zwischen ihnen umrechnen und die Sommerzeit automatisch berücksichtigen.

Überlegungen zur Sommerzeit

Bei der Arbeit mit Datums- und Zeitangaben, die die Zeitzone berücksichtigen, kann die Sommerzeit (DST) Probleme verursachen – vor allem, wenn die Uhren vor- oder zurückgestellt werden.

Bibliotheken wie zoneinfo und pytz kümmern sich automatisch um die Umstellung auf Sommerzeit, wenn du die richtige Zeitzone angibst:

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)

Dadurch wird sichergestellt, dass Datums- und Zeitberechnungen auch bei Sommerzeitumstellungen genau bleiben.

Pandas für die Datums- und Uhrzeitkonvertierung nutzen

Obwohl das in Python integrierte Modul „ datetime “ echt leistungsstark ist, nutzen viele Datenwissenschaftler lieber die Pandas-Bibliothek für Datums- und Uhrzeitkonvertierungen, weil sie einfach zu bedienen ist und ganze Spalten mit Datumsangaben 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 erkennt Formate automatisch und geht super mit häufigen Inkonsistenzen um, was es zur ersten Wahl bei der Arbeit mit tabellarischen Daten macht.

Formatieren von Datetime-Objekten zu Strings mit strftime()

Nachdem du Strings in Datums-/Zeitobjekte umgewandelt und die gewünschten Operationen durchgeführt hast, musst du sie möglicherweise wieder in Strings zurückwandeln. Du kannst dafür datetime.strftime() nutzen.

from datetime import datetime

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

Mit dieser Methode kannst du komplett bestimmen, wie dein Datums- und Uhrzeitobjekt als Zeichenfolge angezeigt wird.

Fehlerbehebung bei häufigen Fehlern mit strptime()

Hier sind ein paar häufige Fehler, die auftreten können, und wie du sie beheben kannst:

Wertfehler: Die Zeitangabe „date_string” passt nicht zum Format „%Y-%m-%d %H:%M:%S”.

Der häufigste Fehler passiert, wenn die Eingabezeichenfolge nicht mit der Formatzeichenfolge übereinstimmt. Bitte überprüfe nochmal, 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'

Typfehler: Das Argument 1 von strptime() muss ein String sein, kein „int“.

Der nächste häufige Fehler passiert, wenn du eine Ganzzahl an datetime.strptime() oder time.strptime() übergibst, statt eine Zeichenkette. Stell sicher, dass alle Werte, die du an die Funktion übergibst, Zeichenfolgen 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: Nicht konvertierte Daten bleiben: „:00“

Dieser Fehler passiert, wenn in der Eingabezeichenfolge Zeichen übrig bleiben, die nicht mit der Formatzeichenfolge übereinstimmen. Dieser Fehler tritt zum Beispiel auf, wenn die Formatzeichenfolge nur das Jahr, den Monat und den Tag angibt, die Eingabezeichenfolge aber auch die Uhrzeit enthält. Um diesen Fehler zu beheben, musst du sicherstellen, dass die Formatzeichenfolge mit der gesamten Eingabezeichenfolge ü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

Man kann echt sagen, dass die Methode „ datetime.strptime() “ eine flexible und leistungsstarke Möglichkeit bietet, Strings in Python in Datums- und Uhrzeitobjekte umzuwandeln, und dass sie für die Verarbeitung einer Vielzahl von Datums- und Uhrzeitformaten verwendet werden kann. Hol dir doch einfach unser Cheatsheet mit Terminen und Zeiten, damit du später alles parat hast.

Nachdem du die Daten und Zeiten verstanden hast, geht's weiter damit, sie in einem Projekt anzuwenden. Wir empfehlen dir, dir eins davon auszusuchen und dein Wissen zu vertiefen:

• Finanzprognosen in Python
• Python für Finanzen für Fortgeschrittene

Wir sind uns einig, dass Datums- und Zeitangaben in der echten Welt kompliziert sind, aber du musst nur die Formate und Muster hinter jeder Art von Datum und Uhrzeit in deinen Daten verstehen und die Bibliotheken, die du hast, clever nutzen.