Tolka datum korrekt
Tolka datumsträngar som datetime64 med pd.to_datetime, hantera flera format och ange ett DatetimeIndex.
Tolka datum korrekt är en gratis lektion i Pandas & NumPy Academy på CoddyKit. Detta är lektion 4 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Pandas & NumPy Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Pandas & NumPy Academy innehåller totalt 4 lektioner.
Varför datumtolkning är viktig
Datum- och tidsdata finns överallt i verkliga dataset – tidsstämplar för transaktioner, födelsedatum, händelseloggar och finansiella perioder. När datum lagras som strängar (datatypen object) kan du inte beräkna tidsintervall, göra omprovtagning per månad eller sortera kronologiskt. Genom att konvertera strängar till Pandas-datatypen datetime64 får du tillgång till hela API:et för tidsserier och kan utföra tidsanalys.
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'))Grunderna i pd.to_datetime()
pd.to_datetime(series) är den primära funktionen för att konvertera strängkolumner till datetime64. Den känner automatiskt igen de flesta vanliga datumformat, såsom ISO 8601 samt amerikanska och europeiska datumformat, utan att en formatsträng krävs. Resultatet är en Series med datatypen datetime64[ns] – precision på nanosekundnivå, med stöd för tidsstämplar från 1677 till 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]Ange argumentet format=
När automatisk tolkning är för långsam eller tvetydig, till exempel när '01-02-03' kan betyda 2 januari 2003, 1 februari 2003 eller 3 februari 2001, anger du den exakta formatsträngen med Pythons strftime-koder. Det är också betydligt snabbare – på stora dataset kan explicit formattolkning vara 10 gånger snabbare än automatisk tolkning, eftersom Pandas inte behöver prova flera mönster.
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 felaktiga datum
Verkliga dataset innehåller ofta stavfel eller platshållarsträngar som 'TBD', 'N/A' eller '99/99/9999' i datumkolumner. Om du skickar med errors='coerce' instrueras pd.to_datetime() att konvertera värden som inte kan tolkas till NaT (Not a Time – datetime-motsvarigheten till NaN) i stället för att utlösa ett undantag. Då kan du identifiera och hantera felaktiga datum 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 effektivaste stället att tolka datum är vid inläsningen med parametern parse_dates i pd.read_csv(). Ange en lista med kolumnnamn eller index som ska tolkas som datum. Då undviker du ett separat efterbearbetningssteg, och det går ofta snabbare eftersom Pandas hanterar detta under CSV-tolkningen på C-nivå.
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]Accessorn .dt för datumkomponenter
När en kolumn har datatypen datetime64 ger accessorn .dt tillgång till dussintals egenskaper och metoder. Du kan hämta .dt.year, .dt.month, .dt.day, .dt.hour, .dt.dayofweek (0=måndag) och .dt.is_month_end. Dessa används för funktionsskapande i prognoser för tidsserier och för att gruppera data efter tidsperiod.
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']])Ange ett DatetimeIndex
Vid tidsserieanalys är det standard att ange datumkolumnen som DataFrame-objektets index. Med ett DatetimeIndex kan du använda tidsbaserad segmentering (df['2024'], df['2024-01':'2024-06']), göra omprovtagning till valfri frekvens och få tillgång till hela Pandas API för tidsserier. Använd set_index() eller skicka med 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'])Hantera flera datumformat
Om en datumkolumn innehåller en blandning av format, till exempel om vissa rader har ISO-datum och andra datum i amerikanskt format, kan du inte ange en enda formatsträng. Skicka med format='mixed' (Pandas 2.0+) för att aktivera radvis formatidentifiering, eller förrensa kolumnen med regex för att normalisera alla datum till ett format innan du anropar 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:00Tidszonsmedvetna datumtider
Tidsstämplar från verkligheten innehåller ofta information om tidszon. pd.to_datetime() kan tolka strängar med UTC-förskjutning, till exempel '2024-01-15 08:30:00+05:30', och lagra dem som tidszonsmedvetna datetime64-värden. Använd .dt.tz_convert('UTC') för att normalisera alla tidsstämplar till en gemensam tidszon så att jämförelser och beräkningar blir korrekta.
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'])Beräkna datumskillnader
Aritmetik mellan två datetime64-kolumner ger en Timedelta-Series. Du kan hämta antalet dagar, timmar eller sekunder från en Timedelta med egenskaperna .dt.days, .dt.seconds och .dt.total_seconds(). Detta är standardmetoden för att beräkna ålder, varaktighet eller funktioner som anger antal dagar sedan den senaste händelsen.
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() för att generera datum
pd.date_range(start, end, freq=) genererar en sekvens med jämnt fördelade datum som ett DatetimeIndex. Detta är användbart när du vill skapa en komplett tidsaxel som du kan indexjustera dina data mot – så att varje kalenderperiod visas i resultatet även om inga händelser inträffade den dagen. Vanliga värden för freq är: 'D' (dagligen), 'ME' (månadsslut) och 'h' (varje timme).
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-31Snabbtest
Testa din förståelse av hur datum tolkas korrekt i Pandas.
Lektionssammanfattning
I den här lektionen har du lärt dig att pd.to_datetime() konverterar strängkolumner till datetime64, att format= anger det exakta mönstret för bättre hastighet och precision, och att errors='coerce' omvandlar felaktiga datum till NaT i stället för att programmet kraschar. Accessorn .dt hämtar år, månad, dag och andra komponenter, och genom att ange ett DatetimeIndex aktiveras tidsbaserad segmentering. Nästa steg är att utforska accessorn .str för vektoriserade strängoperationer.
Lär dig Python med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 30
- Lektioner
- 120
Vanliga frågor
Är lektionen ”Tolka datum korrekt” gratis?
Ja – hela texten till ”Tolka datum korrekt” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Pandas & NumPy Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Pandas & NumPy Academy innehåller totalt 4 lektioner.
Vad lär jag mig i ”Tolka datum korrekt”?
Tolka datumsträngar som datetime64 med pd.to_datetime, hantera flera format och ange ett DatetimeIndex. Ni övar på Pandas & NumPy Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Pandas & NumPy Academy?
Du behöver inga förkunskaper. Utbildningen i Pandas & NumPy Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.
Hur lång tid tar lektionen ”Tolka datum korrekt”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Pandas & NumPy Academy-lektionen?
Ja. Varje Pandas & NumPy Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.