PySpark CSV lezen: Grote bestanden efficiënt laden en verwerken

CSV-bestanden zijn onmisbare pijlers in gegevensverwerking en analytics. Vrijwel elke dataprofessional, van medior data-engineers en data scientists tot developers die PySpark gebruiken, krijgt vroeg of laat te maken met CSV-bestanden. Maar naarmate datasets groeien van megabytes naar gigabytes, of zelfs terabytes en meer, raken eenvoudige, enkelvoudige tools zoals Pandas of standaard Python-bibliotheken overbelast. Dit is waar Apache Spark en PySpark belangrijk worden om grootschalige CSV-bestanden in gedistribueerde computenomgevingen te beheren.

Dit artikel leert je alles wat je moet weten bij het lezen van grote CSV-bestanden met PySpark. 

Zorg dat je PySpark hebt geïnstalleerd en dat je de basis beheerst met onze tutorial Aan de slag met PySpark. 

Wat is CSV lezen in PySpark?

PySpark laat je CSV-bestanden inlezen als gedistribueerde DataFrames. DataFrames in PySpark lijken sterk op Pandas DataFrames en bieden een vertrouwde interface. Onder de motorkap verdelen PySpark DataFrames echter de rekenlast en opslag over meerdere nodes, wat uitzonderlijke prestaties oplevert voor enorme datasets. 

PySpark biedt overtuigende voordelen voor grote CSV-bestanden, zoals:

• Gedistribueerd laden van data,
• Robuuste afhandeling van null-waarden,
• Flexibiliteit in het definiëren van schema’s, en
• Eenvoudige manieren om meerdere of gecomprimeerde CSV-bestanden te beheren.

Toch kom je vaak uitdagingen tegen, zoals headers efficiënt verwerken, schema’s correct afleiden of opgeven, en onjuiste of inconsistente records beheren. Lees verder om te ontdekken hoe je met al deze uitdagingen omgaat. 

CSV-bestanden lezen in PySpark is een onderwerp dat je moet beheersen om te slagen voor een PySpark-sollicitatie. Onze Top 36 PySpark-sollicitatievragen en -antwoorden voor 2025 biedt een uitgebreide gids, van basisconcepten tot geavanceerde technieken en optimalisatiestrategieën.  

Basisprincipes van CSV-bestanden lezen in PySpark

CSV-data lezen is vaak een van de eerste en meest kritieke stappen in PySpark-workflows. Het vormt de basis voor daaropvolgende transformaties, verkennende analyses en machinelearning-taken. Als je deze stap goed doet, zorgt dat voor schonere gegevensverwerking en betere prestaties verderop in de pijplijn.

Conceptueel raamwerk

PySpark leest CSV-bestanden binnen Sparks gedistribueerde model. In plaats van CSV-data volledig in het geheugen van één machine te laden, splitst Spark grote datataken over meerdere clusternodes. Sparks ingebouwde Catalyst-optimizer verbetert de prestaties verder door de onderliggende bewerkingen tijdens CSV-inname efficiënt uit te voeren.

Kernsyntaxis voor lezen

De eenvoudige manier om CSV-bestanden te lezen gebruikt de ingebouwde functies van Spark: 

spark.read.csv("file_path", header=True, inferSchema=True)Mogelijk gemaakt door

Of expliciet:

spark.read.format("csv").option("header", "True").load("file_path")Mogelijk gemaakt door

Belangrijke parameters zijn:

• file_path - locatie van CSV-bestanden.
• header - stel kolomnamen in op basis van CSV-headers als True.
• inferSchema - leidt kolomdatatypen automatisch af.
• delimiter - teken dat kolommen scheidt; standaard is een komma.

Onze tutorial Leer PySpark vanaf nul in 2025 gaat dieper in op de basisprincipes van PySpark en hoe je het leert. 

CSV-bestanden lezen: opties en configuraties

PySpark biedt uitgebreide opties die je fijnmazige controle geven over het leesproces van CSV.

Header en schema-afleiding

Met header=True geef je Spark de instructie om de eerste CSV-regel als kolomnamen te gebruiken.

inferSchema=True  laat Spark kolomtypen automatisch raden door je data te scannen:

spark.read.csv("customers.csv", header=True, inferSchema=True)Mogelijk gemaakt door

