Salta al contenuto principale

02 - Polars contro pandas: benchmark su 20 milioni di righe

Polars 2.1.0 contro pandas 3.1.1 su 20 milioni di righe, con misure riproducibili: dove il vantaggio è dieci volte, dove è nullo e come migrare senza sorprese.

Cosa ne pensi di questo articolo?

02 - Polars contro pandas: benchmark su 20 milioni di righe
Data Engineering 2027Foto:Atlantic AmbiencePexels

In Breve

Polars 2.1.0 contro pandas 3.1.1 su 20 milioni di righe, con misure riproducibili: dove il vantaggio è dieci volte, dove è nullo e come migrare senza sorprese.

Su 20 milioni di righe già in memoria, l'aggregazione per categoria impiega circa 500 millisecondi in pandas 3.1.1 e circa 50 in Polars 2.1.0; la lettura di un CSV da 735 MB, invece, è quasi un pareggio. Il vantaggio di Polars non è uniforme: dipende dall'operazione, dal formato del file, da quanto lavoro il motore riesce a saltare e da quanti core ha a disposizione. Qui trovi le misure, il programma per rifarle e i punti dove la migrazione costa più di quanto rende.

Prerequisiti. Python e un po' di pandas; DuckDB compare solo in un esempio e non serve conoscerlo prima.

Che cosa viene misurato, e come

Un confronto di prestazioni vale quanto il metodo con cui è fatto, quindi lo dichiaro per intero. Le cifre di questo articolo sono mie e vengono dal listato che segue; nessun numero è preso da articoli, siti dei fornitori o benchmark di terzi. Cambiano se cambi macchina, versioni o dati, e infatti il programma stampa un intervallo e non un valore solo. Le condizioni sono queste:

  • macchina: AMD Ryzen 5 5600H con 12 thread logici, 30 GB di RAM, disco locale, file già nella cache del sistema operativo;
  • software: Python 3.14.4, pandas 3.1.1, Polars 2.1.0, PyArrow 26.0.1, tutte le versioni correnti al 2026-11-13;
  • dati: 20 milioni di righe sintetiche con seme fisso (numpy default_rng(42)), un CSV da 735 MB e lo stesso contenuto in Parquet da 248 MB;
  • cronometro: 5 ripetizioni per compito in un processo Python nuovo, riportate come minimo, mediana e massimo;
  • memoria: il picco di memoria residente (ru_maxrss) del processo, che include i dati caricati e non solo il costo dell'operazione.

Due limiti vanno detti subito. La prima ripetizione include effetti di avvio (caricamento di librerie e cache) che le altre non hanno, e lo vedi nel massimo, spesso lontano dalla mediana. Inoltre i dati sono sintetici e uniformi: su dati reali con stringhe lunghe, molte colonne o chiavi sbilanciate le proporzioni cambiano. Prima di decidere, rifai le misure sui tuoi file.

Il dataset di prova

Il generatore scrive un file di ordini con quattro colonne (categoria testuale con otto valori, importo decimale, quantità intera, chiave intera) e una tabella di 1 milione di sconti per il join. Il seme fisso rende i dati identici a ogni esecuzione, controllata con un confronto dell'uscita tra due lanci. Il DataFrame è creato direttamente in Polars e salvato in due formati, perché la differenza fra CSV e Parquet è uno dei risultati più importanti.

import numpy as np, polars as pl, pathlib

pathlib.Path("dati").mkdir(exist_ok=True)
rng = np.random.default_rng(42)            # seme fisso: stessi dati a ogni esecuzione
n = 20_000_000
categorie = np.array(["alimentari", "casa", "elettronica", "libri", "sport", "giardino", "moda", "giochi"])

df = pl.DataFrame({
    "categoria": categorie[rng.integers(0, len(categorie), n)],
    "valore": rng.normal(100.0, 15.0, n),
    "quantita": rng.integers(1, 1000, n),
    "chiave": rng.integers(0, 1_000_000, n),
})
df.write_csv("dati/ordini.csv")
df.write_parquet("dati/ordini.parquet")

# tabella piccola per il join: 1 milione di chiavi, ognuna con una fascia di sconto
rng2 = np.random.default_rng(7)
dim = pl.DataFrame({"chiave": np.arange(1_000_000), "sconto": rng2.integers(0, 30, 1_000_000)})
dim.write_parquet("dati/sconti.parquet")

