JSONL in Python: lezen, schrijven en parseren
Een complete gids voor het werken met JSONL-bestanden (JSON Lines) in Python. Leer JSONL-data lezen, schrijven, parseren en streamen met ingebouwde modules, pandas en snelle libraries.
Waarom Python voor JSONL?
Python is de populairste taal voor het werken met JSONL-bestanden, en dat is niet voor niets. Met de ingebouwde json-module kun je direct JSON parseren. Bestanden regel voor regel doorlopen is standaard geheugenefficiënt, en het ecosysteem biedt krachtige libraries zoals pandas en orjson voor specifieke workflows. Of je nu datasets voor machine learning, applicatielogs of API-responses verwerkt: Python maakt het werken met JSONL eenvoudig.
JSONL (JSON Lines) bevat één JSON-object per regel. Dat maakt het formaat ideaal voor streaming, logging waarbij je alleen records toevoegt en het verwerken van grote datasets zonder alles in het geheugen te laden. De manier waarop Python bestanden regel voor regel leest, sluit hier perfect op aan. In deze gids leer je drie manieren om JSONL te lezen, twee manieren om het te schrijven en hoe je bestanden verwerkt die niet in het geheugen passen.
JSONL-bestanden lezen in Python
Je kunt JSONL-bestanden op verschillende manieren lezen in Python. Welke aanpak het beste past, hangt af van je toepassing. De standaard json-module volstaat meestal, pandas is handig voor het analyseren van tabeldata en generators zijn de beste keuze voor grote bestanden.
De eenvoudigste aanpak is met de ingebouwde json-module van Python. Open het bestand, doorloop het regel voor regel en parseer elke regel met json.loads(). Zo laad je alle records in een lijst in het geheugen.
import json
records = []
with open('data.jsonl', 'r', encoding='utf-8') as f:
for line in f:
line = line.strip()
if line: # Skip empty lines
records.append(json.loads(line))
print(f'Loaded {len(records)} records')
print(records[0])Als je JSONL-data een tabelstructuur heeft (dezelfde keys in elk record), kan pandas deze met één functieaanroep direct in een DataFrame inlezen. Zo kun je het snelst beginnen met het analyseren van gestructureerde JSONL-data.
import pandas as pd
# Read entire file into a DataFrame
df = pd.read_json('data.jsonl', lines=True)
print(df.head())
print(f'Shape: {df.shape}')
# For large files, read in chunks
chunks = pd.read_json('large.jsonl', lines=True, chunksize=10000)
for chunk in chunks:
# Process each chunk (DataFrame)
print(f'Chunk shape: {chunk.shape}')Gebruik een generatorfunctie voor bestanden die niet in het geheugen passen. Die levert steeds één record aan, zodat het geheugengebruik constant blijft, ongeacht de bestandsgrootte. Dit is de aanbevolen aanpak voor datapipelines in productie.
import json
from typing import Iterator, Any
def read_jsonl(path: str) -> Iterator[dict[str, Any]]:
"""Read a JSONL file lazily, yielding one record at a time."""
with open(path, 'r', encoding='utf-8') as f:
for line_num, line in enumerate(f, 1):
line = line.strip()
if not line:
continue
try:
yield json.loads(line)
except json.JSONDecodeError as e:
print(f'Skipping invalid JSON at line {line_num}: {e}')
# Process records one at a time
for record in read_jsonl('large_data.jsonl'):
process(record) # Only one record in memory at a timeJSONL-bestanden schrijven in Python
JSONL-bestanden schrijven is eenvoudig: serialiseer elk record naar een JSON-string en voeg een newline-teken toe. De hoofdregel is één JSON-object per regel, zonder komma's aan het einde of een array om de objecten heen.
Gebruik json.dumps() om elk record te serialiseren en schrijf het weg met een newline erachter. Stel ensure_ascii=False in om Unicode-tekens, zoals Chinese en Japanse tekens of emoji, in de uitvoer te behouden.
import json
records = [
{"id": 1, "name": "Alice", "age": 30},
{"id": 2, "name": "Bob", "age": 25},
{"id": 3, "name": "Charlie", "age": 35},
]
with open('output.jsonl', 'w', encoding='utf-8') as f:
for record in records:
f.write(json.dumps(record, ensure_ascii=False) + '\n')
print(f'Wrote {len(records)} records to output.jsonl')Staan je data al in een pandas DataFrame? Gebruik dan to_json() met orient='records' en lines=True om ze direct als JSONL te exporteren. Dit is het omgekeerde van pd.read_json() met lines=True.
import pandas as pd
df = pd.DataFrame([
{"id": 1, "name": "Alice", "age": 30},
{"id": 2, "name": "Bob", "age": 25},
{"id": 3, "name": "Charlie", "age": 35},
])
# Write DataFrame to JSONL
df.to_json('output.jsonl', orient='records', lines=True, force_ascii=False)
print(f'Wrote {len(df)} records to output.jsonl')Python-libraries voor JSONL
Python heeft verschillende libraries voor het parseren van JSON, elk met hun eigen prestatiekenmerken. Welke je kiest, hangt af van de grootte van je bestanden en je eisen aan de prestaties.
json (standaardbibliotheek)
IngebouwdDe ingebouwde json-module van Python hoef je niet te installeren en werkt overal. De module volstaat voor de meeste JSONL-taken en ondersteunt alle standaard JSON-typen. Voor bestanden tot enkele honderden MB zijn de prestaties toereikend.
orjson
Snelsteorjson is de snelste JSON-library voor Python en is geschreven in Rust. Parseren en serialiseren gaat 2-10x sneller dan met de standaard json-module. De library geeft bytes terug in plaats van strings en biedt ingebouwde ondersteuning voor dataclasses, datetime, numpy en UUID-typen.
ujson
Snelujson (UltraJSON) is een JSON-library geschreven in C die 2-5x sneller is dan de standaard json-module. De API is vrijwel identiek aan die van de ingebouwde json-module, waardoor je deze direct door ujson kunt vervangen. Een goede middenweg tussen compatibiliteit en snelheid.
Grote JSONL-bestanden streamen
Voor JSONL-bestanden van meerdere gigabytes heb je een aanpak nodig waarbij je data streamt en in batches leest, bewerkt en wegschrijft. Zo blijft het geheugengebruik constant en kun je de voortgang volgen.
import json
import sys
def process_large_jsonl(
input_path: str,
output_path: str,
batch_size: int = 1000
) -> int:
"""Stream-process a large JSONL file in batches."""
processed = 0
batch: list[dict] = []
with open(input_path, 'r') as fin, \
open(output_path, 'w') as fout:
for line in fin:
line = line.strip()
if not line:
continue
record = json.loads(line)
# Transform the record
record['processed'] = True
batch.append(record)
if len(batch) >= batch_size:
for r in batch:
fout.write(json.dumps(r) + '\n')
processed += len(batch)
batch.clear()
print(f'\rProcessed {processed} records...', end='')
# Write remaining records
for r in batch:
fout.write(json.dumps(r) + '\n')
processed += len(batch)
print(f'\nDone. Processed {processed} records total.')
return processed
# Usage
process_large_jsonl('input.jsonl', 'output.jsonl', batch_size=5000)Met deze aanpak blijft het geheugengebruik constant doordat je records in batches van een vaste grootte verwerkt. Met de parameter batch_size bepaal je de balans tussen geheugengebruik en I/O-efficiëntie. Op de meeste systemen werken batches van 1.000 tot 10.000 records goed. Met de voortgangsindicator houd je langlopende taken in de gaten.
Probeer onze gratis JSONL-tools
Wil je geen code schrijven? Gebruik onze gratis online tools om JSONL-bestanden direct in je browser te bekijken, te valideren en te converteren.
Strategieën om gigabytes aan JSONL-data te verwerken. Met aandacht voor lezen via streaming, geheugenbeheer, het splitsen van bestanden, compressie en online tools.
Valideer JSONL-bestanden regel voor regel. Spoor syntaxfouten, tekencoderingsproblemen en fouten in het formaat direct op.
Leer de best practices voor JSONL toepassen: opmaak, consistente schema’s, foutafhandeling, prestatieoptimalisatie en het organiseren van bestanden. Vermijd veelvoorkomende valkuilen aan de hand van praktische voorbeelden.
Zet JSONL-bestanden om naar een standaard JSON-array. Ideaal voor API’s en dataverwerkingspipelines.
Leer hoe je het JSONL-formaat gebruikt in JavaScript en Node.js.