Hoewel schema-afleiding handig en in eerste instantie effectief is, lijden grote datasets onder prestatieverlies omdat Spark herhaaldelijk gegevens moet doorlopen om datatypen te bepalen.

Aangepaste schemaspecificatie 

Je schema expliciet definiëren verbetert de prestaties aanzienlijk doordat Spark geen herhaalde datascans hoeft te doen. Een gedefinieerd schema geeft kolomnamen en -typen vooraf door.

Zo definieer je een aangepast schema 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)Mogelijk gemaakt door

Laten we vervolgens bekijken hoe PySpark omgaat met delimiters bij het lezen van CSV-bestanden. 

Delimiters en speciale tekens afhandelen

Veel CSV-bestanden gebruiken andere delimiters dan komma’s, zoals pipes of tabs. In PySpark kun je de delimiter expliciet opgeven:

spark.read.csv("customers.csv", header=True, delimiter="|")Mogelijk gemaakt door

Daarnaast kun je escape- en aanhalingstekens configureren om speciale tekensituaties af te handelen:

spark.read.csv("data.csv", header=True, escape='\"', quote='"')Mogelijk gemaakt door

Null- en ontbrekende waarden beheren

CSV-data uit de praktijk bevat vaak inconsistenties of onvolledige records. PySpark maakt het eenvoudig om null-waarden af te handelen door aangepaste placeholders naar null te vertalen:

spark.read.csv("customers.csv", header=True, schema=schema, nullValue="NA")Mogelijk gemaakt door

Dit maakt null-waarden duidelijk, wat handmatig schoonmaken later sterk vermindert.

Laten we andere strategieën verkennen om met null-waarden om te gaan. 

Je kunt ervoor kiezen de null-waarden eruit te filteren: 

# Filter rows where Age is not null
df_filtered = df.filter(df["Age"].isNotNull())
df_filtered.show()Mogelijk gemaakt door

Dit filtert de DataFrame zodat alleen rijen worden opgenomen waar de kolom Age niet null is. De uitvoer ziet er zo uit:

+---+-----+---+------+
| ID| Name|Age|Salary|
+---+-----+---+------+
|  1| John| 25| 50000|
|  3|  Bob| 30|  NULL|
|  4|Carol| 28| 55000|
+---+-----+---+------+Mogelijk gemaakt door

De andere strategie is om de null-waarden op te vullen: 

# Replace null values in Age and Salary with default values
df_filled = df.na.fill({"Age": 0, "Salary": 0})
df_filled.show()Mogelijk gemaakt door

De uitvoer ziet er dan zo uit: 

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

Meerdere bestanden en mappen lezen

PySpark blinkt uit in het beheren van grote datasets met meerdere bestanden. In plaats van handmatig bestanden uit een map sequentieel te laden en te mergen, ondersteunt PySpark wildcard-patronen voor snel en efficiënt bulkladen:

spark.read.csv("/data/sales/*.csv", header=True, schema=schema)Mogelijk gemaakt door

Dit voegt effectief talloze CSV-bestanden samen in één DataFrame in één gestroomlijnde operatie.

Zodra de data in PySpark is geladen, volgen stappen als wrangling, feature engineering en het bouwen van machinelearning-modellen. Onze cursus Feature Engineering met PySpark behandelt deze concepten uitgebreid. 

Optimalisatietechnieken voor efficiënt CSV lezen

Bij het werken met grootschalige CSV-data is het cruciaal om de optimalisatiestrategieën van PySpark te benutten.

Partitioneringsstrategieën

Partitionering heeft grote invloed op de prestaties door data gelijkmatig over clusternodes te verdelen. Spark biedt expliciete controle over partitiegrootte en -aantal tijdens data-inname om daaropvolgende bewerkingen te versnellen:

df = spark.read.csv("data.csv", header=True, schema=schema).repartition(20)Mogelijk gemaakt door

​​.repartition(20) splitst de DataFrame in 20 partities over je Spark-cluster. Omdat Spark data in stukken verwerkt, kan meer partitionering het volgende opleveren:

• Betere parallelisatie
• Gebalanceerde werklast over het cluster
• Snellere transformaties en writes

Als je op een cluster met veel cores draait, helpt dit om ze volledig te benutten. Maar je kunt het vertragen als je overdrijft (zeg, 1000 partities op een kleine dataset).

