PySpark Read CSV: carica ed elabora file di grandi dimensioni in modo efficiente

I file CSV sono pilastri essenziali nell’elaborazione e nell’analisi dei dati. Quasi ogni professionista dei dati, dagli ingegneri dei dati di livello intermedio e data scientist agli sviluppatori che usano PySpark, prima o poi si trova a lavorare con file CSV. Tuttavia, quando i dataset crescono da megabyte a gigabyte, fino a terabyte e oltre, strumenti semplici e singoli come Pandas o le librerie standard di Python faticano a reggere il carico. È qui che Apache Spark e PySpark diventano fondamentali per gestire file CSV su larga scala in ambienti di calcolo distribuito.

Questo articolo ti insegnerà tutto ciò che devi sapere per leggere file CSV di grandi dimensioni con PySpark. 

Assicurati di avere PySpark installato e di conoscere le basi seguendo il nostro tutorial Primi passi con PySpark. 

Che cos’è la lettura di CSV in PySpark?

PySpark consente di leggere file CSV in DataFrame distribuiti. I DataFrame in PySpark somigliano molto ai DataFrame di Pandas, offrendo un’interfaccia familiare. Sotto il cofano, però, i DataFrame di PySpark distribuiscono il calcolo e l’archiviazione su più nodi, garantendo prestazioni eccezionali per dataset enormi. 

PySpark offre vantaggi interessanti per i file CSV di grandi dimensioni, come:

• Caricamento distribuito dei dati,
• Gestione solida dei valori null,
• Flessibilità nella definizione dello schema, e
• Modi semplici per gestire file CSV multipli o compressi.

Tuttavia, emergono sfide comuni, tra cui gestire in modo efficiente le intestazioni, dedurre o specificare correttamente gli schemi e gestire record malformati o incoerenti. Continua a leggere per scoprire come affrontarle tutte. 

Leggere file CSV in PySpark è uno degli argomenti che devi padroneggiare per superare un colloquio su PySpark. Il nostro articolo Le 36 migliori domande e risposte su PySpark per il 2025 offre una guida completa alle domande di colloquio su PySpark, dai concetti di base alle tecniche avanzate e alle strategie di ottimizzazione.  

Fondamenti della lettura di file CSV in PySpark

La lettura dei dati CSV è spesso uno dei passaggi iniziali e più critici nei workflow PySpark, la base per trasformazioni successive, analisi esplorative e attività di machine learning. Farlo bene garantisce un’elaborazione dei dati più pulita e migliori prestazioni a valle.

Quadro concettuale

PySpark legge i file CSV all’interno del modello distribuito di Spark. Invece di leggere tutti i dati CSV in memoria su una singola macchina, Spark suddivide i grandi carichi di lavoro tra più nodi del cluster. Il Catalyst optimizer integrato in Spark migliora ulteriormente le prestazioni eseguendo in modo efficiente le operazioni necessarie durante l’ingestione dei CSV.

Sintassi di base per la lettura

Il modo semplice per leggere file CSV utilizza le funzioni integrate di Spark: 

spark.read.csv("file_path", header=True, inferSchema=True)Offerto da

Oppure in modo esplicito:

spark.read.format("csv").option("header", "True").load("file_path")Offerto da

I parametri chiave includono:

• file_path - posizione dei file CSV.
• header - imposta i nomi delle colonne dalle intestazioni del CSV se True.
• inferSchema - deduce automaticamente i tipi di dato delle colonne.
• delimiter - carattere che separa le colonne; il valore predefinito è la virgola.

Il nostro tutorial Impara PySpark da zero nel 2025 approfondisce i fondamenti di PySpark e come impararlo. 

Lettura di file CSV: opzioni e configurazioni

PySpark offre numerose opzioni che consentono un controllo granulare sul processo di lettura dei CSV.

Intestazioni e inferenza dello schema

Impostare header=True indica a Spark di usare la prima riga del CSV come nomi delle colonne.

inferSchema=True  consente a Spark di indovinare automaticamente i tipi di colonna scansionando i dati:

spark.read.csv("customers.csv", header=True, inferSchema=True)Offerto da

Sebbene l’inferenza dello schema sia comoda ed efficace inizialmente, su dataset di grandi dimensioni le prestazioni si riducono perché Spark esegue passaggi ripetuti sui dati per determinare i tipi.

