0Pricing
Pandas & NumPy Academy · Lezione

Allineamento e reindicizzazione degli indici

Allinei due DataFrame a un indice comune con reindex(), riempia le etichette mancanti e comprenda come le operazioni aritmetiche allineino gli indici.

Allineamento e reindicizzazione degli indici è una lezione Pandas & NumPy Academy gratuita su CoddyKit. Questa è la lezione 3 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.

Come Pandas allinea gli indici

Uno dei comportamenti più potenti, e talvolta sorprendenti, di Pandas è l'allineamento automatico degli indici. Quando somma, sottrae o combina in altro modo due Series o DataFrame, Pandas li allinea prima in base alle etichette dell'indice, quindi esegue l'operazione. Le etichette corrispondenti vengono elaborate; quelle non corrispondenti producono NaN. Questo evita errori silenziosi dovuti a dati non allineati e consente di combinare in sicurezza dati provenienti da fonti diverse senza doverli ordinare o riordinare manualmente.

import pandas as pd

s1 = pd.Series([10, 20, 30], index=['a', 'b', 'c'])
s2 = pd.Series([1, 2, 3], index=['b', 'c', 'd'])

# Alignment in action: a→NaN, d→NaN
result = s1 + s2
print('s1 + s2 with automatic alignment:')
print(result)

NaN dovuti a indici non allineati

Quando le etichette degli indici non corrispondono, Pandas riempie le voci mancanti con NaN. È intenzionale: segnala che «non era disponibile alcun valore corrispondente in uno degli operandi». Controlli sempre il risultato delle operazioni aritmetiche tra due Series o DataFrame per individuare valori NaN imprevisti: indicano un disallineamento degli indici. Usi fill_value=0 nel metodo aritmetico (s1.add(s2, fill_value=0)) per trattare i valori allineati mancanti come zero invece di propagare NaN.

import pandas as pd

s1 = pd.Series({'a': 10, 'b': 20, 'c': 30})
s2 = pd.Series({'b': 1, 'c': 2, 'd': 3})

# Default: NaN where labels don't match
print('Default (NaN for unmatched):')
print(s1 + s2)

# fill_value=0: treat missing as zero
print('\nWith fill_value=0:')
print(s1.add(s2, fill_value=0))

Allineamento nelle operazioni aritmetiche tra DataFrame

L'allineamento si applica sia alle righe sia alle colonne quando si combinano due DataFrame. Il risultato contiene l'unione di entrambi gli insiemi di indici e di colonne, con NaN ovunque uno dei due DataFrame non abbia un valore. È equivalente a una full outer join simultanea su indice e colonne. Ciò consente di sommare in sicurezza DataFrame relativi a periodi fiscali diversi: i mesi presenti in uno solo dei due ricevono NaN, che può poi riempire o eliminare.

import pandas as pd

df1 = pd.DataFrame({'revenue': [100, 200], 'cost': [80, 150]}, index=['Jan', 'Feb'])
df2 = pd.DataFrame({'revenue': [120, 210], 'headcount': [5, 6]}, index=['Feb', 'Mar'])

result = df1 + df2
print('Combined DataFrame (union of index and columns):')
print(result)

Il metodo reindex()

df.reindex(new_index) restituisce un nuovo DataFrame conforme all'elenco di etichette new_index. Le etichette presenti sia nell'indice originale sia in quello nuovo vengono conservate; quelle presenti in new_index ma non nell'originale ricevono NaN; quelle presenti nell'originale ma non in new_index vengono eliminate. Questo è il modo esplicito per allineare un DataFrame a un insieme di etichette di destinazione prima di eseguire operazioni.

import pandas as pd

s = pd.Series({'a': 10, 'b': 20, 'c': 30})

# Reindex to a new label set
reindexed = s.reindex(['b', 'c', 'd', 'e'])
print('Original:', s.index.tolist())
print('New index: [b, c, d, e]')
print('\nReindexed Series:')
print(reindexed)
# b, c preserved; d, e → NaN; a dropped

Riempire i valori mancanti dopo il reindicizzamento

