Pandas & NumPy Academy · Les

Datums correct parseren

Parse datums als strings naar datetime64 met pd.to_datetime, verwerk meerdere notaties en stel een DatetimeIndex in.

Les 4 van 413 stappen

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 = second

errors='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())  # 2

parse_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:00

Datumtijden 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             15

pd.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-31

Korte 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.

Gratis beginnen

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

  1. Gegevenstypen van kolommen inspecteren
  2. Converteren met astype()
  3. Categorisch gegevenstype
  4. Datums correct parseren
← Terug naar Pandas & NumPy Academy