Specificare uno schema personalizzato 

Definire esplicitamente lo schema migliora notevolmente le prestazioni eliminando le scansioni ripetute dei dati da parte di Spark. Uno schema definito comunica in anticipo nomi e tipi delle colonne.

Ecco come definire uno schema personalizzato in PySpark:

from pyspark.sql.types import StructType, StructField, StringType, IntegerType, DoubleType
schema = StructType([
    StructField("user_id", IntegerType(), True),
    StructField("name", StringType(), True),
    StructField("score", DoubleType(), True),
])
df = spark.read.csv("customers.csv", schema=schema, header=True)Offerto da

Passiamo ora a esplorare la gestione dei delimitatori in PySpark durante la lettura dei file CSV. 

Gestione di delimitatori e caratteri speciali

Molti file CSV usano delimitatori diversi dalla virgola, come pipe o tabulazioni. PySpark consente di specificare esplicitamente il delimitatore:

spark.read.csv("customers.csv", header=True, delimiter="|")Offerto da

Inoltre, è possibile configurare anche i caratteri di escape e di quoting per gestire scenari con caratteri speciali:

spark.read.csv("data.csv", header=True, escape='\"', quote='"')Offerto da

Gestione di valori null e mancanti

I dati CSV del mondo reale contengono spesso incongruenze o record incompleti. PySpark semplifica la gestione dei valori null traducendo segnaposto personalizzati in valori null:

spark.read.csv("customers.csv", header=True, schema=schema, nullValue="NA")Offerto da

Questo rende più chiari i valori null, riducendo drasticamente la pulizia manuale dei dati in seguito.

Vediamo altre strategie per gestire i valori null. 

Puoi decidere di filtrare i valori null: 

# Filtra le righe in cui Age non è null
df_filtered = df.filter(df["Age"].isNotNull())
df_filtered.show()Offerto da

Questo filtra il DataFrame includendo solo le righe in cui la colonna Age non è null. L’output dovrebbe essere simile a:

+---+-----+---+------+
| ID| Name|Age|Salary|
+---+-----+---+------+
|  1| John| 25| 50000|
|  3|  Bob| 30|  NULL|
|  4|Carol| 28| 55000|
+---+-----+---+------+Offerto da

L’altra strategia è riempire i valori null: 

# Sostituisci i valori null in Age e Salary con valori predefiniti
df_filled = df.na.fill({"Age": 0, "Salary": 0})
df_filled.show()Offerto da

L’output sarà simile a questo: 

+---+-----+---+------+
| ID| Name|Age|Salary|
+---+-----+---+------+
|  1| John| 25| 50000|
|  2|Alice|  0| 60000|
|  3|  Bob| 30|     0|
|  4|Carol| 28| 55000|
|  5|David|  0| 48000|
+---+-----+---+------+Offerto da

Lettura di file e directory multiple

PySpark eccelle nella gestione di dataset grandi e composti da più file. Invece di caricare e unire manualmente i file di una directory in sequenza, PySpark supporta pattern con wildcard per un caricamento massivo rapido ed efficiente:

spark.read.csv("/data/sales/*.csv", header=True, schema=schema)Offerto da

Questo aggrega efficacemente numerosi file CSV in un unico DataFrame con un’unica operazione snella.

Una volta caricati i dati in PySpark, i passaggi successivi includono wrangling, feature engineering e costruzione di modelli di machine learning. Il nostro corso Feature Engineering con PySpark approfondisce questi concetti. 

Tecniche di ottimizzazione per una lettura efficiente dei CSV

Quando si gestiscono dati CSV su larga scala, sfruttare le strategie di ottimizzazione di PySpark è fondamentale.

Strategie di partizionamento

Il partizionamento influisce fortemente sulle prestazioni distribuendo uniformemente i dati tra i nodi del cluster. Spark consente un controllo esplicito sulla dimensione e sul numero di partizioni durante l’ingestione per accelerare le operazioni successive:

df = spark.read.csv("data.csv", header=True, schema=schema).repartition(20)Offerto da

​​.repartition(20) suddivide il DataFrame in 20 partizioni nel tuo cluster Spark. Poiché Spark elabora i dati a blocchi, avere più partizioni può:

