Datums correct parseren
Parse datums als strings naar datetime64 met pd.to_datetime, verwerk meerdere notaties en stel een DatetimeIndex in.
Datums correct parseren is een gratis Pandas & NumPy Academy-les op CoddyKit. Dit is les 4 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Pandas & NumPy Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Pandas & NumPy Academy bevat in totaal 4 lessen.
Waarom datumparsering belangrijk is
Datum- en tijdgegevens komen overal voor in realistische gegevensverzamelingen — tijdstempels van transacties, geboortedatums, gebeurtenislogboeken en financiële perioden. Wanneer datums als tekenreeksen zijn opgeslagen (het dtype object), kun je geen tijdsduur berekenen, per maand resamplen of chronologisch sorteren. Door tekenreeksen te converteren naar Pandas' dtype datetime64 krijg je toegang tot de volledige API voor tijdreeksen en wordt temporele analyse mogelijk.
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'))Basis van pd.to_datetime()
pd.to_datetime(series) is de belangrijkste functie om tekenreekskolommen naar datetime64 te converteren. De functie herkent automatisch de meeste gangbare datumindelingen (ISO 8601, Amerikaanse datums, Europese datums), zonder dat je een formattekenreeks hoeft op te geven. Het resultaat is een Series met dtype datetime64[ns] — precisie tot op nanoseconden, geschikt voor tijdstempels van 1677 tot 2262.
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]Het argument format= opgeven
Wanneer automatische afleiding te traag of dubbelzinnig is (bijvoorbeeld: '01-02-03' kan 2 januari 2003, 1 februari 2003 of 3 februari 2001 betekenen), geef je de exacte formattekenreeks op met de strftime-codes van Python. Dit is ook aanzienlijk sneller — bij grote gegevensverzamelingen kan parseren met een expliciete indeling 10 keer sneller zijn dan automatisch afleiden, omdat Pandas niet meerdere patronen hoeft uit te proberen.
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' voor ongeldige datums
Realistische gegevensverzamelingen bevatten vaak typefouten of tijdelijke tekenreeksen zoals 'TBD', 'N/A' of '99/99/9999' in datumkolommen. Als je errors='coerce' meegeeft, converteert pd.to_datetime() niet-parseerbare waarden naar NaT (Not a Time — het datetime-equivalent van NaN) in plaats van een uitzondering op te werpen. Zo kun je ongeldige datums afzonderlijk vinden en verwerken.
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()
Je kunt datums het efficiëntst parseren tijdens het laden met de parameter parse_dates van pd.read_csv(). Geef een lijst met kolomnamen (of indexen) door die als datums moeten worden geparsed. Daarmee vermijd je een afzonderlijke nabewerkingsstap en ben je vaak sneller, omdat Pandas dit tijdens het parseren van de CSV op C-niveau afhandelt.
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]De accessor .dt voor datumonderdelen
Zodra een kolom het dtype datetime64 heeft, geeft de accessor .dt toegang tot tientallen eigenschappen en methoden. Je kunt .dt.year, .dt.month, .dt.day, .dt.hour, .dt.dayofweek (0=maandag) en .dt.is_month_end ophalen. Je gebruikt deze voor feature-engineering bij het voorspellen van tijdreeksen en om gegevens per periode te groeperen.
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']])Een DatetimeIndex instellen
Bij tijdreeksanalyse is het gebruikelijk om de datumtijdkolom in te stellen als de index van de DataFrame. Met een DatetimeIndex kun je tijdgebaseerd selecteren (df['2024'], df['2024-01':'2024-06']), naar elke frequentie resamplen en de volledige API voor tijdreeksen van Pandas gebruiken. Gebruik set_index() of geef index_col door aan 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'])Meerdere datumindelingen verwerken
Als een datumkolom een mix van indelingen bevat (bijvoorbeeld: sommige rijen bevatten ISO-datums en andere datums in Amerikaanse stijl), kun je geen enkele formattekenreeks opgeven. Geef format='mixed' door (Pandas 2.0+) om de indeling per rij te laten detecteren, of maak de kolom vooraf schoon met regex om alle datums naar één indeling te normaliseren voordat je pd.to_datetime() aanroept.
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:00Datumtijden met tijdzone
Tijdstempels uit de praktijk bevatten vaak informatie over de tijdzone. pd.to_datetime() kan tekenreeksen met UTC-verschuivingen parseren (bijvoorbeeld '2024-01-15 08:30:00+05:30') en ze opslaan als datetime64 met tijdzone. Gebruik .dt.tz_convert('UTC') om alle tijdstempels naar een gemeenschappelijke tijdzone te normaliseren voor correcte vergelijkingen en berekeningen.
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'])Datumverschillen berekenen
Rekenkundige bewerkingen tussen twee datetime64-kolommen leveren een Timedelta-Series op. Je kunt het aantal dagen, uren of seconden uit een Timedelta ophalen met de eigenschappen .dt.days, .dt.seconds en .dt.total_seconds(). Dit is de standaardmanier om kenmerken zoals leeftijd, tijdsduur of het aantal dagen sinds de laatste gebeurtenis te berekenen.
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() voor het genereren van datums
pd.date_range(start, end, freq=) genereert een reeks gelijkmatig verdeelde datums als een DatetimeIndex. Dit is handig om een volledige tijdas te maken waartegen je je gegevens opnieuw kunt indexeren — zo verschijnt elke kalenderperiode in de uitvoer, ook als er die dag geen gebeurtenissen waren. Veelgebruikte waarden voor freq: 'D' (dagelijks), 'ME' (maandeinde), 'h' (elk uur).
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-31Korte controle
Test je begrip van het correct parseren van datums in Pandas.
Samenvatting van de les
In deze les heb je geleerd dat pd.to_datetime() tekenreekskolommen naar datetime64 converteert, dat format= het exacte patroon opgeeft voor snelheid en nauwkeurigheid, en dat errors='coerce' ongeldige datums omzet naar NaT in plaats van dat de uitvoering stopt. De accessor .dt haalt het jaar, de maand, de dag en andere onderdelen op, en met een DatetimeIndex kun je tijdgebaseerd selecteren. Hierna verkennen we de accessor .str voor gevectoriseerde bewerkingen op tekenreeksen.
Leer Python met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 30
- Lessen
- 120
Veelgestelde vragen
Is de les “Datums correct parseren” gratis?
Ja — de volledige tekst van “Datums correct parseren” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Pandas & NumPy Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Pandas & NumPy Academy bevat in totaal 4 lessen.
Wat leer ik in “Datums correct parseren”?
Parse datums als strings naar datetime64 met pd.to_datetime, verwerk meerdere notaties en stel een DatetimeIndex in. Je oefent met Pandas & NumPy Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Pandas & NumPy Academy te beginnen?
Ervaring vooraf is niet nodig. Pandas & NumPy Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 4 van 4.
Hoe lang duurt de les “Datums correct parseren”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Pandas & NumPy Academy?
Ja. Elke les over Pandas & NumPy Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Gegevenstypen van kolommen inspecteren
- Converteren met astype()
- Categorisch gegevenstype
- Datums correct parseren