Pandas DataFrame spiegato con esempi nel 2026

Un Pandas DataFrame è Una struttura dati bidimensionale e tabellare in Python con righe e colonne etichettate, progettata per una rapida pulizia, analisi e trasformazione dei dati. Immaginatela come un foglio di calcolo in memoria con potenti funzionalità di indicizzazione, selezione e aggregazione.

Di seguito, troverete una spiegazione di Pandas DataFrame con esempi che potrete copiare, eseguire e adattare. Pandas DataFrame è il componente fondamentale dell'analisi dei dati in Python. Rende l'importazione, la pulizia, la trasformazione e la sintesi dei dati semplici ed efficienti.

In questa guida spiegherò cos'è un DataFrame, come crearlo e come utilizzarlo, il tutto con il supporto di esempi pratici e best practice tratti da progetti di analisi e ingegneria reali.

Cos'è un DataFrame Panda?

Un Pandas DataFrame è una tabella etichettata in 2D in cui:

• Le colonne possono contenere diversi tipi di dati (int, float, string, datetime, categorici).
• Righe e colonne avere etichette (nomi di indice e di colonna) per un accesso rapido e leggibile.
• Operazioni vettorializzate consentono calcoli aritmetici e trasformazioni rapide tra colonne.

I DataFrames sono costruiti sulla base delle serie (matrici 1D) e si integrano strettamente con NumPy per migliorare le prestazioni. Rispetto ai semplici elenchi Python o alla gestione CSV, i DataFrame offrono strumenti integrati per valori mancanti, join, operazioni di gruppo e analisi.

Pandas DataFrame vs Serie vs Array NumPy

• Serie: Array etichettato 1D (come una singola colonna).
• DataFrame: Tabella etichettata 2D di più serie allineate per indice.
• Matrice NumPy: Array n-dimensionale veloce e omogeneo (senza etichette di colonna o tipi misti).

Scegli DataFrame per dati tabulari etichettati e di tipo misto; array NumPy per dati numerici puri e dello stesso tipo; Series per singole colonne o feature.

Come creare un DataFrame (con esempi)

1. Da dizionari o elenchi Python

import pandas as pd

data = {
    "name": ["Ava", "Ben", "Chad"],
    "age": [29, 34, 27],
    "city": ["Dallas", "Austin", "Houston"]
}

df = pd.DataFrame(data)
print(df)

Questo è il modo più semplice per creare un piccolo DataFrame per test o demo.

2. Da CSV, Excel, JSON o SQL

# CSV
df = pd.read_csv("sales.csv")

# Excel
df_xls = pd.read_excel("sales.xlsx", sheet_name="Q1")

# JSON
df_json = pd.read_json("data.json")

# SQL (requires an engine, e.g., SQLite or PostgreSQL)
from sqlalchemy import create_engine
engine = create_engine("sqlite:///app.db")
df_sql = pd.read_sql("SELECT * FROM orders", engine)

Utilizza questi lettori in progetti reali, in particolare per set di dati e pipeline di produzione più grandi.

3. Da array o serie NumPy

import numpy as np
arr = np.array([[1, 2], [3, 4]])
df_np = pd.DataFrame(arr, columns=["a", "b"])
print(df_np)

Quando i dati iniziano con valori numerici e senza etichetta, aggiungere immediatamente i nomi delle colonne per maggiore chiarezza e compatibilità a valle.

Selezione, indicizzazione e filtraggio dei dati

.loc contro .iloc

# Sample setup
df = pd.DataFrame({
    "name": ["Ava", "Ben", "Chad", "Dana"],
    "age": [29, 34, 27, 31],
    "score": [85, 92, 88, 79]
}, index=["u1", "u2", "u3", "u4"])

# Label-based selection with .loc
print(df.loc["u2", "score"])        # row label "u2", column "score"
print(df.loc["u1":"u3", ["name","age"]])  # slice by labels