for f in ("ordini.csv", "ordini.parquet", "sconti.parquet"):
    print(f"{f}: {pathlib.Path('dati', f).stat().st_size / 1e6:.0f} MB")
print(df.head(3))

# Output:
# ordini.csv: 735 MB
# ordini.parquet: 248 MB
# sconti.parquet: 2 MB
# shape: (3, 4)
# ┌────────────┬────────────┬──────────┬────────┐
# │ categoria  ┆ valore     ┆ quantita ┆ chiave │
# │ ---        ┆ ---        ┆ ---      ┆ ---    │
# │ str        ┆ f64        ┆ i64      ┆ i64    │
# ╞════════════╪════════════╪══════════╪════════╡
# │ alimentari ┆ 116.222483 ┆ 698      ┆ 958520 │
# │ moda       ┆ 114.125745 ┆ 756      ┆ 689173 │
# │ giardino   ┆ 86.871773  ┆ 423      ┆ 834971 │
# └────────────┴────────────┴──────────┴────────┘

Il Parquet pesa un terzo del CSV (248 MB contro 735 MB) perché memorizza le colonne con tipo e le comprime; inoltre porta con sé il tipo di ogni colonna, mentre il CSV obbliga chi legge a indovinarlo. Se hai la scelta, un file che passa da una pipeline all'altra è meglio in Parquet; il CSV resta il formato di scambio con chi non può leggere altro.

I quattro compiti

Il file compiti.py esegue un compito con un motore e stampa tempi e memoria. Aggregazione e join partono da dati già in memoria, per misurare solo l'operazione; la lettura del CSV e quella del Parquet con filtro misurano invece il percorso intero dal disco al risultato. Per il Parquet ho aggiunto un terzo concorrente, pandas_filters: pandas può passare il filtro al lettore Parquet con il parametro filters, e ignorarlo renderebbe il confronto scorretto verso pandas.

"""Un compito alla volta, in un processo nuovo: python compiti.py <compito> <motore>"""
import resource, sys, time

compito, motore = sys.argv[1], sys.argv[2]
REPS = 5

def prepara():
    """Carica i dati FUORI dal cronometro, per i compiti che misurano solo l'operazione."""
    if motore == "pandas":
        import pandas as pd
        return pd.read_parquet("dati/ordini.parquet"), pd.read_parquet("dati/sconti.parquet")
    import polars as pl
    return pl.read_parquet("dati/ordini.parquet"), pl.read_parquet("dati/sconti.parquet")

def gruppi(d):
    ordini, _ = d
    if motore == "pandas":
        return ordini.groupby("categoria").agg(valore=("valore", "mean"), quantita=("quantita", "sum"))
    import polars as pl
    return ordini.group_by("categoria").agg(pl.col("valore").mean(), pl.col("quantita").sum())

def join(d):
    ordini, sconti = d
    if motore == "pandas":
        return ordini.merge(sconti, on="chiave", how="inner")
    return ordini.join(sconti, on="chiave", how="inner")

def csv(_):
    if motore == "pandas":
        import pandas as pd
        return pd.read_csv("dati/ordini.csv")
    import polars as pl
    return pl.read_csv("dati/ordini.csv")

def parquet_filtro(_):
    # legge il file E applica filtro e aggregazione: conta il percorso intero
    if motore == "pandas":
        import pandas as pd
        df = pd.read_parquet("dati/ordini.parquet")
        return df[df["quantita"] > 990].groupby("categoria")["valore"].mean()
    if motore == "pandas_filters":
        import pandas as pd
        df = pd.read_parquet("dati/ordini.parquet", filters=[("quantita", ">", 990)])
        return df.groupby("categoria")["valore"].mean()
    import polars as pl
    return (pl.scan_parquet("dati/ordini.parquet").filter(pl.col("quantita") > 990)
              .group_by("categoria").agg(pl.col("valore").mean()).collect())

FUNZ = {"gruppi": gruppi, "join": join, "csv": csv, "parquet_filtro": parquet_filtro}
dati = prepara() if compito in ("gruppi", "join") else None
tempi = []
for _ in range(REPS):
    t0 = time.perf_counter()
    FUNZ[compito](dati)
    tempi.append(time.perf_counter() - t0)
