Analizzare correttamente le date
Analizzi le stringhe di data convertendole in datetime64 con pd.to_datetime, gestisca più formati e imposti un DatetimeIndex.
Analizzare correttamente le date è 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é l’analisi delle date è importante
I dati relativi a date e orari sono onnipresenti nei dataset reali: timestamp delle transazioni, date di nascita, log degli eventi e periodi finanziari. Quando le date sono memorizzate come stringhe (dtype object), non è possibile calcolare durate, ricampionare per mese o ordinare cronologicamente. Convertire le stringhe nel dtype datetime64 di Pandas consente di usare l’intera API delle serie temporali e rende possibile l’analisi temporale.
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'))Nozioni di base su pd.to_datetime()
pd.to_datetime(series) è la funzione principale per convertire le colonne stringa in datetime64. È abbastanza intelligente da riconoscere automaticamente la maggior parte dei formati di data comuni (ISO 8601, formato statunitense, formato europeo) senza richiedere una stringa di formato. Il risultato è una Series con dtype datetime64[ns], con precisione al nanosecondo e in grado di memorizzare timestamp dal 1677 al 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]Specificare l’argomento format=
Quando l’inferenza automatica è troppo lenta o ambigua (ad esempio, '01-02-03' potrebbe indicare il 2 gennaio 2003, il 1° febbraio 2003 oppure il 3 febbraio 2001), fornisca la stringa di formato esatta usando i codici strftime di Python. È anche notevolmente più veloce: sui dataset di grandi dimensioni, l’analisi con un formato esplicito può essere 10 volte più rapida dell’inferenza automatica, perché Pandas non deve provare più modelli.
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' per le date non valide
I dataset reali contengono spesso refusi o stringhe segnaposto come 'TBD', 'N/A' o '99/99/9999' nelle colonne delle date. Passare errors='coerce' indica a pd.to_datetime() di convertire i valori non analizzabili in NaT (Not a Time, l’equivalente di NaN per i datetime) invece di generare un’eccezione. In questo modo può identificare e gestire separatamente le date non valide.
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 in read_csv()
Il punto più efficiente in cui analizzare le date è il momento del caricamento, usando il parametro parse_dates di pd.read_csv(). Passi un elenco di nomi di colonne (o indici) che devono essere analizzati come date. Questo evita un passaggio separato di post-elaborazione ed è spesso più veloce, perché Pandas gestisce l’operazione durante l’analisi CSV a livello C.
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]L’accessor .dt per i componenti delle date
Quando una colonna ha il dtype datetime64, l’accessor .dt mette a disposizione decine di proprietà e metodi. Può estrarre .dt.year, .dt.month, .dt.day, .dt.hour, .dt.dayofweek (0=lunedì) e .dt.is_month_end. Questi strumenti vengono usati per la feature engineering nelle previsioni delle serie temporali e per raggruppare i dati per periodo.
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']])Impostazione di un DatetimeIndex
Nell’analisi delle serie temporali, è prassi standard impostare la colonna datetime come indice del DataFrame. Con un DatetimeIndex può usare il filtraggio basato sul tempo (df['2024'], df['2024-01':'2024-06']), ricampionare a qualsiasi frequenza e accedere all’intera API delle serie temporali di Pandas. Usi set_index() oppure passi index_col a 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'])Gestione di più formati di data
Se una colonna di date contiene un insieme di formati (ad esempio, alcune righe contengono date ISO e altre date in formato statunitense), non può specificare un’unica stringa di formato. Passi format='mixed' (Pandas 2.0 o versioni successive) per consentire il rilevamento del formato riga per riga, oppure esegua una pre-pulizia della colonna con regex per normalizzare tutte le date in un unico formato prima di chiamare 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:00Datetime con fuso orario
I timestamp del mondo reale spesso includono informazioni sul fuso orario. pd.to_datetime() può analizzare stringhe con offset UTC (ad esempio, '2024-01-15 08:30:00+05:30') e memorizzarle come datetime64 con fuso orario. Usi .dt.tz_convert('UTC') per normalizzare tutti i timestamp a un fuso orario comune, così da eseguire confronti e calcoli corretti.
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'])Calcolo delle differenze tra date
L’aritmetica tra due colonne datetime64 produce una Series di tipo Timedelta. Può estrarre il numero di giorni, ore o secondi da un Timedelta usando le proprietà .dt.days, .dt.seconds e .dt.total_seconds(). Questo è il modo standard per calcolare l’età, la durata o il numero di giorni dall’ultimo evento come feature.
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() per generare date
pd.date_range(start, end, freq=) genera una sequenza di date equidistanti come DatetimeIndex. È utile per creare una griglia temporale completa sulla quale riallineare i dati, assicurando che ogni periodo del calendario compaia nell’output anche quando in quel giorno non si sono verificati eventi. Valori comuni di freq: 'D' (giornaliero), 'ME' (fine mese), 'h' (orario).
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-31Verifica rapida
Verifichi la Sua comprensione dell’analisi corretta delle date in Pandas.
Riepilogo della lezione
In questa lezione ha imparato che pd.to_datetime() converte le colonne stringa in datetime64, format= specifica il modello esatto per ottenere maggiore velocità e precisione, mentre errors='coerce' trasforma le date non valide in NaT invece di causare un errore. L’accessor .dt estrae l’anno, il mese, il giorno e altri componenti, mentre l’impostazione di un DatetimeIndex abilita il filtraggio basato sul tempo. Ora vedremo l’accessor .str per le operazioni vettorializzate sulle stringhe.
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 «Analizzare correttamente le date» è gratuita?
Sì — il testo completo di «Analizzare correttamente le date» è 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 «Analizzare correttamente le date»?
Analizzi le stringhe di data convertendole in datetime64 con pd.to_datetime, gestisca più formati e imposti un DatetimeIndex. 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 «Analizzare correttamente le date»?
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
- Esaminare i tipi di dati delle colonne
- Conversione con astype()
- Tipo di dati categorico
- Analizzare correttamente le date