Pandas & NumPy Academy · Lezione

Estrarre caratteristiche temporali

Usi l'accessor .dt per estrarre anno, mese, giorno, day_of_week e ora da una colonna datetime per la feature engineering.

Lezione 4 di 413 passaggi

Estrarre caratteristiche temporali è una lezione Pandas & NumPy Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Pandas & NumPy Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Pandas & NumPy Academy include 4 lezioni in totale.

Perché estrarre le feature temporali?

Una colonna datetime64 grezza è poco interpretabile per la maggior parte degli algoritmi di machine learning: non sono in grado di capire che 2024-12-25 è un giorno festivo o che il Friday favorisce vendite al dettaglio più elevate. Il feature engineering temporale estrae componenti significative dalle colonne datetime — anno, mese, giorno, giorno della settimana, ora — trasformandole in colonne numeriche o categoriche separate, che i modelli e le funzioni di analisi possono utilizzare direttamente.

L'accessor .dt

Quando una colonna di un DataFrame ha il tipo datetime64, l'accessor .dt espone vettorialmente tutte le proprietà e i metodi per datetime. Anziché applicare una funzione Python riga per riga, si scrive df['date'].dt.year e Pandas calcola l'anno per ogni riga in un'unica operazione rapida. Lo stesso accessor funziona sulle colonne timedelta64, con proprietà diverse.

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

Estrarre le componenti della data

Le proprietà .dt più utilizzate per le componenti della data sono: .dt.year, .dt.month, .dt.day, .dt.day_of_week (0=lunedì fino a 6=domenica), .dt.day_of_year, .dt.week o .dt.isocalendar().week, .dt.quarter e .dt.days_in_month. Ciascuna restituisce una Series di numeri interi utilizzabile direttamente come feature.

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())

Estrarre le componenti dell'ora

Per le colonne datetime che includono informazioni sull'ora, e non soltanto la data, usi .dt.hour, .dt.minute, .dt.second e .dt.microsecond. Sono fondamentali per l'analisi intraday, la modellazione del comportamento degli utenti (schemi mattutini rispetto a quelli serali) e tutti i sistemi in cui l'ora del giorno influisce sulla variabile obiettivo.

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())

Nome del giorno e del mese

Per ottenere etichette leggibili, usi .dt.day_name() e .dt.month_name(), che restituiscono nomi testuali come 'Monday' e 'January'. Sono utili per la visualizzazione nei report e per creare feature categoriche che codificano gli effetti del giorno della settimana o del mese. È inoltre possibile passare una locale per ottenere i nomi in altre lingue.

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

Flag del fine settimana e del giorno lavorativo

Una feature molto comune è un flag booleano che indica se una data cade nel fine settimana. day_of_week >= 5 restituisce True per sabato (5) e domenica (6). Per feature più sofisticate basate sul calendario lavorativo, numpy.busdaycalendar gestisce i giorni festivi; nella maggior parte dei casi, però, la semplice distinzione tra giorni feriali e fine settimana cattura gran parte dell'effetto.

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

Flag di inizio e fine periodo

L'accessor .dt fornisce anche proprietà booleane che identificano se una data si trova all'inizio o alla fine di un periodo: .dt.is_month_start, .dt.is_month_end, .dt.is_quarter_start, .dt.is_quarter_end, .dt.is_year_start e .dt.is_year_end. Sono utili per rilevare periodi di rendicontazione, cicli di fatturazione ed effetti stagionali ai confini dei periodi.

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']

Codifica ciclica delle feature temporali

Il mese e l'ora sono ciclici: dicembre (12) è vicino a gennaio (1) e le 23:00 sono vicine alle 00:00. Trattarli come numeri interi lineari (1-12 o 0-23) induce in errore la maggior parte dei modelli. Codifichi le feature cicliche usando le trasformazioni seno e coseno: sin(2π × value / max_value) e cos(2π × value / max_value). In questo modo la struttura circolare viene rappresentata in due colonne numeriche che i modelli possono utilizzare correttamente.

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))

Operazioni aritmetiche con timedelta

La sottrazione tra due colonne datetime produce una Series timedelta64. L'accessor .dt sulle Series timedelta espone .dt.days, .dt.seconds e .dt.total_seconds(). Ciò consente di calcolare la durata degli eventi, il tempo trascorso dall'ultimo acquisto e l'età in giorni, tutto sotto forma di colonne numeriche pronte per ulteriori analisi.

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)

Usare le proprietà .dt dell'indice

Quando il datetime è l'indice del DataFrame (un DatetimeIndex) anziché una colonna, acceda alle stesse proprietà direttamente sull'indice, senza .dt: df.index.year, df.index.month, df.index.day_of_week e così via. Può aggiungerle direttamente come nuove colonne: 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())

Pipeline completa di feature engineering temporale

Ecco una funzione completa di feature engineering temporale che riceve un DataFrame con una colonna datetime e lo restituisce arricchito con le feature temporali più utili. Questo schema è direttamente applicabile all'inizio di qualsiasi pipeline di machine learning o analisi che lavori con dati di eventi contrassegnati temporalmente.

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())

Verifica rapida

Verifichi la Sua comprensione dell'estrazione delle feature temporali dalle colonne datetime.

Riepilogo della lezione

In questa lezione ha imparato che l'accessor .dt consente di accedere vettorialmente a tutte le proprietà datetime; tra le feature estratte più comuni ci sono year, month, day, day_of_week, hour, quarter; la codifica ciclica con seno e coseno gestisce la natura circolare delle ore e dei mesi; e le operazioni aritmetiche con timedelta consentono di calcolare durate in giorni o secondi. Ora esploreremo l'architettura di figure e assi di Matplotlib per creare grafici di qualità editoriale.

Gratis per iniziare

Impara Python con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi
30
Lezioni
120

Domande Frequenti

La lezione «Estrarre caratteristiche temporali» è gratuita?

Sì — il testo completo di «Estrarre caratteristiche temporali» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Pandas & NumPy Academy, passa a CoddyKit PRO. Il corso Pandas & NumPy Academy include 4 lezioni in totale.

Cosa imparerò in «Estrarre caratteristiche temporali»?

Usi l'accessor .dt per estrarre anno, mese, giorno, day_of_week e ora da una colonna datetime per la feature engineering. Eserciti Pandas & NumPy Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Pandas & NumPy Academy?

Non è richiesta alcuna esperienza precedente. Pandas & NumPy Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Estrarre caratteristiche temporali»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Pandas & NumPy Academy?

Sì. Ogni lezione Pandas & NumPy Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. DatetimeIndex e intervalli di periodi
  2. Ricampionare serie temporali
  3. Shift e variabili ritardate
  4. Estrarre caratteristiche temporali
← Torna a Pandas & NumPy Academy