0Pricing
Pandas & NumPy Academy · Lekcja

Wyodrębnianie cech czasowych

Użyj akcesora .dt, aby wyodrębnić z kolumny datetime rok, miesiąc, dzień, day_of_week i godzinę na potrzeby inżynierii cech.

Wyodrębnianie cech czasowych to bezpłatna lekcja Pandas & NumPy Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Pandas & NumPy Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Pandas & NumPy Academy zawiera 4 lekcji w sumie.

Dlaczego wyodrębniać cechy czasowe?

Surowa kolumna typu datetime64 jest nieczytelna dla większości algorytmów uczenia maszynowego — nie potrafią one rozpoznać, że 2024-12-25 jest świętem ani że Friday wpływa na wyższą sprzedaż detaliczną. Inżynieria cech czasowych wyodrębnia z kolumn daty i czasu znaczące składniki — rok, miesiąc, dzień, dzień tygodnia i godzinę — jako osobne kolumny liczbowe lub kategoryczne, z których modele i funkcje analityczne mogą korzystać bezpośrednio.

Akcesor .dt

Gdy kolumna DataFrame ma typ datetime64, akcesor .dt udostępnia wektorowo wszystkie właściwości i metody daty i czasu. Zamiast stosować funkcję języka Python do każdego wiersza, należy użyć df['date'].dt.year, a Pandas obliczy rok dla każdego wiersza w ramach jednej szybkiej operacji. Ten sam akcesor działa na kolumnach typu timedelta64, udostępniając inne właściwości.

import pandas as pd

df = pd.DataFrame({
    'event_date': pd.date_range('2024-01-01', periods=8, freq='D'),
    'revenue': [200, 350, 280, 310, 420, 380, 190, 260]
})

# Access datetime properties with .dt
print(df['event_date'].dt.year)    # 2024 for all
print(df['event_date'].dt.month)   # 1 for all
print(df['event_date'].dt.day[:5]) # 1, 2, 3, 4, 5

Wyodrębnianie składników daty

Najczęściej używane właściwości .dt dotyczące składników daty to: .dt.year, .dt.month, .dt.day, .dt.day_of_week (0 = poniedziałek, a 6 = niedziela), .dt.day_of_year, .dt.week lub .dt.isocalendar().week, .dt.quarter oraz .dt.days_in_month. Każda z nich zwraca Series liczb całkowity, których można bezpośrednio użyć jako cech.

df['year']        = df['event_date'].dt.year
df['month']       = df['event_date'].dt.month
df['day']         = df['event_date'].dt.day
df['day_of_week'] = df['event_date'].dt.day_of_week  # 0=Mon
df['quarter']     = df['event_date'].dt.quarter
df['day_of_year'] = df['event_date'].dt.day_of_year

print(df[['event_date', 'year', 'month', 'day',
           'day_of_week', 'quarter']].head())

Wyodrębnianie składników czasu

W przypadku kolumn daty i czasu, które zawierają również informacje o godzinie, należy użyć .dt.hour, .dt.minute, .dt.second oraz .dt.microsecond. Są one kluczowe w analizie śróddziennej, modelowaniu zachowań użytkowników (wzorce poranne i wieczorne) oraz w każdym systemie, w którym pora dnia wpływa na zmienną docelową.

df_ts = pd.DataFrame({
    'timestamp': pd.date_range('2024-01-01', periods=6, freq='4h'),
    'logins': [50, 200, 320, 280, 180, 90]
})

df_ts['hour']   = df_ts['timestamp'].dt.hour
df_ts['minute'] = df_ts['timestamp'].dt.minute
df_ts['date']   = df_ts['timestamp'].dt.date    # Python date object
df_ts['time']   = df_ts['timestamp'].dt.time    # Python time object
print(df_ts[['timestamp', 'hour', 'date']].head())

Nazwy dni i miesięcy