reindex() accetta un parametro fill_value per sostituire le nuove etichette con una costante e un parametro method per il riempimento in avanti ('ffill') o all'indietro ('bfill'). Questi metodi di riempimento sono particolarmente utili per i dati di serie temporali, quando si reindicizza una Series su un intervallo completo di date e si desidera riempire i giorni mancanti con l'ultimo valore noto anziché con NaN.

import pandas as pd

# Sparse daily data with gaps
s = pd.Series(
    [10, 20, 30],
    index=pd.to_datetime(['2024-01-01', '2024-01-03', '2024-01-07'])
)

# Reindex to complete date range
full_range = pd.date_range('2024-01-01', '2024-01-07')
print('Forward fill (carry last known value):')
print(s.reindex(full_range, method='ffill'))

print('\nFill with 0:')
print(s.reindex(full_range, fill_value=0))

Reindicizzare le colonne

reindex funziona anche sulle colonne: df.reindex(columns=['col1', 'col2', 'new_col']). Le nuove colonne che non esistono nel DataFrame originale vengono aggiunte con NaN. Le colonne esistenti che non sono incluse nel nuovo elenco vengono eliminate. È utile per imporre uno schema canonico delle colonne a più DataFrame provenienti da fonti diverse e potenzialmente caratterizzati da insiemi di colonne non uniformi.

import pandas as pd

df = pd.DataFrame({
    'name': ['Alice', 'Bob'],
    'age': [30, 25],
    'city': ['NY', 'LA']
})

# Enforce a canonical column order and add missing columns
canonical_cols = ['name', 'age', 'email', 'city', 'country']
df_reindexed = df.reindex(columns=canonical_cols)
print(df_reindexed)
# 'email' and 'country' are new → NaN

Usare align() per sincronizzare due oggetti

s1.align(s2) restituisce due nuovi oggetti con lo stesso indice (unione o intersezione in base al parametro join), pronti per operazioni elemento per elemento. È equivalente a reindicizzare simultaneamente entrambi gli oggetti sullo stesso insieme di etichette. Usi join='inner' per mantenere solo le etichette comuni oppure join='outer' (predefinito) per mantenere tutte le etichette di entrambi, con NaN in caso di mancata corrispondenza.

import pandas as pd

s1 = pd.Series({'a': 10, 'b': 20, 'c': 30})
s2 = pd.Series({'b': 1, 'c': 2, 'd': 3})

# Align to common labels only (inner join)
s1_aligned, s2_aligned = s1.align(s2, join='inner')
print('Inner-aligned s1:')
print(s1_aligned)
print('Inner-aligned s2:')
print(s2_aligned)

print('\nProduct on common labels:')
print(s1_aligned * s2_aligned)

Allineamento in merge rispetto alle operazioni aritmetiche

Pandas offre due approcci per combinare i DataFrame: merge/join (in stile SQL, con corrispondenza esplicita delle chiavi) e operazioni aritmetiche con allineamento degli indici (implicito, basato sulle etichette). Usi merge quando combina tabelle strutturate con colonne di chiavi esplicite. Usi l'allineamento aritmetico quando esegue calcoli tra DataFrame che dovrebbero condividere naturalmente un indice, ad esempio sottraendo un DataFrame dei costi da uno dei ricavi, entrambi indicizzati per (regione, mese).

import pandas as pd

# Two DataFrames sharing the same index
revenue = pd.Series({'North': 500, 'South': 300, 'East': 450})
costs = pd.Series({'North': 350, 'South': 280, 'West': 400})

# Automatic alignment: 'East' and 'West' don't match → NaN
profit = revenue - costs
print('Profit by region:')
print(profit)

# If you want only common regions
profit_inner = revenue.align(costs, join='inner')[0] - revenue.align(costs, join='inner')[1]
print('\nProfit (common regions only):')
print(profit_inner)

Controllare l'uguaglianza degli indici prima delle operazioni

Prima di eseguire operazioni su due DataFrame, controlli se i relativi indici coincidono con (df1.index == df2.index).all(). Se gli indici differiscono solo nell'ordine, li ordini entrambi prima del confronto. Per i DataFrame caricati da fonti diverse, è buona pratica allinearli o reindicizzarli esplicitamente prima delle operazioni aritmetiche, per evitare la propagazione accidentale di NaN. Documenti nei commenti o nei log della pipeline ogni ipotesi relativa all'allineamento.

