# Python Standardbibliothek – Daten speichern & serialisieren: `json`, `pickle`, `csv`

Um Daten in Dateien zu sichern oder über das Netzwerk zu übertragen, ist **Serialisierung** nötig. Python bietet dafür drei sehr unterschiedliche Standardwerkzeuge: **`json`**, **`pickle`**, **`csv`**.

![Datenlieferungsformate](/media/editor_temp/6/82b2d285-16b0-473a-b88a-cd9a6f6582f2.png)

* **`json`**: menschenlesbares Textformat, stark in der sprachübergreifenden Kommunikation
* **`pickle`**: binäres Format, das Python‑Objekte exakt speichert – mächtig, aber mit Risiken verbunden
* **`csv`**: einfaches Textformat für tabellarische Daten, sehr vielseitig

In diesem Beitrag zeigen wir, wie man je nach Anwendungsfall das passende Modul auswählt.

---

## 1. JSON {#sec-c0452ee3f8b9}

### 1.1 Überblick {#sec-573894aef250}

JSON (JavaScript Object Notation) ist **textbasiert** und **sprachunabhängig**. Es wird häufig für Konfigurationsdateien, API‑Antworten/Anfragen und Log‑Dateien verwendet. In Python greift man einfach auf das `json`‑Modul zu.

### 1.2 Kern‑APIs (nur die wichtigsten) {#sec-7388e1478aff}

* `json.dump(obj, fp, ...)` / `json.load(fp, ...)` : Datei‑Speichern/Laden
* `json.dumps(obj, ...)` / `json.loads(s, ...)` : String‑Umwandlung/Restaurierung

Wichtige Optionen:

* `ensure_ascii=False` – Nicht‑ASCII‑Zeichen (z. B. CJK) werden nicht escaped, sondern im Original ausgegeben
* `indent=2` – Lesbare, eingerückte Ausgabe
* `default=...` – Callback für unbekannte Typen

### 1.3 Beispiel (Grundlage) {#sec-57d0c0653337}

```python
import json

data = {
    "name": "Alice",
    "age": 30,
    "skills": ["Python", "Data Science"]
}

with open("data.json", "w", encoding="utf-8") as f:
    json.dump(data, f, ensure_ascii=False, indent=2)

with open("data.json", "r", encoding="utf-8") as f:
    loaded = json.load(f)

print(loaded)
```

### 1.4 Umgang mit JSON‑Typbeschränkungen {#sec-a43d0fe8a199}

JSON unterstützt nativ nur `dict`, `list`, `str`, `int/float`, `bool` und `None`. Typen wie `datetime` müssen über `default` konvertiert werden.

```python
import json
from datetime import datetime, timezone

payload = {"created_at": datetime.now(timezone.utc)}

def to_jsonable(obj):
    if isinstance(obj, datetime):
        return obj.isoformat()
    raise TypeError(f"Not JSON serializable: {type(obj)!r}")

s = json.dumps(payload, default=to_jsonable, ensure_ascii=False)
print(s)
```

### 1.5 Vor- und Nachteile {#sec-667d6fad184b}

**Vorteile**

* Sprachunabhängig – ideal für Austausch
* Textbasiert, leicht debugbar, Git‑freundlich
* Keine Codeausführung beim Laden

**Nachteile**

* Eingeschränkte Typunterstützung (z. B. `datetime`, `set`, `Decimal`, Binärdaten)
* Bei großen Daten kann Speicher/Performance leiden

---

## 2. Pickle {#sec-7417b1955ccc}

### 2.1 Überblick {#sec-1889607ea8cb}

`pickle` serialisiert Python‑Objekte **exakt**. Das Ergebnis ist ein binäres Format (bytes). Beim Laden entsteht fast identisches Objekt.

Pickle ist besonders nützlich, wenn:

* Komplexe Python‑Objekte (z. B. benutzerdefinierte Klassen, verschachtelte Strukturen, trainierte Modelle) gespeichert werden sollen
* Kein Austausch mit anderen Sprachen nötig ist

Vermeiden sollte man Pickle bei:

* Daten aus unsicheren Quellen – `pickle.load()` kann beliebigen Code ausführen
* Interoperabilität mit anderen Systemen

---

### 2.2 Kern‑APIs (die vier wichtigsten) {#sec-a0a97fe87a25}

* `pickle.dump(obj, file, protocol=...)` – Objekt → Datei (binär)
* `pickle.load(file)` – Datei → Objekt
* `pickle.dumps(obj, protocol=...)` – Objekt → bytes
* `pickle.loads(data)` – bytes → Objekt

```python
import pickle

data = {"a": [1, 2, 3], "b": ("x", "y")}

with open("data.pkl", "wb") as f:
    pickle.dump(data, f)

with open("data.pkl", "rb") as f:
    loaded = pickle.load(f)

print(loaded)
```

---

### 2.3 Was ist `protocol` und warum wichtig? {#sec-1f8e5565848c}

`protocol` bestimmt die **Version** des Pickle‑Formats. Unterschiedliche Versionen beeinflussen Dateigröße, Geschwindigkeit und unterstützte Features.

* Ohne Angabe nutzt Python die aktuelle, optimale Version.
* Manchmal muss man eine ältere Version für Kompatibilität erzwingen.
* Für Performance‑Optimierung empfiehlt sich `pickle.HIGHEST_PROTOCOL`.

```python
import pickle

with open("data.pkl", "wb") as f:
    pickle.dump({"x": 1}, f, protocol=pickle.HIGHEST_PROTOCOL)
```