Aby uzyskać etykiety czytelne dla człowieka, należy użyć .dt.day_name() i .dt.month_name(), które zwracają nazwy tekstowe, takie jak 'Monday' i 'January'. Są one przydatne podczas wyświetlania danych w raportach oraz tworzenia cech kategorycznych kodujących wpływ dnia tygodnia lub miesiąca. Można również przekazać parametr locale, aby uzyskać nazwy w innych językach.

df['day_name']   = df['event_date'].dt.day_name()
df['month_name'] = df['event_date'].dt.month_name()

print(df[['event_date', 'day_name', 'month_name']].head(5))
# event_date day_name month_name
# 2024-01-01   Monday    January
# 2024-01-02  Tuesday    January
# 2024-01-03  Wednesday  January

Flaga weekendu i dnia roboczego

Bardzo często używaną cechą jest flaga logiczna wskazująca, czy dana data przypada w weekend. day_of_week >= 5 zwraca True dla soboty (5) i niedzieli (6). W przypadku bardziej zaawansowanych cech związanych z kalendarzem biznesowym numpy.busdaycalendar obsługuje dni świąteczne, jednak w większości przypadków prosty podział na dni robocze i weekend oddaje większość tego efektu.

df['is_weekend'] = df['event_date'].dt.day_of_week >= 5
df['is_weekday'] = ~df['is_weekend']

# Compare weekend vs weekday revenue
print(df.groupby('is_weekend')['revenue'].mean().round(1))
# is_weekend
# False    308.3  <- weekday average
# True     285.0  <- weekend average

Flagi początku i końca okresu

Akcesor .dt udostępnia również właściwości logiczne wskazujące, czy data przypada na początek lub koniec okresu: .dt.is_month_start, .dt.is_month_end, .dt.is_quarter_start, .dt.is_quarter_end, .dt.is_year_start oraz .dt.is_year_end. Są one przydatne do wykrywania okresów sprawozdawczych, cykli rozliczeniowych i sezonowych efektów granicznych.

dates_series = pd.Series(
    pd.date_range('2024-01-28', periods=10, freq='D')
)

print(dates_series[dates_series.dt.is_month_start].values)
# ['2024-02-01']

print(dates_series[dates_series.dt.is_month_end].values)
# ['2024-01-31']

Cykliczne kodowanie cech czasowych

Miesiąc i godzina mają charakter cykliczny — grudzień (12) jest blisko stycznia (1), a 23:00 jest blisko 00:00. Traktowanie ich jak liniowych liczb całkowitych (1–12 lub 0–23) wprowadza większość modeli w błąd. Cechy cykliczne należy kodować za pomocą transformacji sinusoidalnej i cosinusoidalnej: sin(2π × value / max_value) oraz cos(2π × value / max_value). W ten sposób struktura kołowa zostaje odwzorowana w dwóch kolumnach liczbowych, z których modele mogą poprawnie korzystać.

import numpy as np

# Cyclical encoding for month (1-12)
df['month_sin'] = np.sin(2 * np.pi * df['month'] / 12)
df['month_cos'] = np.cos(2 * np.pi * df['month'] / 12)

# Cyclical encoding for day of week (0-6)
df['dow_sin'] = np.sin(2 * np.pi * df['day_of_week'] / 7)
df['dow_cos'] = np.cos(2 * np.pi * df['day_of_week'] / 7)

print(df[['month', 'month_sin', 'month_cos']].head().round(3))

Operacje arytmetyczne na timedel­ta

Odjęcie od siebie dwóch kolumn daty i czasu tworzy Series typu timedelta64. Akcesor .dt dla Series typu timedelta udostępnia .dt.days, .dt.seconds oraz .dt.total_seconds(). Dzięki temu można obliczać czas trwania zdarzeń, czas od ostatniego zakupu oraz wiek w dniach — wszystko jako kolumny liczbowe gotowe do dalszej analizy.