Ontdek meer Spark-functies zoals repartition met onze PySpark Cheat Sheet: Spark in Python. Die gaat in op het initialiseren van Spark in Python, data laden, sorteren en repartitioneren. 

Caching en persistentie

Toegangen je na inname herhaaldelijk dezelfde dataset, dan kan het cachen van je DataFrame in geheugen of op schijf de prestaties aanzienlijk verbeteren:

df.cache()Mogelijk gemaakt door

Houd er wel rekening mee dat cachen voldoende systeembronnen vereist; weeg geheugenverbruik altijd af tegen de prestatiewinst.

Lazy evaluation en acties triggeren

PySpark gebruikt een lazy evaluation-model: DataFrame-bewerkingen transformeren plannen in plaats van direct uit te voeren. Het daadwerkelijke lezen gebeurt pas wanneer nodig, getriggerd door commando’s zoals show(), count() of collect():

# no reading yet
df = spark.read.csv("data.csv", header=True, schema=schema)   
# actual read triggered here
df.show(5)  Mogelijk gemaakt door

Geavanceerde use-cases en overwegingen

Laten we complexere scenario’s verkennen die je kunt tegenkomen bij het lezen van CSV-bestanden: 

Gecomprimeerde CSV-bestanden lezen

Spark beheert gecomprimeerde CSV-bestanden zoals gz of .bz2  efficiënt en transparant, zonder extra configuraties:

spark.read.csv("logs.csv.gz", header=True, schema=schema)Mogelijk gemaakt door

Onjuiste records afhandelen

CSV-datasets kunnen onjuiste regels bevatten. PySpark biedt meerdere opties om fouten of onjuiste records netjes te beheren:

• mode="PERMISSIVE" (standaard): bevat onjuiste rijen met kolommen gevuld met null.
• mode="DROPMALFORMED: slaat onjuiste records stilzwijgend over. Deze modus wordt niet ondersteund in de ingebouwde CSV-functies.
• mode="FAILFAST": gooit een exceptie zodra een onjuist record wordt aangetroffen.

spark.read.csv("data.csv", header=True, schema=schema, mode="FAILFAST")Mogelijk gemaakt door

Locale- en coderinginstellingen

Soms gebruiken CSV-bestanden niet-standaard coderingen. PySpark kan eenvoudig verschillende coderingen verwerken via de parameter encoding:

spark.read.csv("data_utf8.csv", header=True, encoding="UTF-8")Mogelijk gemaakt door

Ondersteunde coderingen zijn onder meer US-ASCII, ISO-8859-1, UTF-8, UTF-16BE, UTF-16LE en UTF-16. 

Best practices en veelvoorkomende valkuilen

Hier zijn enkele best practices om in gedachten te houden bij het lezen van CSV-bestanden met Spark: 

• Specificeer het schema expliciet wanneer de datasetstructuur bekend is.
• Beheer partitionering om de werklast efficiënt te verdelen.
• Cache strategisch voor DataFrames die je vaak nodig hebt.
• Trigger leesacties doelgericht, met oog voor lazy evaluation.

Zorg dat je het volgende vermijdt: 

• header=False instellen voor CSV’s met header-rijen.
• Uitsluitend vertrouwen op inferSchema bij grote of vaak benaderde datasets.
• Kritieke delimiter- of coderinginstellingen negeren.

Conclusie

Een goed begrip en gebruik van PySparks krachtige mogelijkheden voor CSV-inname is essentieel voor effectieve bigdataverwerking. Met een duidelijk schema, het afhandelen van aangepaste null-formaten, efficiënte partitionering en het beheren van gecomprimeerde of meerdere bestanden, wordt je workflow gestroomlijnd en performant.

Onthoud dat hoewel PySpark enorme voordelen biedt voor grootschalige datataken, eenvoudigere tools zoals Pandas nog steeds voldoende kunnen zijn voor kleine datasets. Gebruik PySpark wanneer je werkt met data die de mogelijkheden van één machine overstijgt, en maak altijd gebruik van de voordelen van gedistribueerd rekenen.

Wil je PySpark verder verkennen? Bekijk onze diepgaande Spark-cursussen, waaronder:

• Inleiding tot PySpark
• Grondslagen van PySpark 
• Big Data Fundamentals met PySpark
• Aanbevelingssystemen bouwen met PySpark