Pandas & NumPy Academy · Lektion

Tolka datum korrekt

Tolka datumsträngar som datetime64 med pd.to_datetime, hantera flera format och ange ett DatetimeIndex.

Lektion 4 av 413 steg

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

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

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

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

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

Snabbtest

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.

Gratis att börja

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.

Alla lektioner i den här kursen

  1. Inspektera kolumnernas datatyper
  2. Typkonvertering med astype()
  3. Kategorisk datatyp
  4. Tolka datum korrekt
← Tillbaka till Pandas & NumPy Academy