tempi.sort()
mediana = tempi[len(tempi) // 2]
rss_mb = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024
print(f"{tempi[0]*1000:.0f} {mediana*1000:.0f} {tempi[-1]*1000:.0f} {rss_mb:.0f}")

Ogni compito gira in un processo suo, così la memoria di uno non sporca quella dell'altro. Il motore Polars usa pl.scan_parquet per il caso con filtro: è la lettura pigra, che costruisce un piano e legge solo le colonne e le righe necessarie. Il driver qui sotto lancia i processi e raccoglie i risultati; a ogni esecuzione gli intervalli cambiano di qualche punto percentuale.

import subprocess, sys

def esegui(compito, motore):
    r = subprocess.run([sys.executable, "compiti.py", compito, motore], capture_output=True, text=True)
    if r.returncode:
        return f"ERRORE: {r.stderr.strip().splitlines()[-1]}"
    lo, med, hi, rss = r.stdout.split()
    return f"min {lo:>5}  mediana {med:>5}  max {hi:>5} ms   picco {rss:>5} MB"

PROVE = [("gruppi", ["pandas", "polars"]), ("join", ["pandas", "polars"]),
         ("csv", ["pandas", "polars"]), ("parquet_filtro", ["pandas", "pandas_filters", "polars"])]
for compito, motori in PROVE:
    print(compito)
    for m in motori:
        print(f"  {m:<15} {esegui(compito, m)}")

# Output:
# gruppi
#   pandas          min   514  mediana   529  max   584 ms   picco  2254 MB
#   polars          min    47  mediana    48  max    49 ms   picco   907 MB
# join
#   pandas          min   690  mediana   742  max   964 ms   picco  2401 MB
#   polars          min   367  mediana   530  max   651 ms   picco  2210 MB
# csv
#   pandas          min   515  mediana   569  max   857 ms   picco  2047 MB
#   polars          min   407  mediana   444  max   820 ms   picco  1609 MB
# parquet_filtro
#   pandas          min   236  mediana   290  max   630 ms   picco  2469 MB
#   pandas_filters  min   189  mediana   225  max   532 ms   picco   781 MB
#   polars          min    39  mediana    40  max   171 ms   picco   122 MB

Come leggere la tabella

L'aggregazione è dove Polars distanzia di più: la mediana di pandas è circa dieci volte quella di Polars, in tutte le serie che ho lanciato. Dietro c'è soprattutto il parallelismo, misurato nella sezione successiva, e in parte una rappresentazione in memoria a colonne secondo il formato Arrow. Il join ha un vantaggio più modesto, intorno a 1,4-2,4 volte nelle mie serie: la tabella di sconti ha 1 milione di chiavi e il lavoro è dominato dall'accesso casuale in memoria, che nessun motore elimina.

La lettura del CSV è quasi un pareggio, e qui il racconto classico "pandas legge su un core" non regge: la documentazione di pandas 3.1.1 dice che il motore C legge i file sufficientemente grandi in parallelo, e le misure lo confermano (mediane tra 0,5 e 0,6 secondi per entrambi, i due intervalli si sovrappongono). Il caso più netto è il Parquet con filtro: Polars legge solo tre colonne su quattro, scarta le righe già nella scansione e non materializza mai la tabella intera, quindi finisce intorno a 40-50 millisecondi con un picco di circa 125 MB. Pandas senza filters carica tutto: oltre 2 GB di picco.

Il dato più utile per chi decide è quello a destra: pandas con filters riduce il picco di memoria da circa 2,4 GB a circa 0,8 GB e il tempo di un terzo o più (nelle mie serie da 1,6 a 3 volte), senza cambiare libreria. Una parte consistente del "vantaggio di Polars" sul Parquet è quindi un vantaggio di come leggi il file, e si ottiene in parte anche restando in pandas. Il resto (aggregazione, join, memoria in scansione) è un vantaggio vero del motore.

Quanto vale il parallelismo

La domanda che il confronto da solo non risolve è: il vantaggio sull'aggregazione viene dall'algoritmo o dai core? Lo si vede misurando due cose insieme, il tempo reale e il tempo di CPU, mentre si limita il numero di thread di Polars con la variabile d'ambiente POLARS_MAX_THREADS, che la documentazione indica come modo per impostare la dimensione del pool prima dell'avvio del processo. Ogni misura gira in un processo nuovo, perché dopo l'avvio il pool non si può cambiare.

import os, subprocess, sys

CODICE = """
import time, polars as pl
df = pl.read_parquet("dati/ordini.parquet")
q = lambda: df.group_by("categoria").agg(pl.col("valore").mean(), pl.col("quantita").sum())
q()                                   # riscaldamento
t, c = [], []
for _ in range(5):
    w, p = time.perf_counter(), time.process_time()
    q()
    t.append(time.perf_counter() - w); c.append(time.process_time() - p)
print(f"{min(t)*1000:.0f} ms reali, {min(c)*1000:.0f} ms di CPU, thread usati: {pl.thread_pool_size()}")
"""
for n in (1, 2, 4, 12):
    env = dict(os.environ, POLARS_MAX_THREADS=str(n))
    r = subprocess.run([sys.executable, "-c", CODICE], env=env, capture_output=True, text=True)
    print(f"POLARS_MAX_THREADS={n:>2}: {r.stdout.strip() or r.stderr.strip().splitlines()[-1]}")

# Output:
# POLARS_MAX_THREADS= 1: 221 ms reali, 221 ms di CPU, thread usati: 1
# POLARS_MAX_THREADS= 2: 112 ms reali, 222 ms di CPU, thread usati: 2
# POLARS_MAX_THREADS= 4: 61 ms reali, 237 ms di CPU, thread usati: 4
# POLARS_MAX_THREADS=12: 45 ms reali, 446 ms di CPU, thread usati: 12

Con un thread Polars impiega circa 210-220 ms, contro circa 500 ms di pandas: un fattore 2,3 che viene dall'implementazione. Poi il tempo reale scende quasi linearmente a 2 e 4 thread (circa 115 ms e 58-68 ms) mentre il tempo di CPU resta uguale: il lavoro è lo stesso, diviso fra più core. A 12 thread il guadagno si appiattisce (circa 42-47 ms) e il tempo di CPU raddoppia, segno di lavoro in più per coordinare i thread. Su una macchina da 2 vCPU, come molte macchine virtuali economiche, l'aggregazione sarebbe quindi più vicina a 4 volte che a 10.

Il piano pigro e che cosa nasconde

Il Parquet dell'esempio è stato veloce perché Polars non esegue le righe mentre le scrivi: costruisce un piano e lo ottimizza al momento di collect(). Il blocco seguente mostra il piano della stessa query: il filtro sulla quantità è stato spinto dentro la scansione (SELECTION) e solo 3 colonne su 4 vengono lette (PROJECT 3/4 COLUMNS).

import polars as pl

lf = pl.scan_parquet("dati/ordini.parquet").filter(pl.col("quantita") > 990) \
       .group_by("categoria").agg(pl.col("valore").mean().alias("media"))

print(type(lf).__name__)                 # nessun calcolo e' ancora partito
print(lf.explain())                      # il piano ottimizzato
risultato = lf.collect()
print(type(risultato).__name__, risultato.shape)

# Output:
# LazyFrame
# AGGREGATE[maintain_order: false]
#   [col("valore").mean().alias("media")] BY [col("categoria")]
#   FROM
#   simple π 2/2 ["categoria", "valore"]
#     Parquet SCAN [dati/ordini.parquet]
#     PROJECT 3/4 COLUMNS
#     SELECTION: col("quantita") > 990
#     ESTIMATED ROWS: 20000000
# DataFrame (8, 2)

L'errore classico è dimenticare collect() e ritrovarsi un LazyFrame invece dei dati. Dal 2.0 c'è anche una novità che può cambiare i risultati senza avvisarti: la pagina di aggiornamento della documentazione spiega che con collect() l'opzione engine="auto" usa ora il motore streaming per le query pigre, e che questo motore non garantisce l'ordine delle righe in group_by, nei join e in altre operazioni. Se il tuo codice dipende da un ordine che nessuno ha mai richiesto, ordina in modo esplicito oppure usa le opzioni di mantenimento dell'ordine dove esistono.

Migrare senza cambiare i risultati

La prima garanzia di una migrazione è che gli stessi dati diano gli stessi numeri. Il test seguente esegue quattro operazioni in pandas e in Polars sullo stesso milione di righe e confronta i risultati con assert_frame_equal, ordinando le righe prima del confronto perché, come visto, l'ordine non è garantito. Il tipo dei dati lo ignoro (check_dtype=False), perché pandas e Polars non rappresentano gli interi e le stringhe allo stesso modo.

import pandas as pd
import polars as pl

pdf = pd.read_parquet("dati/ordini.parquet").head(1_000_000)
plf = pl.read_parquet("dati/ordini.parquet").head(1_000_000)

def ordina(df):                      # confronto indipendente dall'ordine delle righe
    return df.sort_values(list(df.columns)).reset_index(drop=True)

coppie = {
    "filtro":      (pdf[pdf["quantita"] > 990],
                    plf.filter(pl.col("quantita") > 990).to_pandas()),
    "selezione":   (pdf[["categoria", "valore"]],
                    plf.select("categoria", "valore").to_pandas()),
    "aggregazione": (pdf.groupby("categoria", as_index=False)["quantita"].sum(),
                     plf.group_by("categoria").agg(pl.col("quantita").sum()).to_pandas()),
    "colonna nuova": (pdf.assign(totale=pdf["valore"] * pdf["quantita"]),
                      plf.with_columns((pl.col("valore") * pl.col("quantita")).alias("totale")).to_pandas()),
}
for nome, (a, b) in coppie.items():
    pd.testing.assert_frame_equal(ordina(a), ordina(b), check_dtype=False)
    print(f"{nome:<14} identico ({len(a)} righe)")

# Output:
# filtro         identico (9154 righe)
# selezione      identico (1000000 righe)
# aggregazione   identico (8 righe)
# colonna nuova  identico (1000000 righe)

La tabella raccoglie le corrispondenze che il test ha verificato, più la lettura pigra che in pandas non ha un equivalente diretto:

OperazionepandasPolars
Filtrodf[df["x"] > 5]df.filter(pl.col("x") > 5)
Selezionedf[["a", "b"]]df.select("a", "b")
Aggregazionedf.groupby("c")["q"].sum()df.group_by("c").agg(pl.col("q").sum())
Colonna nuovadf.assign(t=df["v"] * df["q"])df.with_columns((pl.col("v") * pl.col("q")).alias("t"))
Joina.merge(b, on="k")a.join(b, on="k")
Lettura pigraread_parquet(..., filters=...)pl.scan_parquet(...).filter(...).collect()

La differenza concettuale più grande non è nella sintassi ma nell'indice: Polars non ha indici di riga e non ha un MultiIndex, e ogni riga è identificata dalla posizione, come dice la guida alla migrazione dalla documentazione ufficiale. Se il tuo codice pandas usa set_index, loc con etichette o unstack, la riscrittura non è meccanica. Un altro tranello: il nome groupby usato da molti tutorial vecchi non esiste più, ed è group_by.

import polars as pl

df = pl.DataFrame({"categoria": ["a", "b", "a"], "valore": [1, 2, 3]})
try:
    df.groupby("categoria").agg(pl.col("valore").sum())      # nome usato dai vecchi tutorial
except AttributeError as e:
    print("AttributeError:", e)
print(df.group_by("categoria").agg(pl.col("valore").sum()).sort("categoria").to_dict(as_series=False))

# Output:
# AttributeError: 'DataFrame' object has no attribute 'groupby'
# {'categoria': ['a', 'b'], 'valore': [4, 2]}

NaN e null: dove i risultati divergono

I valori mancanti sono la causa più concreta di risultati diversi dopo la migrazione. Pandas usa NaN (e talvolta None) e, nei tipi predefiniti, trasforma in decimale una colonna intera che contiene un buco. In Polars il valore mancante è sempre null, la colonna intera resta intera, e NaN è un valore decimale come gli altri, che non conta come mancante. Il listato mette le due cose a confronto.

import numpy as np
import pandas as pd
import polars as pl

pdf = pd.DataFrame({"x": [1.0, np.nan, 3.0], "n": [1, None, 3]})
print(pdf.dtypes.to_dict())              # pandas: l'intero con un buco diventa float
print("pandas, media di x:", pdf["x"].mean())

nativo = pl.DataFrame({"x": [1.0, float("nan"), None], "n": [1, None, 3]})
print(nativo.schema)                     # Polars: l'intero resta intero
print("Polars, nan e null sono due cose diverse:")
print(nativo.select(
    nan=pl.col("x").is_nan(), nullo=pl.col("x").is_null()).to_dict(as_series=False))
print("Polars, media di x:", nativo["x"].mean())

# la conversione da pandas trasforma NaN in null (parametro nan_to_null)
print("da pandas:", pl.from_pandas(pdf)["x"].null_count(), "null su", len(pdf))

# Output:
# {'x': dtype('float64'), 'n': dtype('float64')}
# pandas, media di x: 2.0
# Schema({'x': Float64, 'n': Int64})
# Polars, nan e null sono due cose diverse:
# {'nan': [False, True, None], 'nullo': [False, False, True]}
# Polars, media di x: nan
# da pandas: 1 null su 3

La media di pandas ignora il NaN (2,0), mentre in Polars la colonna con NaN e null dà nan: il NaN contagia il calcolo e il null viene ignorato. La conversione pl.from_pandas trasforma i NaN in null, perciò un dato passato per quella strada si comporta come in pandas, mentre un dato letto dal file e già contenente NaN no. Aggiungi sempre un test sul tuo dato più sporco.

Polars e DuckDB nello stesso programma

Non devi scegliere un solo strumento. DuckDB può leggere un DataFrame Polars presente nel programma come se fosse una tabella, citandolo per nome di variabile, e restituire il risultato come DataFrame Polars con il metodo .pl(). È comodo quando una trasformazione si scrive meglio in SQL, e il passaggio dei dati è a colonne Arrow. La composizione completa di una pipeline è nell'articolo DuckDB e Polars: una pipeline lean in Python, mentre la scelta fra DuckDB e Spark è in DuckDB in produzione.

import duckdb
import polars as pl

df = pl.read_parquet("dati/ordini.parquet")
# DuckDB legge direttamente la variabile Python `df` (replacement scan) e restituisce un DataFrame Polars
top = duckdb.sql("""
    SELECT categoria, count(*) AS righe, round(avg(valore), 2) AS media
    FROM df GROUP BY categoria ORDER BY righe DESC LIMIT 3
""").pl()
print(type(top).__module__.split(".")[0], top.shape)
print(top)

# Output:
# polars (3, 3)
# shape: (3, 3)
# ┌───────────┬─────────┬────────┐
# │ categoria ┆ righe   ┆ media  │
# │ ---       ┆ ---     ┆ ---    │
# │ str       ┆ i64     ┆ f64    │
# ╞═══════════╪═════════╪════════╡
# │ libri     ┆ 2501822 ┆ 99.99  │
# │ casa      ┆ 2501488 ┆ 100.0  │
# │ sport     ┆ 2501032 ┆ 100.02 │
# └───────────┴─────────┴────────┘

Qui duckdb.sql(...) trova la variabile df nello scope Python (la cosiddetta replacement scan). La documentazione di DuckDB precisa che un DataFrame viene convertito per intero e filtrato dopo, mentre un LazyFrame riceve la selezione delle colonne e i filtri traducibili: con dati grandi passa un LazyFrame. Se rinomini la variabile, la query smette di funzionare con un errore di tabella inesistente. Per un uso in produzione preferisci registrare esplicitamente il DataFrame con il nome che vuoi.

Quando conviene migrare, con i conti

Una migrazione costa giornate di sviluppo e test; il vantaggio è tempo macchina, memoria e, a volte, la possibilità di usare una macchina più piccola. Il listato calcola quanto tempo serve per recuperare il costo con il solo risparmio di calcolo. I valori sono esempi miei e sono dichiarati tali nel codice: sostituiscili con i tuoi, e soprattutto con i tempi misurati sul tuo job.

# Valori di ESEMPIO: sostituiscili con i tuoi. Nessuno e' una misura.
secondi_pandas = 300        # durata del job oggi, per esecuzione
secondi_polars = 60         # durata dopo la migrazione (da misurare sul TUO codice)
esecuzioni_al_giorno = 24
costo_macchina_ora = 0.50   # euro/ora della macchina su cui gira il job
giorni_sviluppo = 6
costo_giornata_dev = 400    # euro

risparmio_giorno = (secondi_pandas - secondi_polars) * esecuzioni_al_giorno / 3600 * costo_macchina_ora
costo_migrazione = giorni_sviluppo * costo_giornata_dev
print(f"risparmio di calcolo al giorno: {risparmio_giorno:.2f} euro")
print(f"costo della migrazione: {costo_migrazione} euro")
print(f"pareggio solo sul calcolo dopo: {costo_migrazione / risparmio_giorno:.0f} giorni")

# Output:
# risparmio di calcolo al giorno: 0.80 euro
# costo della migrazione: 2400 euro
# pareggio solo sul calcolo dopo: 3000 giorni

Il risultato è sgradevole e istruttivo: anche portando un job da 300 a 60 secondi, 24 volte al giorno, il risparmio di calcolo è di meno di un euro al giorno, e il pareggio arriva dopo anni. Se il motivo della migrazione è solo il costo della macchina, spesso non conviene. Conviene quando il job non entra più nella memoria della macchina, quando supera la finestra notturna a disposizione o quando il tempo di attesa degli analisti è il costo vero.

La regola pratica che ne ricavo ha due metà. Resta su pandas se i dati sono piccoli, se il codice dipende da indici o da librerie che si aspettano un DataFrame pandas, o se il team non ha tempo per il passaggio; passa a Polars quando una misura sul tuo carico mostra un tempo o una memoria che non puoi più accettare. I due convivono bene: to_pandas() e pl.from_pandas() sono pensati per questo.

Che cosa sai fare adesso

Sai impostare un confronto onesto fra pandas e Polars: dati con seme fisso, un processo per prova, minimo-mediana-massimo e picco di memoria. Sai riconoscere dove il vantaggio è reale (aggregazione, scansioni Parquet) e dove è modesto o nullo (lettura di CSV grandi), controllare che una migrazione non cambi i risultati, e fare i conti prima di riscrivere. Per i formati su cui mettere questi file, passa a Iceberg, Delta Lake e Hudi; per versionare i risultati, a lakeFS, dove trovi anche il cambio di licenza da conoscere.

Domande frequenti

Polars è sempre più veloce di pandas?

No. Nelle mie misure su 20 milioni di righe vince nettamente sull'aggregazione e sulla lettura Parquet con filtro, vince poco sul join e pareggia sulla lettura di un CSV grande. Con dati piccoli la differenza è trascurabile rispetto al tempo di avvio di Python.

Posso usare Polars e pandas nello stesso progetto?

Sì. DataFrame.to_pandas() e pl.from_pandas() convertono in entrambe le direzioni, e il test di equivalenza di questo articolo li usa. Attenzione ai valori mancanti: la conversione da pandas trasforma i NaN in null.

Perché la stessa query dà righe in ordine diverso?

Dalla versione 2.0 il motore streaming è quello predefinito per le query pigre e non garantisce l'ordine delle righe in group_by e nei join. Se serve un ordine, aggiungi un sort esplicito al risultato.

Le licenze permettono l'uso commerciale?

Polars è distribuito con licenza MIT, come dichiara il progetto sul suo sito; pandas con licenza BSD-3-Clause secondo i metadati su PyPI. Il team di Polars vende anche una piattaforma gestita separata, che non serve per usare la libreria.

Fonti

Tutti i listati sono stati eseguiti con Python 3.14.4, pandas 3.1.1 e Polars 2.1.0. Quelli con una uscita fissa sono stati lanciati due volte con risultato identico; la tabella dei tempi viene da una sola esecuzione e cambia da una all'altra, mentre il calcolo dei costi usa valori di esempio.

Prova Questi Strumenti

Strumenti gratuiti correlati a questo argomento.

Commenti

Caricamento commenti...

Accedi per commentare

Articoli e strumenti nuovi anche su Telegram

Il canale Telegram segnala gli articoli e gli strumenti nuovi del sito.

Ti è piaciuto questo articolo?

Esplora altri contenuti sul blog o scopri i miei progetti