# Position-based selection with .iloc
print(df.iloc[1, 2])                # second row, third column (0-based)
print(df.iloc[0:2, 0:2])            # top-left 2x2 block

Filtraggio e query booleani

# Filter rows
adults = df[df["age"] >= 30]
high_scorers = df[(df["score"] >= 90) & (df["age"] < 35)]

# Using query (readable for complex filters)
top = df.query("score >= 90 and age < 35")

Per una maggiore velocità e leggibilità, è preferibile utilizzare maschere booleane vettoriali o stringhe di query anziché cicli.

Operazioni comuni dei DataFrame

Aggiungere, rinominare ed eliminare colonne

# Create or transform columns
df["age_group"] = pd.cut(df["age"], bins=[0, 29, 100], labels=["Young", "Adult"])
df = df.rename(columns={"score": "exam_score"})
df = df.drop(columns=["age_group"])

Ordinamento e classificazione

df_sorted = df.sort_values(by=["exam_score", "age"], ascending=[False, True])
df["rank"] = df["exam_score"].rank(ascending=False, method="dense")

GroupBy e aggregazione

sales = pd.DataFrame({
    "region": ["US","US","EU","EU","APAC"],
    "rep": ["A","B","C","D","E"],
    "revenue": [100, 130, 90, 120, 150]
})

summary = sales.groupby("region")["revenue"].agg(["count","sum","mean","max"])
print(summary)

GroupBy suddivide i dati in gruppi, applica funzioni e combina i risultati. È il cavallo di battaglia per i report e i riepiloghi in stile BI.

Applica vs vettorializzazione

# Prefer vectorized operations
df["double_score"] = df["exam_score"] * 2

# If you must use apply, keep it simple (it’s slower)
df["pass_fail"] = df["exam_score"].apply(lambda x: "Pass" if x >= 80 else "Fail")

Le operazioni vettorializzate sfruttano le routine ottimizzate per C e sono notevolmente più veloci rispetto all'applicazione per riga.

Gestione dei dati e dei tipi mancanti

Rileva, riempi o elimina i valori mancanti

df.isna().sum()                      # count of NaNs per column
df_filled = df.fillna({"exam_score": 0})
df_dropped = df.dropna(subset=["exam_score"])

Utilizzare strategie specifiche per il dominio: riempire in avanti le serie temporali, riempire con le mediane per i dati numerici asimmetrici o eliminare quando appropriato.

Correggi i dtype per velocità e memoria

# Convert strings that look like numbers
df["exam_score"] = pd.to_numeric(df["exam_score"], errors="coerce")

# Categorical for repeated strings
df["name"] = df["name"].astype("category")

# Parse datetimes
df["date"] = pd.to_datetime(df["date"], errors="coerce")

I dtype appropriati (in particolare quelli categorici e di data e ora) riducono la memoria e consentono di filtrare e raggruppare più velocemente.

Unione, unione e concatenazione

Combina più DataFrame proprio come i join SQL o le tabelle impilate.

customers = pd.DataFrame({
    "cust_id": [1,2,3],
    "name": ["Ava","Ben","Chad"]
})
orders = pd.DataFrame({
    "order_id": [101,102,103],
    "cust_id": [1,1,3],
    "amount": [39.5, 12.0, 55.0]
})

# SQL-style inner join on a key
merged = pd.merge(orders, customers, on="cust_id", how="inner")

# Concatenate rows (stack)
stacked = pd.concat([orders, orders], ignore_index=True)

# Join by index
customers_i = customers.set_index("cust_id")
orders_i = orders.set_index("cust_id")
joined = customers_i.join(orders_i, how="left")

Scegli "interno" per l'intersezione, "sinistra" per mantenere tutti gli elementi della tabella di sinistra ed "esterno" per l'unione completa. Convalida sempre l'univocità della chiave per evitare duplicazioni.

I/O e serializzazione: CSV vs Parquet vs Feather

