DuckDB e Polars si usano spesso insieme: il primo per scrivere SQL su file, il secondo per costruire trasformazioni a colonne in Python. Sono davvero complementari, o uno dei due basta? Su un CSV da 10 milioni di righe ho misurato quattro percorsi equivalenti: nessuno stravince, e il percorso "DuckDB poi Polars" non è il più rapido né il più leggero. La ragione per combinarli è l'ergonomia, e qui vedi dove conviene.
Che cosa fa ciascuno, in poche righe
DuckDB è un motore SQL analitico che gira dentro il tuo processo Python e legge direttamente CSV, Parquet e JSON. Supporta transazioni ACID, come dichiara la sua documentazione, e rimane un database vero anche quando lo usi come motore di query su file. Polars è una libreria di DataFrame con un'API a espressioni e una modalità pigra, in cui costruisci un piano di calcolo e lo esegui alla fine. Il confronto fra Polars e pandas, con le misure, è nell'articolo Polars contro pandas; la scelta fra DuckDB e Spark è in DuckDB in produzione.
Conviene avere letto prima questi due articoli o conoscere l'equivalente: qui do per noto che cosa sia un piano pigro e perché un file Parquet si legge a colonne. Per il resto bastano Python e un po' di SQL. Le versioni usate sono DuckDB 2.0.0 e Polars 2.1.0, entrambe correnti al 2026-11-13; entrambe hanno cambiato API rispetto alle versioni dei vecchi tutorial, e lungo l'articolo segnalo dove.
Il dataset di prova
Il file è un registro di 10 milioni di transazioni su tre anni, con data, paese (20 valori), cliente e importo. Viene generato con un seme fisso, perciò due esecuzioni producono lo stesso file e le somme riportate si possono rifare. Il CSV pesa circa 274 MB: abbastanza grande da far lavorare i motori, abbastanza piccolo da stare in memoria su un portatile.
import numpy as np, polars as pl, pathlib
pathlib.Path("dati").mkdir(exist_ok=True)
rng = np.random.default_rng(2024) # seme fisso
n = 10_000_000
paesi = np.array(["IT", "DE", "FR", "ES", "NL", "PL", "SE", "AT", "BE", "PT", "IE", "DK", "FI", "GR", "CZ", "HU", "RO", "BG", "HR", "SK"])
giorni = np.datetime64("2023-01-01") + rng.integers(0, 3 * 365, n).astype("timedelta64[D]")
df = pl.DataFrame({
"transaction_date": giorni,
"country": paesi[rng.integers(0, len(paesi), n)],
"customer_id": rng.integers(0, 2_000_000, n),
"amount": np.round(rng.lognormal(3.5, 0.8, n), 2),
})
df.write_csv("dati/transazioni.csv")
print(df.schema)
print("righe:", df.height, "| CSV:", round(pathlib.Path("dati/transazioni.csv").stat().st_size / 1e6), "MB")
print("intervallo date:", df["transaction_date"].min(), "->", df["transaction_date"].max())
# Output:
# Schema({'transaction_date': Date, 'country': String, 'customer_id': Int64, 'amount': Float64})
# righe: 10000000 | CSV: 274 MB
# intervallo date: 2023-01-01 -> 2025-12-30
Lo schema che Polars stampa (Date, String, Int64, Float64) è quello che avrai anche leggendo il file con try_parse_dates=True o con read_csv di DuckDB, che riconosce le date da solo. Nei CSV reali questa inferenza è il primo punto di rottura: una sola riga con un valore anomalo può far cambiare tipo alla colonna, quindi in produzione dichiara i tipi esplicitamente.
Solo DuckDB: una query
La domanda "quali sono i tre paesi con più ricavi nel 2024?" è una query SQL naturale. duckdb.sql(...) restituisce una relazione, cioè una query non ancora eseguita, e .pl() la esegue e restituisce un DataFrame Polars. Per stampare i numeri in forma estesa dovrei impostare pl.Config.set_fmt_float("full"), altrimenti Polars usa la notazione scientifica, come mostra l'uscita qui sotto.
import duckdb
top = duckdb.sql("""
SELECT country, round(sum(amount), 2) AS ricavi, count(*) AS transazioni
FROM read_csv('dati/transazioni.csv')
WHERE year(transaction_date) = 2024
GROUP BY country
ORDER BY ricavi DESC
LIMIT 3
""")
print(top.pl())
# Output:
# shape: (3, 3)
# ┌─────────┬──────────┬─────────────┐
# │ country ┆ ricavi ┆ transazioni │
# │ --- ┆ --- ┆ --- │
# │ str ┆ f64 ┆ i64 │
# ╞═════════╪══════════╪═════════════╡
# │ AT ┆ 7.6644e6 ┆ 167582 │
# │ SE ┆ 7.6540e6 ┆ 167269 │
# │ NL ┆ 7.6511e6 ┆ 167853 │
# └─────────┴──────────┴─────────────┘
Una novità della 2.0 che i vecchi tutorial non conoscono: .pl() esiste sulle relazioni create con duckdb.sql o con.sql, ma non sul risultato di con.execute(), e sulle relazioni fetch_arrow_table e fetch_record_batch sono alias deprecati di to_arrow_table e to_arrow_reader. Se copi codice di due anni fa che concatena conn.execute(...).fetch_arrow_table(), controlla la pagina Python della documentazione della tua versione prima di accusare i dati.
Il passaggio a Polars: filtrare in SQL, trasformare a colonne
Alcune trasformazioni sono scomode in SQL e comode in Polars: tabelle larghe con pivot, somme mobili per gruppo, catene di espressioni riutilizzabili. Lo schema che propongo è questo: DuckDB legge il file e restituisce solo le colonne e le righe che servono, Polars fa il resto in modalità pigra. Il listato si chiude con un controllo incrociato: il totale per paese calcolato da Polars deve coincidere con quello che DuckDB calcola da solo in SQL.
import duckdb
import polars as pl
pl.Config.set_fmt_float("full")
# 1) DuckDB legge il CSV, filtra e proietta SOLO le colonne che servono; .pl() restituisce un DataFrame Polars
anno = duckdb.sql("""
SELECT country, transaction_date, amount
FROM read_csv('dati/transazioni.csv')
WHERE year(transaction_date) = 2024
""").pl()
print("righe dopo il filtro:", anno.height, "| colonne:", anno.columns)
# 2) Polars: ricavi mensili per paese, tabella larga, somma mobile a 3 mesi
mensile = (
anno.lazy()
.group_by("country", pl.col("transaction_date").dt.month().alias("mese"))
.agg(pl.col("amount").sum().round(2).alias("ricavi"))
.sort("country", "mese")
.with_columns(pl.col("ricavi").rolling_sum(window_size=3).over("country").alias("mobile_3_mesi"))
.collect()
)
print(mensile.filter(pl.col("country") == "IT").head(4))
larga = mensile.pivot(on="mese", index="country", values="ricavi").sort("country")
print("tabella larga:", larga.shape)
# 3) controllo incrociato: il totale per paese deve coincidere con quello calcolato da DuckDB in SQL
sql = duckdb.sql("""
SELECT country, round(sum(amount), 2) AS ricavi FROM read_csv('dati/transazioni.csv')
WHERE year(transaction_date) = 2024 GROUP BY country ORDER BY country""").pl()
totali = mensile.group_by("country").agg(pl.col("ricavi").sum().round(2)).sort("country")
differenza = (totali["ricavi"] - sql["ricavi"]).abs().max()
print("scarto massimo fra Polars e SQL:", round(differenza, 2))
larga.write_parquet("dati/ricavi_2024_larga.parquet")
# Output:
# righe dopo il filtro: 3341070 | colonne: ['country', 'transaction_date', 'amount']
# shape: (4, 4)
# ┌─────────┬──────┬───────────┬───────────────┐
# │ country ┆ mese ┆ ricavi ┆ mobile_3_mesi │
# │ --- ┆ --- ┆ --- ┆ --- │
# │ str ┆ i8 ┆ f64 ┆ f64 │
# ╞═════════╪══════╪═══════════╪═══════════════╡
# │ IT ┆ 1 ┆ 643413.45 ┆ null │
# │ IT ┆ 2 ┆ 593282.06 ┆ null │
# │ IT ┆ 3 ┆ 646162.44 ┆ 1882857.95 │
# │ IT ┆ 4 ┆ 625001.08 ┆ 1864445.58 │
# └─────────┴──────┴───────────┴───────────────┘
# tabella larga: (20, 13)
# scarto massimo fra Polars e SQL: 0.0
Il filtro sull'anno 2024 riduce i dati da 10 milioni a 3.341.070 righe e a tre colonne prima di entrare in Polars. La somma mobile rolling_sum(window_size=3).over("country") restituisce null per i primi due mesi di ogni paese, perché la finestra non è ancora completa: è corretto, e va gestito quando usi quella colonna. Lo scarto massimo fra i due calcoli è 0,0 dopo l'arrotondamento a due decimali: i motori sommano i decimali in ordine diverso, e senza arrotondare vedresti differenze nell'ultimo decimale.
I quattro percorsi, misurati
Resta la domanda decisiva: conviene davvero far leggere il file a DuckDB? Per rispondere ho confrontato quattro modi di calcolare lo stesso risultato (ricavi 2024 per paese) in un processo nuovo ciascuno: Polars che legge tutto il CSV e poi filtra, Polars in modalità pigra con scan_csv, DuckDB da solo, e il percorso ibrido DuckDB poi Polars. Il file percorsi.py contiene i quattro modi; qui sotto trovi il driver e l'uscita, che mostra minimo, mediana e massimo di 5 ripetizioni e il picco di memoria.
"""Un percorso alla volta, in un processo nuovo: python percorsi.py <percorso>. Stampa: min mediana max (ms) e picco (MB)."""
import resource, sys, time
nome = sys.argv[1]
FILE = "dati/transazioni.csv"
def polars_eager():
import polars as pl
df = pl.read_csv(FILE, try_parse_dates=True)
return df.filter(pl.col("transaction_date").dt.year() == 2024).group_by("country").agg(pl.col("amount").sum())
def polars_lazy():
import polars as pl
return (pl.scan_csv(FILE, try_parse_dates=True).filter(pl.col("transaction_date").dt.year() == 2024)
.group_by("country").agg(pl.col("amount").sum()).collect())
def duckdb_sql():
import duckdb
return duckdb.sql(f"""SELECT country, sum(amount) AS amount FROM read_csv('{FILE}')
WHERE year(transaction_date) = 2024 GROUP BY country""").pl()
def duckdb_poi_polars():
import duckdb, polars as pl
anno = duckdb.sql(f"""SELECT country, amount FROM read_csv('{FILE}')
WHERE year(transaction_date) = 2024""").pl()
return anno.group_by("country").agg(pl.col("amount").sum())
F = {"polars_eager": polars_eager, "polars_lazy": polars_lazy, "duckdb_sql": duckdb_sql, "duckdb_poi_polars": duckdb_poi_polars}[nome]
tempi = []
for _ in range(5):
t0 = time.perf_counter(); F(); tempi.append(time.perf_counter() - t0)
tempi.sort()
print(f"{tempi[0]*1000:.0f} {tempi[2]*1000:.0f} {tempi[-1]*1000:.0f} {resource.getrusage(resource.RUSAGE_SELF).ru_maxrss/1024:.0f}")
import subprocess, sys
for nome in ("polars_eager", "polars_lazy", "duckdb_sql", "duckdb_poi_polars"):
r = subprocess.run([sys.executable, "percorsi.py", nome], capture_output=True, text=True)
if r.returncode:
print(nome, "ERRORE:", r.stderr.strip().splitlines()[-1]); continue
lo, med, hi, rss = r.stdout.split()
print(f"{nome:<18} min {lo:>5} mediana {med:>5} max {hi:>5} ms picco {rss:>5} MB")
# Output:
# polars_eager min 249 mediana 314 max 415 ms picco 912 MB
# polars_lazy min 256 mediana 280 max 503 ms picco 528 MB
# duckdb_sql min 333 mediana 393 max 587 ms picco 864 MB
# duckdb_poi_polars min 347 mediana 378 max 642 ms picco 969 MB
Il verdetto non è quello che ci si aspetta da un articolo sul combinare i due strumenti. Il percorso più leggero in memoria è Polars pigro, con circa 525-540 MB, perché scan_csv spinge il filtro dentro la lettura; è anche il più rapido o a pari merito. DuckDB da solo sta a metà, e il percorso ibrido è l'ultimo nel tempo e, con Polars che legge tutto, il più pesante in memoria: la causa più probabile è che materializza in un DataFrame i 3,3 milioni di righe filtrate prima che Polars inizi a lavorare (non l'ho isolata con una misura a parte). Le differenze di tempo fra i primi tre sono dell'ordine di qualche decina di millisecondi, entro la variabilità delle esecuzioni.
Come leggerlo: non scegliere DuckDB per "leggere più veloce" un CSV, perché su questo carico non lo è. Sceglilo quando la lettura è accompagnata da join, da funzioni finestra o da più file da unire con un glob, cose per cui SQL è più corto e più chiaro; scegli Polars quando la parte difficile è la trasformazione. Questa misura riguarda un solo file, un filtro e un'aggregazione: con più file, join grandi o sorgenti remote il risultato può cambiare, e va rimisurato.
Convertire in Parquet senza caricare tutto
Un compito frequente è convertire il CSV in Parquet, che occupa meno spazio e si legge a colonne. Il metodo ingenuo in Polars è read_csv seguito da write_parquet, che porta tutto in memoria; scan_csv seguito da sink_parquet elabora il file a blocchi. DuckDB offre COPY (...) TO ... (FORMAT parquet). Il listato esegue i tre metodi in processi separati e verifica che i tre file contengano le stesse righe e la stessa somma.
"""python conversione.py <metodo>: converte tutto il CSV in Parquet. Stampa secondi e picco di memoria (MB)."""
import resource, sys, time
metodo, SRC = sys.argv[1], "dati/transazioni.csv"
DST = f"dati/out_{metodo}.parquet"
t0 = time.perf_counter()
if metodo == "polars_eager":
import polars as pl
pl.read_csv(SRC, try_parse_dates=True).write_parquet(DST)
elif metodo == "polars_sink":
import polars as pl
pl.scan_csv(SRC, try_parse_dates=True).sink_parquet(DST)
else:
import duckdb
duckdb.sql(f"COPY (SELECT * FROM read_csv('{SRC}')) TO '{DST}' (FORMAT parquet)")
print(f"{time.perf_counter() - t0:.2f} {resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024:.0f}")
import subprocess, sys, duckdb
for metodo in ("polars_eager", "polars_sink", "duckdb_copy"):
r = subprocess.run([sys.executable, "conversione.py", metodo], capture_output=True, text=True)
if r.returncode:
print(metodo, "ERRORE:", r.stderr.strip().splitlines()[-1]); continue
secondi, picco = r.stdout.split()
controllo = duckdb.sql(f"SELECT count(*), round(sum(amount), 2) FROM 'dati/out_{metodo}.parquet'").fetchall()[0]
print(f"{metodo:<13} {secondi:>5} s picco {picco:>5} MB righe {controllo[0]} somma {controllo[1]}")
# Output:
# polars_eager 0.76 s picco 783 MB righe 10000000 somma 456197116.21
# polars_sink 0.83 s picco 565 MB righe 10000000 somma 456197116.21
# duckdb_copy 0.90 s picco 1006 MB righe 10000000 somma 456197116.21
I tre metodi producono file con le stesse 10 milioni di righe e la stessa somma (456.197.116,21), e questa è la prima cosa da controllare in qualunque conversione. Il percorso sink_parquet ha il picco di memoria più basso, circa 570-580 MB contro circa 775 MB della lettura completa e oltre 1 GB di DuckDB, che per impostazione predefinita usa tutti i thread e un limite di memoria alto. Se la memoria è il vincolo, limita DuckDB con memory_limit e threads come nell'articolo DuckDB in produzione.
Testare le trasformazioni
Una pipeline di dati è codice, e una funzione che riceve un LazyFrame e ne restituisce un altro è facile da testare senza toccare il disco. Il listato definisce ricavi_per_paese, la prova su un DataFrame di quattro righe in cui una data cade il 31 dicembre 2023 per verificare che il filtro funzioni al confine, e la stessa logica scritta in SQL con il metodo sql() di Polars, che interroga il DataFrame chiamandolo self.
import polars as pl
from polars.testing import assert_frame_equal
def ricavi_per_paese(lf: pl.LazyFrame, anno: int) -> pl.LazyFrame:
"""Trasformazione pura: riceve un LazyFrame, ne restituisce un altro, non tocca il disco."""
return (lf.filter(pl.col("transaction_date").dt.year() == anno)
.group_by("country").agg(pl.col("amount").sum().alias("ricavi"))
.sort("country"))
piccolo = pl.DataFrame({
"transaction_date": ["2024-03-01", "2024-07-15", "2023-12-31", "2024-01-10"],
"country": ["IT", "IT", "IT", "DE"],
"amount": [10.0, 5.5, 99.0, 7.0],
}).with_columns(pl.col("transaction_date").str.to_date())
atteso = pl.DataFrame({"country": ["DE", "IT"], "ricavi": [7.0, 15.5]})
assert_frame_equal(ricavi_per_paese(piccolo.lazy(), 2024).collect(), atteso)
print("il filtro sull'anno esclude il 2023-12-31: test superato")
# la stessa trasformazione, scritta in SQL sul DataFrame con il metodo sql() di Polars
via_sql = piccolo.sql("""
SELECT country, sum(amount) AS ricavi FROM self
WHERE year(transaction_date) = 2024 GROUP BY country ORDER BY country""")
assert_frame_equal(via_sql, atteso)
print("la versione SQL dà lo stesso risultato")
# Output:
# il filtro sull'anno esclude il 2023-12-31: test superato
# la versione SQL dà lo stesso risultato
I test usano assert_frame_equal di polars.testing, che confronta tipi, nomi e valori. La scelta di casi di prova con un confine (l'ultimo giorno dell'anno precedente) cattura il difetto più comune, cioè un filtro sull'anno scritto male. Tieni i test su dati minuscoli: servono a proteggere la logica, non a misurare le prestazioni, per le quali hai le misure del paragrafo precedente.
Capire dove va il tempo
I tutorial indicano spesso LazyFrame.profile() per misurare il tempo di ogni nodo: in Polars 2.x il metodo è stato rimosso, perché progettato per il motore in memoria e fuorviante con il motore streaming ora predefinito. Il listato lo prova, stampa il piano ottimizzato con explain() e chiede a DuckDB l'EXPLAIN ANALYZE, filtrando l'uscita per mostrare solo i conteggi di righe e non i tempi, che cambiano a ogni esecuzione.
import re
import duckdb
import polars as pl
from polars.exceptions import AttributeRemovedError
lf = (pl.scan_csv("dati/transazioni.csv", try_parse_dates=True)
.filter(pl.col("transaction_date").dt.year() == 2024)
.group_by("country").agg(pl.col("amount").sum()))
try:
lf.profile() # il metodo che molti tutorial indicano
except AttributeRemovedError as e:
print("Polars:", str(e).split(";")[0])
print(lf.explain()) # il piano, senza eseguire la query
piano = duckdb.sql("""EXPLAIN ANALYZE SELECT country, sum(amount) FROM read_csv('dati/transazioni.csv')
WHERE year(transaction_date) = 2024 GROUP BY country""").fetchall()
for riga in piano[0][1].splitlines(): # il testo del piano contiene anche i tempi: stampo solo i conteggi
testo = riga.strip("│╭╮╰╯┰┸┒┎┚┖─ ")
if "BETWEEN" in testo:
print("DuckDB, il filtro riscritto:", testo)
elif re.match(r"[\d,]+ rows", testo):
print("DuckDB, righe che attraversano un operatore:", testo.split()[0])
# Output:
# Polars: `profile` was removed in version 2.0
# AGGREGATE[maintain_order: false]
# [col("amount").sum()] BY [col("country")]
# FROM
# simple π 2/2 ["country", "amount"]
# Csv SCAN [dati/transazioni.csv]
# PROJECT 3/4 COLUMNS
# SELECTION: (col("transaction_date").dt.year() == 2024)
# ESTIMATED ROWS: 10523554
# DuckDB, righe che attraversano un operatore: 20
# DuckDB, righe che attraversano un operatore: 3,341,070
# DuckDB, righe che attraversano un operatore: 3,341,070
# DuckDB, il filtro riscritto: transaction_date BETWEEN '2024-01-01'::DATE AND '2024-12-31'::DATE
# DuckDB, righe che attraversano un operatore: 3,341,070
# DuckDB, righe che attraversano un operatore: 10,000,000
Nel piano di Polars vedi che il filtro sull'anno e la scelta di tre colonne su quattro sono dentro la scansione del CSV; nel piano di DuckDB il filtro year(transaction_date) = 2024 è stato riscritto come intervallo BETWEEN tra due date, la forma che l'ottimizzatore sa spingere nella lettura. Il numero 10.000.000 vicino a 3.341.070 dice quante righe ha letto la scansione e quante ne sono rimaste dopo il filtro: se i due numeri coincidono, il tuo filtro non sta riducendo nulla.
Come scegliere
Sulla base delle misure e dei listati, la regola pratica si riassume in questa tabella. L'ordine delle righe non ha importanza: sono casi indipendenti.
| Situazione | Scelta | Perché |
|---|---|---|
| Un file, filtro e aggregazione | Polars pigro o DuckDB | Tempi paragonabili; Polars pigro ha il picco di memoria più basso nella mia misura |
| Join, finestre, più file da unire | DuckDB | SQL è più corto e le sorgenti si leggono con un glob |
| Pivot, somme mobili per gruppo, trasformazioni riutilizzabili | Polars | Le espressioni si compongono in funzioni testabili |
| Conversione di un file grande in Parquet | Polars con sink_parquet | Elabora a blocchi con il picco più basso |
| Versionare le uscite | Un sistema esterno | Vedi lakeFS e la licenza da valutare |
Il percorso ibrido ha senso quando la parte SQL riduce davvero i dati: se DuckDB filtra 10 milioni di righe in 10 mila, il passaggio a Polars costa niente. Se il filtro lascia passare un terzo dei dati, come qui, è il passaggio che costa. Sul dove mettere la pipeline dentro un'architettura completa, l'ultimo articolo della serie è Modern Data Stack: un'architettura minima. Per il formato di tabella su cui pubblicare i risultati, vedi Iceberg, Delta Lake e Hudi.
Che cosa sai fare adesso
Sai far parlare DuckDB e Polars con i metodi attuali (duckdb.sql(...).pl()), sai misurare quanta memoria e quanto tempo costa ogni percorso, convertire un CSV grande in Parquet a blocchi, scrivere una trasformazione testabile e leggere i piani di entrambi i motori. Sai anche che combinare i due non è un guadagno automatico: dipende da quante righe tolgono il filtro iniziale.
Domande frequenti
DuckDB è transazionale?
Sì: la documentazione dichiara il supporto alle transazioni ACID. Il vincolo che conta in produzione non è la transazionalità ma la concorrenza, con un solo processo in lettura e scrittura per file di database.
Perché .pl() non funziona dopo con.execute()?
.pl() non funziona dopo con.execute()?In DuckDB 2.0 il metodo è disponibile sulle relazioni create con duckdb.sql o con.sql, non sul risultato di con.execute(). Usa con.sql(...) e chiama .pl() sulla relazione.
È meglio la modalità pigra o quella eager in Polars?
Nelle mie misure la lettura pigra con scan_csv ha usato meno memoria della lettura completa (circa 530 MB contro 910 MB) con tempi uguali o migliori. Per query semplici su dati piccoli la differenza non si nota.
Posso interrogare un DataFrame Polars da DuckDB?
Sì, citandolo per nome nella query. La documentazione precisa che un LazyFrame riceve la selezione delle colonne e i filtri traducibili, mentre un DataFrame viene convertito per intero e filtrato dopo.
Fonti
- DuckDB 2.0: Integration with Polars - metodo
.pl()sulle relazioni, parametrolazy, pushdown verso i LazyFrame, consultata il 2026-11-13 - DuckDB 2.0: Export to Apache Arrow -
to_arrow_table,to_arrow_readere alias deprecati, consultata il 2026-11-13 - DuckDB 2.0: Transaction Management - supporto alle transazioni ACID, consultata il 2026-11-13
- Polars user guide: Upgrade guide to version 2 - motore streaming predefinito e rimozione di
profile, consultata il 2026-11-13 - Polars: LazyFrame.collect - i motori disponibili, consultata il 2026-11-13
- PyPI: duckdb - versione 2.0.0 e licenza MIT, consultata il 2026-11-13
Tutti i listati con uscita sono stati eseguiti con Python 3.14.4, DuckDB 2.0.0 e Polars 2.1.0; quelli deterministici due volte con uscita identica. Le tabelle di tempi e memoria vengono da una sola esecuzione e cambiano a ogni lancio; il confronto a quattro percorsi è stato ripetuto due volte con lo stesso ordine dei risultati. Il codice dei percorsi e della conversione è mostrato nel testo.

Commenti
Caricamento commenti...
Accedi per commentare