Python JSON verarbeiten mit dem -Modul – einfach erklärt

Du hast eine API abgefragt, eine Config-Datei geöffnet oder Daten von einem Webserver bekommen - und überall begegnet dir dasselbe Format: JSON (gesprochen „Dscheison", kurz für *JavaScript Object Notation*). Es ist das Datenformat im Web, ob bei REST-APIs, Konfigurationsdateien oder Logdaten. In diesem Artikel lernst du, wie du JSON in Python einliest, bearbeitest und wieder ausgibst - mit dem eingebauten `json`-Modul, ganz ohne externe Bibliotheken.

Voraussetzungen: Was brauchst du?

Kurz gesagt: nicht viel. Konkret brauchst du:

• Python 3.6 oder neuer - das `json`-Modul ist in der Standardbibliothek enthalten, du musst also nichts mit `pip` installieren

• Grundlagen zu Dictionaries und Listen - JSON-Daten landen in Python fast immer in diesen beiden Typen. Wenn du bei Python Dictionary noch nachholen willst, was ein Dict ist, ist jetzt ein guter Moment

• Grundlagen im Dateihandling - für die Datei-Beispiele hilft es, wenn du `open()` und das `with`-Statement kennst (Python Datei lesen schreiben)

Falls du dein Projekt sauber verwalten willst, wirf vorher einen Blick in Python pip virtualenv. Für dieses Tutorial reicht aber ein einfaches Skript.

Was ist JSON - und warum braucht Python das json-Modul?

JSON ist ein Textformat zum Austausch strukturierter Daten. Stell dir vor, du schreibst eine Einkaufsliste - aber statt Stift und Papier nutzt du ein festes Schema, das jeder Computer versteht. Die komplette Syntax beschreibt json.org. So sieht JSON aus:

{
  "name": "Mara",
  "alter": 23,
  "azubi": true,
  "kenntnisse": ["Python", "SQL", "Git"],
  "adresse": {
    "stadt": "Bonn",
    "plz": 53111
  }
}

Der Haken: Für Python ist das erstmal nur ein String. Du kannst mit einem String keine einzelnen Felder ansprechen. Das `json`-Modul übersetzt hin und her:

• Parsen (einlesen): JSON-Text wird zu Python-Objekten wie `dict` und `list`

• Serialisieren (ausgeben): Python-Objekte werden zu JSON-Text

Merke: JSON ist ein Textformat, Python arbeitet mit Objekten. Das `json`-Modul ist der Übersetzer dazwischen.

Welche JSON-Typen werden zu welchen Python-Typen?

Die offizielle Python-Dokumentation zum json-Modul listet die Zuordnung - hier die Kurzversion:

Wichtig in der anderen Richtung: Python kennt `tuple`, `set` oder `datetime` - JSON nicht. Tuple werden beim Serialisieren zu Arrays, aber Sets und Datumsobjekte werfen Fehler. Dazu später mehr.

Schritt 1: JSON-String einlesen mit json.loads()

`json.loads()` („load string") parst einen JSON-String in Python-Objekte. So gehst du vor:

import json

# JSON als String, z. B. von einer API-Antwort
antwort = '{"name": "Mara", "alter": 23, "kenntnisse": ["Python", "SQL"]}'

# String in ein Python-Dictionary umwandeln
daten = json.loads(antwort)

print(type(daten))  # <class 'dict'>
print(daten["name"])  # Mara
print(daten["kenntnisse"])  # ['Python', 'SQL']
print(daten["alter"] + 1)  # 24  -> alter ist ein int, kein String!

Nach dem Parsen arbeitest du ganz normal mit Dictionaries und Listen weiter - inklusive `.get()` für sicheren Zugriff oder verschachteltem Indexing wie `daten["adresse"]["stadt"]`.

Schritt 2: Python-Daten als JSON ausgeben mit json.dumps()

`json.dumps()` („dump string") macht das Gegenteil: Es erzeugt aus Python-Objekten einen JSON-String.

import json

person = {
    "name": "Jonas",
    "alter": 25,
    "azubi": False,
    "noten": [1.7, 2.3, 1.0],
}

json_text = json.dumps(person)
print(json_text)
# {"name": "Jonas", "alter": 25, "azubi": false, "noten": [1.7, 2.3, 1.0]}

# Lesbar formatiert mit Einrueckung
formatiert = json.dumps(person, indent=2, ensure_ascii=False)
print(formatiert)

Zwei Parameter solltest du kennen:

• `indent=2` erzeugt Einrückungen - so wird JSON für Menschen lesbar. Warum? Weil ein einzeiliger JSON-String bei größeren Datenmengen schnell unlesbar wird.

• `ensure_ascii=False` sorgt dafür, dass Umlaute wie `ü` direkt ausgegeben werden statt als `\u00fc`. Standardmäßig escaped `json.dumps()` alle Nicht-ASCII-Zeichen - technisch korrekt, aber mühsam zu lesen.

Schritt 3: JSON-Dateien lesen mit json.load()

`json.load()` (ohne „s") liest JSON direkt aus einem geöffneten Dateiobjekt - ideal für Config-Dateien, exportierte Daten oder Logs:

import json

with open("config.json", "r", encoding="utf-8") as datei:
    config = json.load(datei)

print(config.get("datenbank", "kein Eintrag"))

Das `with`-Statement schließt die Datei automatisch - auch wenn ein Fehler auftritt. Details dazu findest du im Artikel zum Python Context Manager with-Statement.

Schritt 4: In JSON-Dateien schreiben mit json.dump()

Analog schreibt `json.dump()` Python-Objekte direkt in eine Datei:

import json

messwerte = {"geraet": "Sensor-A1", "werte": [21.4, 22.1, 19.8]}

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

Merke: `loads`/`dumps` arbeiten mit Strings, `load`/`dump` mit Dateien. Das „s" steht für „string".

Vollständiges Beispiel: Ein kleines JSON-Tool

Alle Schritte zusammen in einem lauffähigen Programm - es liest eine Datei, verarbeitet die Daten und schreibt das Ergebnis zurück:

import json


def lade_azubis(pfad):
    # Laedt eine JSON-Datei und gibt die Liste zurueck
    with open(pfad, "r", encoding="utf-8") as datei:
        return json.load(datei)


def berechne_durchschnitt(azubis):
    # Berechnet das Durchschnittsalter aller Azubis
    if not azubis:
        return 0.0
    summe = sum(a["alter"] for a in azubis)
    return summe / len(azubis)


def speichere_ergebnis(pfad, ergebnis):
    with open(pfad, "w", encoding="utf-8") as datei:
        json.dump(ergebnis, datei, indent=2, ensure_ascii=False)


if __name__ == "__main__":
    azubis = lade_azubis("azubis.json")
    durchschnitt = berechne_durchschnitt(azubis)

    ergebnis = {
        "anzahl": len(azubis),
        "durchschnittsalter": round(durchschnitt, 1),
    }
    speichere_ergebnis("ergebnis.json", ergebnis)
    print("Ergebnis gespeichert:", ergebnis)

Dazu passende `azubis.json`:

[
  { "name": "Mara", "alter": 23 },
  { "name": "Jonas", "alter": 25 },
  { "name": "Lena", "alter": 19 }
]

Welche typischen Fehler gibt es - und wie löst du sie?

Drei Fehler begegnen Anfängern ständig: ungültiges JSON, nicht serialisierbare Typen und kaputte Umlaute. Hier die Lösungen.

Problem 1: json.decoder.JSONDecodeError

Der Klassiker beim Parsen. Häufigste Ursachen: einfache Anführungszeichen, ein Komma zu viel oder ein fehlendes Anführungszeichen.

# FALSCH: Single Quotes sind kein gueltiges JSON
json.loads("{'name': 'Mara'}")  # JSONDecodeError

# RICHTIG: JSON verlangt doppelte Quotes
json.loads('{"name": "Mara"}')  # funktioniert

Merke: JSON verlangt zwingend doppelte Anführungszeichen. Einfache Quotes sind in JSON invalid - auch wenn Python sie bei Strings erlaubt.

Fange den Fehler am besten mit `try`/`except` ab, wie im Artikel zum Python Exception Handling beschrieben:

import json

try:
    daten = json.loads(kaputter_text)
except json.JSONDecodeError as fehler:
    print("Ungueltiges JSON:", fehler)

Problem 2: TypeError bei nicht serialisierbaren Typen

`json.dumps()` kennt Sets, `datetime` oder eigene Klassen nicht:

import json
from datetime import date

daten = {"datum": date.today()}
json.dumps(daten)  # TypeError: Object of type date is not JSON serializable

Lösung: Wandle vorher in JSON-kompatible Typen um, z. B. mit `str(daten["datum"])` oder `.isoformat()`.

Problem 3: Encoding-Chaos bei Umlauten

Liest du eine UTF-8-Datei ohne `encoding="utf-8"`, können Umlaute als kaputte Zeichen erscheinen - unter Windows ist das Standard-Encoding nämlich nicht UTF-8. Gib daher beim `open()`-Aufruf immer explizit `encoding="utf-8"` an.

FAQ: Häufige Fragen zu Python und JSON

Was ist der Unterschied zwischen json.load() und json.loads()?

`json.load()` liest JSON aus einer geöffneten Datei, `json.loads()` parst einen String. Fürs Schreiben gilt dasselbe Muster: `json.dump()` schreibt in eine Datei, `json.dumps()` erzeugt einen String.

Wie formatiere ich JSON lesbar in Python?

Über den Parameter `indent`, z. B. `json.dumps(daten, indent=2)`. Mit `sort_keys=True` werden die Schlüssel zusätzlich alphabetisch sortiert - praktisch, wenn du Dateien per Diff vergleichen willst.

Wie lese ich JSON aus einer API in Python?

Mit dem `requests`-Modul (das musst du per `pip` installieren) und `response.json()`. Intern macht `requests` nichts anderes als `json.loads()` auf den Antworttext anzuwenden.

Kann ich eigene Klassen als JSON speichern?

Nicht direkt - `json.dumps()` kennt nur die Basistypen. Du kannst aber eine Funktion mit `default=my_funktion` übergeben oder das Objekt vorher manuell in ein Dictionary umwandeln. Für Datenklassen lohnt sich ein Blick auf Python dataclasses.

Ist JSON dasselbe wie ein Python-Dictionary?

Nein. JSON ist ein Textformat mit eigener Syntax (z. B. `false` statt `False`, `null` statt `None`), ein Dictionary ist ein Python-Objekt im Speicher. Sie sehen ähnlich aus, sind aber verschiedene Dinge.

Fazit

JSON-Verarbeitung gehört zu den Grundlagen, die dir in Ausbildung, Studium und Beruf ständig begegnen - bei APIs, Configs und Datenaustausch. Mit dem Python-`json`-Modul hast du das komplette Werkzeug im Kasten: `loads`/`dumps` für Strings, `load`/`dump` für Dateien. Denk an die drei Stolpersteine: doppelte Anführungszeichen, nicht serialisierbare Typen und `encoding="utf-8"`.

Wenn du bei Python-Nachhilfe, Prüfungsvorbereitung oder deinem ersten Berufseinstieg Unterstützung brauchst, schau bei study-it.education vorbei. Dort findest du individuelle Nachhilfe genau für dein Level - von den Basics bis zur API-Entwicklung.