Il formato CSV è leggibile, ma è di grandi dimensioni e lento da analizzare. Parquet e Feather sono formati binari colonnari che si caricano più velocemente e occupano meno spazio su disco.

# CSV
df.to_csv("data.csv", index=False)

# Parquet (requires pyarrow or fastparquet)
df.to_parquet("data.parquet", index=False)

# Feather (fast for Python-R interchange)
df.to_feather("data.feather")

Per analisi su larga scala, è preferibile usare Parquet o Feather per ridurre il sovraccarico di I/O e velocizzare le pipeline.

Suggerimenti sulle prestazioni per i dataframe di grandi dimensioni

• Leggi a pezzi: utilizzare read_csv con chunksize per file di grandi dimensioni.
• Numeri in calo: convertire float64/int64 in float32/int32 quando è sicuro.
• Utilizzare dtype categorico per stringhe ripetute (ad esempio, codici paese, ID prodotto).
• Preferire le operazioni vettorializzate e le aggregazioni integrate rispetto ai cicli.
• Filtrare in anticipo, selezionare solo le colonne necessarie (usecols=…).
• Memorizza i risultati intermedi nella cache di Parquet per rieseguirli più velocemente.

# Example: chunked CSV processing
import pandas as pd

total = 0
for chunk in pd.read_csv("events.csv", usecols=["user_id","amount"], chunksize=500_000):
    chunk["amount"] = pd.to_numeric(chunk["amount"], errors="coerce")
    total += chunk["amount"].sum(skipna=True)
print(total)

Lavorare con milioni di righe trae vantaggio da Elaborazione e I/O potenti. Se esegui script Jupyter, Airflow o ETL nel cloud, un VPS scalabile con storage NVMe è utile. YouStable, forniamo VPS SSD/NVMe e manageIstanze cloud adatte ai flussi di lavoro dei dati, in modo che i tuoi lavori Pandas vengano completati in modo più rapido e affidabile.

Esempi concreti che puoi riutilizzare

Analisi del registro Web (filtraggio e raggruppamento)

import pandas as pd

logs = pd.read_csv("access.log.csv", usecols=["ip","status","bytes","ts"])
# Parse timestamp and filter errors
logs["ts"] = pd.to_datetime(logs["ts"])
errors = logs[logs["status"].isin([500, 502, 503, 504])]

# Error rate by minute
rate = (errors
        .groupby(pd.Grouper(key="ts", freq="1min"))
        .size()
        .rename("errors_per_min"))
print(rate.tail())

Analisi delle vendite (unioni e aggregazioni)

orders = pd.read_csv("orders.csv")           # order_id, cust_id, amount, date
customers = pd.read_csv("customers.csv")     # cust_id, segment

df = pd.merge(orders, customers, on="cust_id", how="left")
df["date"] = pd.to_datetime(df["date"])

# Revenue by segment and month
monthly = (df
    .groupby([pd.Grouper(key="date", freq="MS"), "segment"])["amount"]
    .sum()
    .reset_index()
    .sort_values(["date", "segment"]))
print(monthly.head())

Questi modelli si manifestano nei dashboard aziendali, nel rilevamento delle anomalie e nella pianificazione della capacità nei team di ingegneria.

Elenco di controllo delle migliori pratiche

• Assegnare nomi chiari e coerenti alle colonne (si consiglia snake_case).
• Imposta l'indice quando trasmette identità o tempo (ad esempio, imposta un indice data/ora per le serie temporali).
• Convalida le unioni: verificare l'univocità delle chiavi e il conteggio delle righe dopo le unioni.
• Utilizzare Parquet per grandi set di dati intermedi, CSV per lo scambio con gli esseri umani.
• Convertire i dtype in anticipo per evitare sorprese e ridurre la memoria.
• Favorire la vettorizzazione e i metodi integrati; evitare l'applicazione per riga in cicli stretti.
• Scrivere codice riproducibile: pinnare le versioni e aggiungere casualità quando necessario.

Domande Frequenti