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.
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, 5Estrarre 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 JanuaryFlag 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 averageFlag 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.
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
- DatetimeIndex e intervalli di periodi
- Ricampionare serie temporali
- Shift e variabili ritardate
- Estrarre caratteristiche temporali