---

### 2.4 Wichtige Vorsicht bei Pickle {#sec-007b70a5e9ec}

`pickle.load()` führt den **Wiederherstellungs‑Code** im Pickle‑Objekt aus. Unsichere Pickles können schädlichen Code ausführen.

* **Sicherer Ansatz**: Öffnen Sie keine Pickle aus unbekannten Quellen.
* Für Austausch‑Zwecke wählen Sie lieber ein textbasiertes Format wie `json`.

---

### 2.5 Vor- und Nachteile {#sec-bbd5a24bec31}

**Vorteile**

* Speichert praktisch jedes Python‑Objekt
* Oft schneller und kompakter als `json`

**Nachteile**

* Sicherheitsrisiko bei unsicheren Daten
* Python‑spezifisch – keine Interoperabilität
* Änderungen an Klassen können alte Pickles unbrauchbar machen

---

## 3. CSV {#sec-99e590b24e50}

### 3.1 Überblick {#sec-1265cc44a461}

CSV (Comma‑Separated Values) ist das einfachste Format für tabellarische Daten. Es wird häufig in Tabellenkalkulationen, Datenexporten und einfachen Log‑Dump‑Szenarien verwendet.

### 3.2 Kern‑APIs (nur die wichtigsten) {#sec-5b2e4c37cce5}

* `csv.reader`, `csv.writer` – Listen‑basiert
* `csv.DictReader`, `csv.DictWriter` – Wörterbuch‑basiert (häufig bevorzugt)

### 3.3 Beispiel (DictWriter/DictReader) {#sec-524921270351}

```python
import csv

data = [
    {"name": "Alice", "age": 30, "city": "Seoul"},
    {"name": "Bob",   "age": 25, "city": "Busan"},
]

with open("people.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=["name", "age", "city"])
    writer.writeheader()
    writer.writerows(data)

with open("people.csv", "r", encoding="utf-8") as f:
    reader = csv.DictReader(f)
    loaded = list(reader)

print(loaded)
```

### 3.4 Wichtige Punkte bei CSV {#sec-3db1b7ed8444}

1. **`newline=""`** – besonders unter Windows verhindert doppelte Zeilenumbrüche.
2. **Alle Werte sind Strings** – bei Bedarf manuell konvertieren.
3. **Trennzeichen, Anführungszeichen, Zeilenumbrüche** können in Daten vorkommen – das `csv`‑Modul handhabt das zuverlässig.

### 3.5 Vor- und Nachteile {#sec-6a8ca4891a8e}

**Vorteile**

* Sehr leichtgewichtig und weit verbreitet
* Für tabellarische Daten ideal

**Nachteile**

* Keine Unterstützung für verschachtelte Strukturen
* Typinformationen fehlen – Konvertierung nötig

---

## 4. Vergleich & Auswahl‑Guide {#sec-6304ec188cc0}

| Merkmal | JSON | Pickle | CSV |
|---------|------|--------|-----|
| Sprach‑Kompatibilität | sehr gut | Python‑spezifisch | sehr gut |
| Lesbarkeit | hoch | niedrig (binär) | hoch |
| Typ‑Ausdruck | begrenzt | sehr hoch | begrenzt |
| Sicherheit | relativ sicher | **Achtung** | relativ sicher |
| Datenform | Baum (verschachtelt) | „Python‑Objekt exakt“ | Tabelle (Zeilen/Spalten) |

Kurz gesagt:

* **Austausch mit anderen Systemen** → `json`
* **Python‑Objekte komplett speichern** → `pickle` (nur vertrauenswürdige Quellen)
* **Tabellarische Daten exportieren** → `csv`

---

## 5. Dasselbe Datenobjekt in drei Formaten speichern & laden {#sec-21f8c2a6d6c9}

```python
import json, pickle, csv

data = [
    {"id": 1, "name": "Alice", "score": 95.5},
    {"id": 2, "name": "Bob",   "score": 88.0},
]

# 1) JSON
with open("data.json", "w", encoding="utf-8") as f:
    json.dump(data, f, ensure_ascii=False, indent=2)

with open("data.json", "r", encoding="utf-8") as f:
    json_loaded = json.load(f)

# 2) Pickle
with open("data.pkl", "wb") as f:
    pickle.dump(data, f)

with open("data.pkl", "rb") as f:
    pickle_loaded = pickle.load(f)

# 3) CSV
with open("data.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=["id", "name", "score"])
    writer.writeheader()
    writer.writerows(data)

with open("data.csv", "r", encoding="utf-8") as f:
    reader = csv.DictReader(f)
    csv_loaded = [
        {"id": int(row["id"]), "name": row["name"], "score": float(row["score"])}
        for row in reader
    ]

print(json_loaded)
print(pickle_loaded)
print(csv_loaded)
```

**Hinweis**

* CSV erfordert sofortige Typ‑Konvertierung.
* Pickle ist bequem, aber die Quelle muss vertrauenswürdig sein.

---

## 6. Fazit {#sec-f88db3766ed6}

Mit der Python‑Standardbibliothek lässt sich Daten‑Speicherung und Serialisierung in großem Umfang abdecken.

* **Daten für andere Sprachen** → `json`
* **Python‑Objekte exakt sichern** → `pickle`
* **Tabellarische Daten exportieren** → `csv`

Wählen Sie das Format, das am besten zu Ihrer Datenstruktur und Ihrem Ziel passt – so bleibt die Entscheidung schnell und sauber.