import pandas as pd

df1 = pd.DataFrame({'sales': [100, 200, 300]}, index=['Q1', 'Q2', 'Q3'])
df2 = pd.DataFrame({'cost': [80, 160, 240]}, index=['Q1', 'Q2', 'Q3'])

# Check index equality
if (df1.index == df2.index).all():
    print('Indices match — safe to combine.')
    combined = pd.concat([df1, df2], axis=1)
    combined['profit'] = combined['sales'] - combined['cost']
    print(combined)
else:
    print('Indices differ — align before combining!')

Schema pratico: standardizzare le forme

Uno schema comune quando si caricano dati da più file o chiamate API consiste nel fatto che ogni batch copre un sottoinsieme diverso di chiavi. Prima di concatenare o aggregare, reindicizzi tutti i batch sullo spazio completo delle chiavi note con fill_value=0. In questo modo ogni batch ha la stessa forma (stesso indice e stesse colonne) prima delle operazioni, evitando discrepanze silenziose nelle forme che causano risultati aggregati errati.

import pandas as pd

# Two sales batches with different product sets
batch1 = pd.Series({'laptop': 50, 'phone': 80, 'tablet': 30})
batch2 = pd.Series({'phone': 90, 'tablet': 40, 'headphones': 60})

# Full product catalogue
all_products = ['laptop', 'phone', 'tablet', 'headphones']

# Standardise both to the full catalogue
b1 = batch1.reindex(all_products, fill_value=0)
b2 = batch2.reindex(all_products, fill_value=0)

total = b1 + b2
print('Total sales per product:')
print(total)

Casi limite dell’allineamento degli indici

Due casi limite importanti: Etichette duplicate — se entrambe le Series hanno etichette di indice duplicate, l’allineamento produce un’espansione simile a un prodotto cartesiano con molti valori NaN (Pandas non presume quali duplicati corrispondano tra loro). Si assicuri sempre che gli indici siano univoci prima dell’allineamento aritmetico. Indici integer e object — un RangeIndex(0,5) e un Int64Index([0,1,2,3,4]) potrebbero non allinearsi perfettamente dopo alcune operazioni, perché uno viene dedotto e l’altro è esplicito. Utilizzi reset_index(drop=True) per normalizzarli.

import pandas as pd

# Duplicate label alignment — produces unexpected expansion
s1 = pd.Series([1, 2, 3], index=['a', 'a', 'b'])
s2 = pd.Series([10, 20], index=['a', 'b'])

result = s1 + s2
print('Result with duplicate indices (unexpected expansion):')
print(result)
print('\nAlways ensure unique indices before arithmetic!')

Verifica rapida

Verifichi la sua comprensione dell’allineamento e del reindicizzamento degli indici presentati in questa lezione.

Riepilogo della lezione

In questa lezione ha imparato che Pandas esegue l’allineamento automatico degli indici nelle operazioni aritmetiche, producendo NaN per le etichette senza corrispondenza; reindex() adatta un DataFrame a un insieme di etichette di destinazione, con opzioni di riempimento per quelle mancanti; e align() sincronizza contemporaneamente due oggetti sullo stesso indice. Nella prossima lezione esploreremo i vantaggi in termini di prestazioni degli indici ordinati e come misurarli con timeit.

Domande Frequenti

La lezione «Allineamento e reindicizzazione degli indici» è gratuita?

Sì — il testo completo di «Allineamento e reindicizzazione degli indici» è 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 «Allineamento e reindicizzazione degli indici»?

Allinei due DataFrame a un indice comune con reindex(), riempia le etichette mancanti e comprenda come le operazioni aritmetiche allineino gli indici. 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 3 di 4.

Quanto tempo richiede la lezione «Allineamento e reindicizzazione degli indici»?

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. Creare un MultiIndex
  2. Selezionare dati da un MultiIndex
  3. Allineamento e reindicizzazione degli indici
  4. Vantaggi prestazionali degli indici ordinati
← Torna a Pandas & NumPy Academy