Salta al contenuto principale

04 - DuckDB + Polars: pipeline lean Python

DuckDB e Polars insieme in una pipeline Python: query SQL, trasformazioni a colonne, conversione a Parquet e quattro percorsi misurati su 10 milioni di righe.

Cosa ne pensi di questo articolo?

04 - DuckDB + Polars: pipeline lean Python
Data Engineering 2027Foto:Firmbee.comPexels

In Breve

DuckDB e Polars insieme in una pipeline Python: query SQL, trasformazioni a colonne, conversione a Parquet e quattro percorsi misurati su 10 milioni di righe.

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.

SituazioneSceltaPerché
Un file, filtro e aggregazionePolars pigro o DuckDBTempi paragonabili; Polars pigro ha il picco di memoria più basso nella mia misura
Join, finestre, più file da unireDuckDBSQL è più corto e le sorgenti si leggono con un glob
Pivot, somme mobili per gruppo, trasformazioni riutilizzabiliPolarsLe espressioni si compongono in funzioni testabili
Conversione di un file grande in ParquetPolars con sink_parquetElabora a blocchi con il picco più basso
Versionare le usciteUn sistema esternoVedi 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()?

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

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.

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