Datumsangaben korrekt parsen
Parsen Sie Datumszeichenfolgen mit pd.to_datetime in datetime64, behandeln Sie unterschiedliche Formate und setzen Sie einen DatetimeIndex.
Datumsangaben korrekt parsen ist eine kostenlose Pandas & NumPy Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Pandas & NumPy Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Pandas & NumPy Academy-Kurs umfasst insgesamt 4 Lektionen.
Warum die Datumsanalyse wichtig ist
Datums- und Zeitdaten kommen in realen Datensätzen überall vor – etwa als Zeitstempel von Transaktionen, Geburtsdaten, Ereignisprotokolle und Finanzzeiträume. Wenn Datumsangaben als Zeichenfolgen (mit dem Datentyp object) gespeichert sind, können Sie keine Zeitspannen berechnen, keine Resamples nach Monat erstellen und nicht chronologisch sortieren. Durch die Konvertierung von Zeichenfolgen in Pandas' Datentyp datetime64 wird die vollständige Zeitreihen-API verfügbar und eine zeitbezogene Analyse möglich.
import pandas as pd
df = pd.DataFrame({'date': ['2024-01-15', '2024-03-20', '2024-07-04']})
print(df['date'].dtype) # object
# You cannot do arithmetic on string dates
# df['date'] + pd.Timedelta('1 day') # TypeError!
# After parsing:
df['date'] = pd.to_datetime(df['date'])
print(df['date'].dtype) # datetime64[ns]
print(df['date'] + pd.Timedelta('1 day'))Grundlagen von pd.to_datetime()
pd.to_datetime(series) ist die primäre Funktion, um Zeichenfolgenspalten in datetime64 umzuwandeln. Sie erkennt die meisten gängigen Datumsformate automatisch (ISO 8601, US-amerikanische und europäische Datumsangaben), ohne dass eine Formatzeichenfolge erforderlich ist. Das Ergebnis ist eine Series mit dem Datentyp datetime64[ns] – mit Nanosekundenpräzision und der Möglichkeit, Zeitstempel von 1677 bis 2262 zu speichern.
import pandas as pd
dates = pd.Series([
'2024-01-15',
'15/01/2024',
'January 15, 2024',
'2024-01-15 08:30:00'
])
parsed = pd.to_datetime(dates)
print(parsed)
# 0 2024-01-15 00:00:00
# 1 2024-01-15 00:00:00
# 2 2024-01-15 00:00:00
# 3 2024-01-15 08:30:00
print(parsed.dtype) # datetime64[ns]Das Argument format= angeben
Wenn die automatische Erkennung zu langsam oder mehrdeutig ist (z. B. kann '01-02-03' den 2. Januar 2003, den 1. Februar 2003 oder den 3. Februar 2001 bedeuten), geben Sie die genaue Formatzeichenfolge mithilfe der strftime-Codes von Python an. Das ist außerdem deutlich schneller: Bei großen Datensätzen kann die explizite Formatanalyse 10-mal schneller sein als die automatische Erkennung, da Pandas nicht mehrere Muster ausprobieren muss.
import pandas as pd
dates = pd.Series(['15/01/2024', '20/03/2024', '04/07/2024'])
# Explicit format: day/month/year
parsed = pd.to_datetime(dates, format='%d/%m/%Y')
print(parsed)
# 0 2024-01-15
# 1 2024-03-20
# 2 2024-07-04
# Common format codes:
# %Y = 4-digit year, %y = 2-digit year
# %m = month (01-12), %d = day (01-31)
# %H = hour (0-23), %M = minute, %S = seconderrors='coerce' für fehlerhafte Datumsangaben
Reale Datensätze enthalten in Datumsspalten häufig Tippfehler oder Platzhalterzeichenfolgen wie 'TBD', 'N/A' oder '99/99/9999'. Die Übergabe von errors='coerce' weist pd.to_datetime() an, nicht analysierbare Werte in NaT (Not a Time – das datetime-Gegenstück zu NaN) umzuwandeln, anstatt eine Ausnahme auszulösen. So können Sie fehlerhafte Datumsangaben separat identifizieren und behandeln.
import pandas as pd
dates = pd.Series(['2024-01-15', 'TBD', '2024-07-04', 'N/A'])
parsed = pd.to_datetime(dates, errors='coerce')
print(parsed)
# 0 2024-01-15
# 1 NaT
# 2 2024-07-04
# 3 NaT
# Detect bad dates
print('Bad date rows:', parsed.isna().sum()) # 2parse_dates in read_csv()
Am effizientesten analysieren Sie Datumsangaben bereits beim Laden mithilfe des Parameters parse_dates von pd.read_csv(). Übergeben Sie eine Liste von Spaltennamen (oder Indizes), die als Datumsangaben analysiert werden sollen. Dadurch entfällt ein separater Nachbearbeitungsschritt. Oft ist dieses Vorgehen auch schneller, da Pandas die Analyse während des CSV-Parsings auf C-Ebene durchführt.
import pandas as pd
import io
csv_data = '''order_id,order_date,ship_date
1,2024-01-15,2024-01-18
2,2024-02-20,2024-02-22
'''
df = pd.read_csv(
io.StringIO(csv_data),
parse_dates=['order_date', 'ship_date']
)
print(df.dtypes)
# order_id int64
# order_date datetime64[ns]
# ship_date datetime64[ns]Der .dt-Accessor für Datumskomponenten
Sobald eine Spalte den Datentyp datetime64 besitzt, stellt der .dt-Accessor Dutzende Eigenschaften und Methoden bereit. Sie können .dt.year, .dt.month, .dt.day, .dt.hour, .dt.dayofweek (0=Montag) und .dt.is_month_end extrahieren. Diese Möglichkeiten werden für Feature Engineering bei Zeitreihenvorhersagen und zum Gruppieren von Daten nach Zeiträumen verwendet.
import pandas as pd
df = pd.DataFrame({
'event_time': pd.to_datetime([
'2024-03-15 08:30:00',
'2024-07-04 14:00:00',
'2024-12-25 09:00:00'
])
})
df['year'] = df['event_time'].dt.year
df['month'] = df['event_time'].dt.month
df['day_of_week'] = df['event_time'].dt.day_name()
df['hour'] = df['event_time'].dt.hour
print(df[['year', 'month', 'day_of_week', 'hour']])Einen DatetimeIndex festlegen
Bei der Zeitreihenanalyse ist es üblich, die Datumsspalte als Index des DataFrames festzulegen. Mit einem DatetimeIndex können Sie zeitbasierte Ausschnitte verwenden (df['2024'], df['2024-01':'2024-06']), auf jede Frequenz resamplen und die vollständige Zeitreihen-API von Pandas nutzen. Verwenden Sie dazu set_index() oder übergeben Sie index_col an read_csv.
import pandas as pd
df = pd.DataFrame({
'date': pd.to_datetime(['2024-01-01', '2024-01-02', '2024-01-03']),
'temp': [22.5, 23.0, 21.8]
})
df = df.set_index('date')
print(df)
# temp
# date
# 2024-01-01 22.5
# 2024-01-02 23.0
# 2024-01-03 21.8
# Time-based slicing
print(df['2024-01-02':'2024-01-03'])Mehrere Datumsformate behandeln
Wenn eine Datumsspalte einen Mix aus Formaten enthält (z. B. einige Zeilen mit ISO-Datumsangaben und andere mit US-amerikanischen Datumsangaben), können Sie keine einzelne Formatzeichenfolge angeben. Übergeben Sie format='mixed' (ab Pandas 2.0), um eine zeilenweise Formaterkennung zu ermöglichen, oder bereinigen Sie die Spalte vorab mit regulären Ausdrücken, um alle Datumsangaben vor dem Aufruf von pd.to_datetime() in ein einheitliches Format zu bringen.
import pandas as pd
mixed_dates = pd.Series([
'2024-01-15',
'03/20/2024',
'2024-07-04T10:30:00'
])
# format='mixed' handles different formats row-by-row (Pandas >= 2.0)
parsed = pd.to_datetime(mixed_dates, format='mixed')
print(parsed)
# 0 2024-01-15 00:00:00
# 1 2024-03-20 00:00:00
# 2 2024-07-04 10:30:00Zeitzonenbewusste Datetimes
Zeitstempel aus der Praxis enthalten häufig Zeitzoneninformationen. pd.to_datetime() kann Zeichenfolgen mit UTC-Versatz analysieren (z. B. '2024-01-15 08:30:00+05:30') und als zeitzonenbewusstes datetime64 speichern. Verwenden Sie .dt.tz_convert('UTC'), um alle Zeitstempel für korrekte Vergleiche und Berechnungen in eine gemeinsame Zeitzone zu normalisieren.
import pandas as pd
dates = pd.to_datetime(['2024-01-15 08:30:00+05:30', '2024-01-15 10:00:00-08:00'])
print(dates)
# DatetimeIndex(['2024-01-15 08:30:00+05:30', '2024-01-15 10:00:00-08:00'])
# Convert both to UTC for fair comparison
utc_dates = dates.tz_convert('UTC')
print(utc_dates)
# DatetimeIndex(['2024-01-15 03:00:00+00:00', '2024-01-15 18:00:00+00:00'])Datumsdifferenzen berechnen
Arithmetik zwischen zwei datetime64-Spalten erzeugt eine Timedelta-Series. Die Anzahl der Tage, Stunden oder Sekunden eines Timedelta können Sie mithilfe der Eigenschaften .dt.days, .dt.seconds und .dt.total_seconds() extrahieren. Dies ist der Standardweg, um Merkmale wie Alter, Dauer oder die Anzahl der Tage seit dem letzten Ereignis zu berechnen.
import pandas as pd
df = pd.DataFrame({
'start': pd.to_datetime(['2024-01-01', '2024-03-10', '2024-06-15']),
'end': pd.to_datetime(['2024-01-20', '2024-04-05', '2024-06-30'])
})
df['duration_days'] = (df['end'] - df['start']).dt.days
print(df[['start', 'end', 'duration_days']])
# start end duration_days
# 0 2024-01-01 2024-01-20 19
# 1 2024-03-10 2024-04-05 26
# 2 2024-06-15 2024-06-30 15pd.date_range() zum Erzeugen von Datumsangaben
pd.date_range(start, end, freq=) erzeugt eine Folge gleichmäßig verteilter Datumsangaben als DatetimeIndex. Das ist nützlich, um eine vollständige Zeitachse zu erstellen, an der Sie Ihre Daten neu indizieren können. So erscheint jeder Kalenderzeitraum in der Ausgabe, auch wenn an diesem Tag keine Ereignisse stattfanden. Häufige freq-Werte sind: 'D' (täglich), 'ME' (Monatsende), 'h' (stündlich).
import pandas as pd
# Weekly dates for the first quarter of 2024
weekly = pd.date_range(start='2024-01-01', end='2024-03-31', freq='W')
print(weekly[:5])
# DatetimeIndex(['2024-01-07', '2024-01-14', '2024-01-21', '2024-01-28', '2024-02-04'])
# Monthly date spine
monthly = pd.date_range(start='2024-01', periods=12, freq='ME')
print(len(monthly), monthly[0], monthly[-1])
# 12 2024-01-31 2024-12-31Schnelltest
Testen Sie Ihr Verständnis der korrekten Datumsanalyse in Pandas.
Lektionszusammenfassung
In dieser Lektion haben Sie gelernt: pd.to_datetime() wandelt Zeichenfolgenspalten in datetime64 um, format= legt das genaue Muster für Geschwindigkeit und Genauigkeit fest, und errors='coerce' wandelt fehlerhafte Datumsangaben in NaT um, anstatt einen Fehler auszulösen. Der .dt-Accessor extrahiert Jahr, Monat, Tag und weitere Komponenten, und ein DatetimeIndex ermöglicht zeitbasierte Ausschnitte. Als Nächstes sehen wir uns den .str-Accessor für vektorisierte Zeichenfolgenoperationen an.
Häufig gestellte Fragen
Ist die Lektion „Datumsangaben korrekt parsen“ kostenlos?
Ja — der vollständige Text von „Datumsangaben korrekt parsen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Pandas & NumPy Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Pandas & NumPy Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Datumsangaben korrekt parsen“?
Parsen Sie Datumszeichenfolgen mit pd.to_datetime in datetime64, behandeln Sie unterschiedliche Formate und setzen Sie einen DatetimeIndex. Du übst Pandas & NumPy Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Pandas & NumPy Academy zu starten?
Keine Vorkenntnisse erforderlich. Pandas & NumPy Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.
Wie lange dauert die Lektion „Datumsangaben korrekt parsen“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Pandas & NumPy Academy-Lektion Code schreiben und ausführen?
Ja. Jede Pandas & NumPy Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Datentypen von Spalten untersuchen
- Typumwandlung mit astype()
- Kategorischer Datentyp
- Datumsangaben korrekt parsen