• Migliorare il parallelismo
• Bilanciare il carico di lavoro sul cluster
• Velocizzare trasformazioni e scritture

Se stai eseguendo su un cluster con molti core, questo aiuta a sfruttarli appieno. Ma se esageri (per esempio, 1000 partizioni su un dataset piccolo) puoi rallentare le cose.

Scopri altre funzioni di Spark come repartition con il nostro PySpark Cheat Sheet: Spark in Python. Approfondisce l’inizializzazione di Spark in Python, il caricamento dei dati, l’ordinamento e il repartizionamento. 

Caching e persistenza

Se il tuo workflow prevede l’accesso ripetuto allo stesso dataset dopo l’ingestione, effettuare il caching del DataFrame in memoria o su disco può incrementare notevolmente le prestazioni:

df.cache()Offerto da

Ricorda però che il caching richiede risorse di sistema adeguate; bilancia sempre l’uso di memoria con i benefici prestazionali.

Valutazione lazy e azioni di trigger

PySpark si basa su un modello di valutazione lazy: le operazioni sui DataFrame trasformano i piani invece di essere eseguite subito. La lettura effettiva dei file avviene solo quando necessario, attivata da comandi come show(), count() o collect():

# nessuna lettura ancora
df = spark.read.csv("data.csv", header=True, schema=schema)   
# la lettura effettiva parte qui
df.show(5)  Offerto da

Casi d’uso avanzati e considerazioni

Vediamo scenari più complessi che potresti incontrare durante la lettura dei file CSV: 

Lettura di file CSV compressi

Spark gestisce in modo efficiente file CSV compressi come gz o .bz2  in modo trasparente, senza configurazioni aggiuntive:

spark.read.csv("logs.csv.gz", header=True, schema=schema)Offerto da

Gestione dei record malformati

I dataset CSV possono contenere righe malformate. PySpark offre diverse opzioni per gestire con grazia errori o record malformati:

• mode="PERMISSIVE" (predefinito): include le righe malformate riempiendo con null le colonne.
• mode="DROPMALFORMED: salta in silenzio i record malformati. Questa modalità non è supportata nelle funzioni CSV integrate.
• mode="FAILFAST": genera un’eccezione quando incontra qualsiasi record malformato.

spark.read.csv("data.csv", header=True, schema=schema, mode="FAILFAST")Offerto da

Impostazioni di locale e codifica

A volte i dati CSV usano codifiche non standard. PySpark gestisce facilmente codifiche diverse tramite il parametro encoding:

spark.read.csv("data_utf8.csv", header=True, encoding="UTF-8")Offerto da

Le codifiche supportate includono US-ASCII, ISO-8859-1, UTF-8, UTF-16BE, UTF-16LE e UTF-16. 

Best practice e insidie comuni

Ecco alcune best practice da tenere a mente quando leggi file CSV con Spark: 

• Specifica esplicitamente lo schema quando la struttura del dataset è nota.
• Controlla il partizionamento per distribuire il carico in modo efficiente.
• Fai caching in modo strategico per i DataFrame a cui accedi spesso.
• Attiva intenzionalmente le azioni di lettura, tenendo a mente la valutazione lazy.

Assicurati di evitare: 

• Impostare header=False per CSV con righe di intestazione.
• Affidarti esclusivamente a inferSchema su dataset grandi o accessi ripetuti.
• Ignorare impostazioni critiche di delimitatore o codifica.

Conclusione

Comprendere e sfruttare correttamente le potenti funzionalità di ingestione CSV di PySpark è essenziale per un’elaborazione efficace dei big data. Con una chiara specifica dello schema, la gestione di formati null personalizzati, un partizionamento efficiente e la gestione di scenari con file compressi o multipli, il tuo workflow diventa snello e performante.

Ricorda che, sebbene PySpark offra enormi vantaggi per attività su larga scala, per dataset piccoli strumenti più semplici come Pandas possono essere sufficienti. Usa PySpark quando lavori con dati che superano le capacità di una singola macchina, e considera sempre i vantaggi del calcolo distribuito.

Per esplorare ulteriormente PySpark, dai un’occhiata ai nostri corsi Spark approfonditi, tra cui:

• Introduzione a PySpark
• Fondamenti di PySpark 
• Fondamenti di Big Data con PySpark
• Costruire motori di raccomandazione con PySpark