Pandas & NumPy Academy · Lezione

Analizzare correttamente le date

Analizzi le stringhe di data convertendole in datetime64 con pd.to_datetime, gestisca più formati e imposti un DatetimeIndex.

Lezione 4 di 413 passaggi

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

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

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

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

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

Verifica 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.

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

  1. Esaminare i tipi di dati delle colonne
  2. Conversione con astype()
  3. Tipo di dati categorico
  4. Analizzare correttamente le date
← Torna a Pandas & NumPy Academy