df_orders = pd.DataFrame({
    'order_date':    pd.to_datetime(['2024-01-01', '2024-02-10', '2024-03-05']),
    'delivery_date': pd.to_datetime(['2024-01-04', '2024-02-13', '2024-03-12'])
})

# Compute delivery time in days
df_orders['delivery_days'] = (
    df_orders['delivery_date'] - df_orders['order_date']
).dt.days
print(df_orders)

Używanie właściwości .dt indeksu

Gdy data i czas znajdują się w indeksie DataFrame (DatetimeIndex), a nie w kolumnie, należy uzyskać dostęp do tych samych właściwości bezpośrednio przez indeks, bez użycia .dt: df.index.year, df.index.month, df.index.day_of_week itd. Można dodać je bezpośrednio jako nowe kolumny: df['month'] = df.index.month.

df_indexed = df.set_index('event_date')

# Access components directly on the DatetimeIndex
print(df_indexed.index.month[:3])  # [1, 1, 1]
print(df_indexed.index.day_of_week[:3])  # [0, 1, 2]

# Add as new columns
df_indexed['month']   = df_indexed.index.month
df_indexed['weekday'] = df_indexed.index.day_of_week
print(df_indexed.head())

Pełny potok inżynierii cech czasowych

Oto kompletna funkcja inżynierii cech czasowych, która przyjmuje DataFrame z kolumną daty i czasu oraz zwraca go wzbogaconego o najbardziej przydatne cechy czasowe. Ten schemat można bezpośrednio zastosować na początku dowolnego potoku uczenia maszynowego lub analizy pracującego z danymi zdarzeń opatrzonymi znacznikami czasu.

def add_temporal_features(df, date_col):
    dt = df[date_col].dt
    df['year']       = dt.year
    df['month']      = dt.month
    df['day']        = dt.day
    df['day_of_week'] = dt.day_of_week
    df['quarter']    = dt.quarter
    df['is_weekend'] = dt.day_of_week >= 5
    df['month_sin']  = (2 * 3.14159 * dt.month / 12).__round__(4)
    df['month_cos']  = (2 * 3.14159 * dt.month / 12).__round__(4)
    return df

result = add_temporal_features(df.copy(), 'event_date')
print(result.columns.tolist())

Szybkie sprawdzenie

Sprawdź swoją wiedzę na temat wyodrębniania cech czasowych z kolumn daty i czasu.

Podsumowanie lekcji

W tej lekcji nauczyli się Państwo, że: akcesor .dt zapewnia wektorowy dostęp do wszystkich właściwości daty i czasu; często wyodrębniane cechy to rok, miesiąc, dzień, day_of_week, godzina i kwartał; kodowanie cykliczne za pomocą sinusa i cosinusa obsługuje cykliczny charakter godzin i miesięcy; a operacje arytmetyczne na timedelta pozwalają obliczać czas trwania w dniach lub sekundach. W następnym kroku poznamy architekturę obiektów figure i axes w Matplotlib, używaną do tworzenia wykresów o jakości publikacyjnej.

Często zadawane pytania

Czy lekcja „Wyodrębnianie cech czasowych” jest bezpłatna?

Tak — pełny tekst „Wyodrębnianie cech czasowych” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Pandas & NumPy Academy, przejdź na CoddyKit PRO. Kurs Pandas & NumPy Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Wyodrębnianie cech czasowych”?

Użyj akcesora .dt, aby wyodrębnić z kolumny datetime rok, miesiąc, dzień, day_of_week i godzinę na potrzeby inżynierii cech. Ćwiczysz Pandas & NumPy Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Pandas & NumPy Academy?

Nie wymagamy żadnego doświadczenia. Pandas & NumPy Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Wyodrębnianie cech czasowych”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Pandas & NumPy Academy?

Tak. Każda lekcja Pandas & NumPy Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. DatetimeIndex i zakresy okresów
  2. Resampling szeregów czasowych
  3. Przesuwanie i cechy opóźnione
  4. Wyodrębnianie cech czasowych
← Powrót do Pandas & NumPy Academy