Korrekt fortolkning af datoer
Fortolk datostringsværdier som datetime64 med pd.to_datetime, håndtér flere formater, og indstil et DatetimeIndex.
Korrekt fortolkning af datoer er en gratis Pandas & NumPy Academy-lektion på CoddyKit. Dette er lektion 4 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Pandas & NumPy Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Pandas & NumPy Academy-kurset indeholder 4 lektioner i alt.
Hvorfor fortolkning af datoer er vigtig
Dato- og tidsdata findes overalt i datasæt fra den virkelige verden — tidsstempler for transaktioner, fødselsdatoer, hændelseslogge og regnskabsperioder. Når datoer gemmes som strenge (datatypen object), kan du ikke beregne varigheder, aggregere efter måned eller sortere kronologisk. Når du konverterer strenge til Pandas' datetime64-datatype, får du adgang til hele API'et til tidsserier, og tidsmæssig analyse bliver mulig.
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'))Grundlæggende om pd.to_datetime()
pd.to_datetime(series) er den primære funktion til at konvertere strengkolonner til datetime64. Den kan automatisk genkende de fleste almindelige datoformater (ISO 8601, amerikanske datoer og europæiske datoer) uden at kræve en formatstreng. Resultatet er en Series med datatypen datetime64[ns] — nanosekundpræcision, der kan gemme tidsstempler fra 1677 til 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]Angivelse af argumentet format=
Når automatisk fortolkning er for langsom eller tvetydig (f.eks. kan '01-02-03' betyde 2. januar 2003, 1. februar 2003 eller 3. februar 2001), skal du angive den nøjagtige formatstreng ved hjælp af Pythons strftime-koder. Det er også betydeligt hurtigere — på store datasæt kan fortolkning med et eksplicit format være 10 gange hurtigere end automatisk fortolkning, fordi Pandas ikke behøver at afprøve flere mønstre.
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' til ugyldige datoer
Datasæt fra den virkelige verden indeholder ofte slåfejl eller pladsholderstrenge som 'TBD', 'N/A' eller '99/99/9999' i datokolonner. Hvis du angiver errors='coerce', får pd.to_datetime() besked på at konvertere værdier, der ikke kan fortolkes, til NaT (Not a Time — datetime-ækvivalenten til NaN) i stedet for at udløse en undtagelse. Det gør det muligt at identificere og håndtere ugyldige datoer separat.
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 i read_csv()
Det mest effektive tidspunkt at fortolke datoer på er ved indlæsning ved hjælp af parameteren parse_dates i pd.read_csv(). Angiv en liste med kolonnenavne (eller indekser), der skal fortolkes som datoer. Det eliminerer et separat efterbehandlingstrin og er ofte hurtigere, fordi Pandas håndterer det under CSV-fortolkningen på C-niveau.
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]Adgangen .dt til datokomponenter
Når en kolonne har datatypen datetime64, giver .dt-adgangen adgang til snesevis af egenskaber og metoder. Du kan udtrække .dt.year, .dt.month, .dt.day, .dt.hour, .dt.dayofweek (0=mandag) og .dt.is_month_end. De bruges til konstruktion af egenskaber i prognoser for tidsserier og til gruppering af data efter tidsperiode.
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']])Indstilling af et DatetimeIndex
Ved analyse af tidsserier er det standard at indstille datokolonnen som DataFramets indeks. Med et DatetimeIndex kan du bruge tidsbaseret udsnit (df['2024'], df['2024-01':'2024-06']), aggregere til enhver frekvens og få adgang til hele Pandas' API til tidsserier. Brug set_index(), eller angiv index_col i 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'])Håndtering af flere datoformater
Hvis en datokolonne indeholder en blanding af formater (f.eks. hvis nogle rækker har ISO-datoer, mens andre har datoer i amerikansk format), kan du ikke angive én enkelt formatstreng. Angiv format='mixed' (Pandas 2.0+) for at tillade registrering af formatet række for række, eller rens kolonnen på forhånd med regex for at normalisere alle datoer til ét format, før du kalder pd.to_datetime().
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:00Tidszonebevidste datotider
Tidsstempler fra den virkelige verden indeholder ofte oplysninger om tidszone. pd.to_datetime() kan fortolke strenge med UTC-forskydning (f.eks. '2024-01-15 08:30:00+05:30') og gemme dem som tidszonebevidst datetime64. Brug .dt.tz_convert('UTC') til at normalisere alle tidsstempler til en fælles tidszone, så sammenligninger og beregninger bliver korrekte.
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'])Beregning af forskelle mellem datoer
Aritmetik mellem to datetime64-kolonner producerer en Timedelta-Series. Du kan udtrække antallet af dage, timer eller sekunder fra en Timedelta ved hjælp af egenskaberne .dt.days, .dt.seconds og .dt.total_seconds(). Det er standardmetoden til at beregne alder, varighed eller egenskaber som antal dage siden seneste hændelse.
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() til generering af datoer
pd.date_range(start, end, freq=) genererer en sekvens af jævnt fordelte datoer som et DatetimeIndex. Det er nyttigt til at oprette en komplet tidsakse, som du kan genindeksere dine data efter — så hver kalenderperiode vises i resultatet, selv hvis der ikke var nogen hændelser den pågældende dag. Almindelige værdier for freq: 'D' (dagligt), 'ME' (månedsslutning), 'h' (hver time).
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-31Hurtig kontrol
Test din forståelse af korrekt datofortolkning i Pandas.
Opsummering af lektionen
I denne lektion har du lært, at pd.to_datetime() konverterer strengkolonner til datetime64, at format= angiver det nøjagtige mønster for hastighed og nøjagtighed, og at errors='coerce' konverterer ugyldige datoer til NaT i stedet for at få programmet til at gå ned. .dt-adgangen udtrækker år, måned, dag og andre komponenter, og et DatetimeIndex gør tidsbaserede udsnit mulige. Dernæst udforsker vi .str-adgangen til vektoriserede strengoperationer.
Lær Python med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 30
- Lektioner
- 120
Ofte stillede spørgsmål
Er lektionen “Korrekt fortolkning af datoer” gratis?
Ja — hele teksten til “Korrekt fortolkning af datoer” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Pandas & NumPy Academy-kurset, skal du opgradere til CoddyKit PRO. Pandas & NumPy Academy-kurset indeholder 4 lektioner i alt.
Hvad lærer jeg i “Korrekt fortolkning af datoer”?
Fortolk datostringsværdier som datetime64 med pd.to_datetime, håndtér flere formater, og indstil et DatetimeIndex. Du øver dig i Pandas & NumPy Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på Pandas & NumPy Academy?
Der kræves ingen tidligere erfaring. Pandas & NumPy Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 4 af 4.
Hvor lang tid tager lektionen “Korrekt fortolkning af datoer”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne Pandas & NumPy Academy-lektion?
Ja. Alle Pandas & NumPy Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.
Alle lektioner i dette kursus
- Undersøgelse af kolonners datatyper
- Typetilpasning med astype()
- Kategorisk datatype
- Korrekt fortolkning af datoer