Python und JSON: Vollständiger Leitfaden zur Datenverarbeitung

# Python und JSON: Vollständiger Leitfaden

Ein umfassender Leitfaden zur Arbeit mit JSON in Python.

Einführung

Python bietet hervorragende Unterstützung für JSON durch das eingebaute json-Modul. JSON-Daten lassen sich nahtlos in Python-Dictionaries und -Listen umwandeln.

Python <-> JSON Mapping

| Python | JSON |

|--------|------|

| dict | object |

| list, tuple | array |

| str | string |

| int, float | number |

| True | true |

| False | false |

| None | null |

Grundlagen

JSON-Modul importieren

import json

# Optional für schöne Ausgabe
from pprint import pprint

JSON-String zu Python-Objekt

# JSON-String parsen
json_string = '{"name": "Max", "alter": 30, "stadt": "Berlin"}'
data = json.loads(json_string)

print(type(data))  # <class 'dict'>
print(data['name'])  # Max
print(data['alter'])  # 30

Python-Objekt zu JSON-String

# Python-Dictionary zu JSON
data = {
    "name": "Max Mustermann",
    "alter": 30,
    "stadt": "Berlin",
    "aktiv": True
}

json_string = json.dumps(data)
print(json_string)
# {"name": "Max Mustermann", "alter": 30, "stadt": "Berlin", "aktiv": true}

JSON-Dateien lesen und schreiben

Datei lesen

import json

# JSON-Datei lesen
with open('daten.json', 'r', encoding='utf-8') as f:
    data = json.load(f)

print(data)

# Auf Elemente zugreifen
print(data['name'])

Datei schreiben

import json

data = {
    "benutzer": {
        "name": "Max Mustermann",
        "email": "max@example.de",
        "alter": 30
    },
    "einstellungen": {
        "theme": "dunkel",
        "sprache": "de"
    }
}

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

print("✅ Datei erfolgreich geschrieben!")

Formatierung und Pretty Print

Formatiertes JSON

import json

data = {
    "name": "Max",
    "adresse": {
        "stadt": "Berlin",
        "plz": "10115"
    }
}

# Mit Einrückung (2 Leerzeichen)
formatiert = json.dumps(data, indent=2, ensure_ascii=False)
print(formatiert)

Ausgabe:

{
  "name": "Max",
  "adresse": {
    "stadt": "Berlin",
    "plz": "10115"
  }
}

Verschiedene Einrückungen

# 4 Leerzeichen
json.dumps(data, indent=4)

# Tabs
json.dumps(data, indent='	')

# Kompakt (keine Leerzeichen)
json.dumps(data, separators=(',', ':'))

Schlüssel sortieren

data = {
    "z_wert": 1,
    "a_wert": 2,
    "m_wert": 3
}

# Alphabetisch sortiert
sortiert = json.dumps(data, indent=2, sort_keys=True)
print(sortiert)

Ausgabe:

{
  "a_wert": 2,
  "m_wert": 3,
  "z_wert": 1
}

ensure_ascii Parameter

data = {
    "name": "Max Müller",
    "stadt": "München",
    "nachricht": "Grüße aus Österreich"
}

# Mit ASCII-Escape (Standard)
ascii_json = json.dumps(data, indent=2)
print(ascii_json)
# {"name": "Max M\u00fcller", ...}

# Ohne ASCII-Escape (empfohlen für Deutsch)
utf8_json = json.dumps(data, indent=2, ensure_ascii=False)
print(utf8_json)
# {"name": "Max Müller", ...}

Komplexe Datenstrukturen

Verschachtelte Objekte

import json

data = {
    "firma": {
        "name": "TechCorp",
        "mitarbeiter": [
            {
                "id": 1,
                "name": "Max Mustermann",
                "abteilung": "Entwicklung",
                "skills": ["Python", "JavaScript", "Docker"]
            },
            {
                "id": 2,
                "name": "Anna Schmidt",
                "abteilung": "Design",
                "skills": ["Figma", "Photoshop", "Illustrator"]
            }
        ],
        "standorte": {
            "hauptsitz": {
                "stadt": "Berlin",
                "mitarbeiteranzahl": 50
            },
            "niederlassung": {
                "stadt": "München",
                "mitarbeiteranzahl": 20
            }
        }
    }
}

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

# Lesen und navigieren
with open('firma.json', 'r', encoding='utf-8') as f:
    firma_data = json.load(f)

# Zugriff auf verschachtelte Daten
print(firma_data['firma']['name'])  # TechCorp
print(firma_data['firma']['mitarbeiter'][0]['name'])  # Max Mustermann
print(firma_data['firma']['standorte']['hauptsitz']['stadt'])  # Berlin

Listen von Objekten

# JSON-Array mit Objekten
benutzer_json = '''
[
  {
    "id": 1,
    "name": "Max",
    "email": "max@example.de"
  },
  {
    "id": 2,
    "name": "Anna",
    "email": "anna@example.de"
  }
]
'''

benutzer = json.loads(benutzer_json)

# Iteration
for user in benutzer:
    print(f"{user['id']}: {user['name']} ({user['email']})")

# Filterung
aktive_benutzer = [u for u in benutzer if u.get('aktiv', True)]

# Transformation
nur_namen = [u['name'] for u in benutzer]
print(nur_namen)  # ['Max', 'Anna']

API-Requests mit JSON

Mit requests-Bibliothek

import requests
import json

# GET-Request
response = requests.get('https://api.example.com/benutzer')

# Automatisches JSON-Parsing
data = response.json()
print(data)

# POST-Request mit JSON
neuer_benutzer = {
    "name": "Max Mustermann",
    "email": "max@example.de"
}

response = requests.post(
    'https://api.example.com/benutzer',
    json=neuer_benutzer  # Automatisch zu JSON serialisiert
)

# Oder manuell
response = requests.post(
    'https://api.example.com/benutzer',
    data=json.dumps(neuer_benutzer),
    headers={'Content-Type': 'application/json'}
)

print(response.status_code)
print(response.json())

Mit urllib (Standard-Bibliothek)

import urllib.request
import json

# GET-Request
url = 'https://api.example.com/daten'
with urllib.request.urlopen(url) as response:
    data = json.loads(response.read())
    print(data)

# POST-Request
data = {"name": "Max", "alter": 30}
json_data = json.dumps(data).encode('utf-8')

req = urllib.request.Request(
    'https://api.example.com/benutzer',
    data=json_data,
    headers={'Content-Type': 'application/json'}
)

with urllib.request.urlopen(req) as response:
    result = json.loads(response.read())
    print(result)

Fehlerbehandlung

JSON-Parsing-Fehler

import json

ungueltig = '{"name": "Max", "alter": 30,}'  # Trailing comma

try:
    data = json.loads(ungueltig)
except json.JSONDecodeError as e:
    print(f"Fehler beim Parsen: {e}")
    print(f"Zeile {e.lineno}, Spalte {e.colno}")
    print(f"Position: {e.pos}")
    # Fehler beim Parsen: Expecting property name enclosed in double quotes

Validierung

def validiere_benutzer(data):
    """Validiert Benutzerdaten"""
    erforderliche_felder = ['name', 'email', 'alter']

    for feld in erforderliche_felder:
        if feld not in data:
            raise ValueError(f"Fehlendes Feld: {feld}")

    if not isinstance(data['alter'], int):
        raise TypeError("Alter muss eine Zahl sein")

    if data['alter'] < 0 or data['alter'] > 150:
        raise ValueError("Alter muss zwischen 0 und 150 liegen")

    return True

try:
    benutzer = json.loads('{"name": "Max", "email": "max@example.de", "alter": 30}')
    validiere_benutzer(benutzer)
    print("✅ Gültige Daten")
except (ValueError, TypeError) as e:
    print(f"❌ Validierungsfehler: {e}")

Custom Encoder und Decoder

Datum serialisieren

import json
from datetime import datetime, date

class DateTimeEncoder(json.JSONEncoder):
    """Custom Encoder für Datum/Zeit"""
    def default(self, obj):
        if isinstance(obj, (datetime, date)):
            return obj.isoformat()
        return super().default(obj)

data = {
    "name": "Max",
    "erstellt": datetime.now(),
    "geburtsdatum": date(1995, 3, 15)
}

# Mit Custom Encoder
json_string = json.dumps(data, cls=DateTimeEncoder, indent=2)
print(json_string)

Ausgabe:

{
  "name": "Max",
  "erstellt": "2026-01-26T12:00:00.123456",
  "geburtsdatum": "1995-03-15"
}

Custom Klassen serialisieren

import json

class Benutzer:
    def __init__(self, name, email, alter):
        self.name = name
        self.email = email
        self.alter = alter

    def to_dict(self):
        return {
            'name': self.name,
            'email': self.email,
            'alter': self.alter
        }

class BenutzerEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, Benutzer):
            return obj.to_dict()
        return super().default(obj)

benutzer = Benutzer("Max", "max@example.de", 30)
json_string = json.dumps(benutzer, cls=BenutzerEncoder, indent=2)
print(json_string)

Custom Decoder

import json
from datetime import datetime

def datetime_decoder(dct):
    """Konvertiert ISO-Strings zurück zu datetime"""
    for key, value in dct.items():
        if isinstance(value, str):
            try:
                dct[key] = datetime.fromisoformat(value)
            except (ValueError, AttributeError):
                pass
    return dct

json_string = '{"name": "Max", "erstellt": "2026-01-26T12:00:00"}'
data = json.loads(json_string, object_hook=datetime_decoder)

print(type(data['erstellt']))  # <class 'datetime.datetime'>
print(data['erstellt'])  # 2026-01-26 12:00:00

Große JSON-Dateien verarbeiten

Streaming mit ijson

import ijson

# Für sehr große Dateien
with open('grosse_datei.json', 'rb') as f:
    # Iteriere über Array-Elemente
    parser = ijson.items(f, 'benutzer.item')

    for benutzer in parser:
        print(benutzer['name'])
        # Verarbeite jeden Benutzer einzeln
        # Lädt nicht die gesamte Datei in den Speicher

Chunked Processing

import json

def verarbeite_in_chunks(dateiname, chunk_groesse=1000):
    """Verarbeitet große JSON-Arrays in Chunks"""
    with open(dateiname, 'r', encoding='utf-8') as f:
        data = json.load(f)

        # Angenommen, data ist eine Liste
        for i in range(0, len(data), chunk_groesse):
            chunk = data[i:i + chunk_groesse]
            yield chunk

# Verwendung
for chunk in verarbeite_in_chunks('grosse_liste.json'):
    print(f"Verarbeite {len(chunk)} Einträge...")
    # Verarbeite Chunk

JSON Schema Validierung

Mit jsonschema-Bibliothek

from jsonschema import validate, ValidationError
import json

# Schema definieren
schema = {
    "type": "object",
    "properties": {
        "name": {"type": "string", "minLength": 1},
        "alter": {"type": "number", "minimum": 0, "maximum": 150},
        "email": {
            "type": "string",
            "pattern": "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$"
        },
        "aktiv": {"type": "boolean"}
    },
    "required": ["name", "email"]
}

# Daten validieren
daten = {
    "name": "Max Mustermann",
    "alter": 30,
    "email": "max@example.de",
    "aktiv": True
}

try:
    validate(instance=daten, schema=schema)
    print("✅ Daten sind gültig!")
except ValidationError as e:
    print(f"❌ Validierungsfehler: {e.message}")

JSON und Pandas

JSON zu DataFrame

import pandas as pd
import json

# JSON-String zu DataFrame
json_string = '''
[
  {"name": "Max", "alter": 30, "stadt": "Berlin"},
  {"name": "Anna", "alter": 25, "stadt": "München"},
  {"name": "Tom", "alter": 35, "stadt": "Hamburg"}
]
'''

df = pd.read_json(json_string)
print(df)

# JSON-Datei zu DataFrame
df = pd.read_json('daten.json')

# Verschachtelte JSON-Daten
json_string = '''
{
  "benutzer": [
    {"id": 1, "name": "Max"},
    {"id": 2, "name": "Anna"}
  ]
}
'''

data = json.loads(json_string)
df = pd.DataFrame(data['benutzer'])

DataFrame zu JSON

import pandas as pd

df = pd.DataFrame({
    'name': ['Max', 'Anna', 'Tom'],
    'alter': [30, 25, 35],
    'stadt': ['Berlin', 'München', 'Hamburg']
})

# Zu JSON-String
json_string = df.to_json(orient='records', indent=2, force_ascii=False)
print(json_string)

# Zu JSON-Datei
df.to_json('ausgabe.json', orient='records', indent=2, force_ascii=False)

Best Practices

1. Encoding immer angeben

# ✅ Gut - Explizites UTF-8
with open('daten.json', 'r', encoding='utf-8') as f:
    data = json.load(f)

# ❌ Schlecht - Verwendet System-Standard
with open('daten.json', 'r') as f:
    data = json.load(f)

2. ensure_ascii=False für nicht-ASCII-Zeichen

# ✅ Gut - Umlaute bleiben lesbar
json.dumps(data, ensure_ascii=False)

# ❌ Schlecht - Umlaute werden escaped
json.dumps(data)  # "M\u00fcnchen" statt "München"

3. Context Manager verwenden

# ✅ Gut - Datei wird automatisch geschlossen
with open('daten.json', 'r', encoding='utf-8') as f:
    data = json.load(f)

# ❌ Schlecht - Datei muss manuell geschlossen werden
f = open('daten.json', 'r')
data = json.load(f)
f.close()

4. Fehlerbehandlung

import json

def lade_json_sicher(dateiname):
    """Sicheres Laden von JSON mit Fehlerbehandlung"""
    try:
        with open(dateiname, 'r', encoding='utf-8') as f:
            return json.load(f)
    except FileNotFoundError:
        print(f"Datei nicht gefunden: {dateiname}")
        return None
    except json.JSONDecodeError as e:
        print(f"Ungültiges JSON: {e}")
        return None
    except Exception as e:
        print(f"Fehler: {e}")
        return None

data = lade_json_sicher('daten.json')
if data:
    print("Daten erfolgreich geladen")

5. Type Hints verwenden

from typing import Dict, List, Any
import json

def parse_benutzer(json_string: str) -> Dict[str, Any]:
    """Parst JSON-String zu Dictionary"""
    return json.loads(json_string)

def benutzer_liste_laden(dateiname: str) -> List[Dict[str, Any]]:
    """Lädt Liste von Benutzern aus JSON-Datei"""
    with open(dateiname, 'r', encoding='utf-8') as f:
        return json.load(f)

Praktische Beispiele

Konfigurationsdatei verwalten

import json
from pathlib import Path

class Config:
    def __init__(self, config_datei='config.json'):
        self.config_datei = Path(config_datei)
        self.config = self.laden()

    def laden(self):
        """Lädt Konfiguration oder erstellt Standard"""
        if self.config_datei.exists():
            with open(self.config_datei, 'r', encoding='utf-8') as f:
                return json.load(f)
        else:
            return self.standard_config()

    def standard_config(self):
        """Gibt Standard-Konfiguration zurück"""
        return {
            "app": {
                "name": "MeineApp",
                "version": "1.0.0"
            },
            "datenbank": {
                "host": "localhost",
                "port": 5432
            }
        }

    def speichern(self):
        """Speichert Konfiguration"""
        with open(self.config_datei, 'w', encoding='utf-8') as f:
            json.dump(self.config, f, indent=2, ensure_ascii=False)

    def get(self, key, default=None):
        """Holt Konfigurationswert"""
        keys = key.split('.')
        value = self.config
        for k in keys:
            value = value.get(k, default)
            if value is default:
                return default
        return value

    def set(self, key, value):
        """Setzt Konfigurationswert"""
        keys = key.split('.')
        config = self.config
        for k in keys[:-1]:
            config = config.setdefault(k, {})
        config[keys[-1]] = value
        self.speichern()

# Verwendung
config = Config()
print(config.get('app.name'))  # MeineApp
config.set('app.version', '2.0.0')

Log-Daten sammeln

import json
from datetime import datetime
from pathlib import Path

class JSONLogger:
    def __init__(self, log_datei='logs.json'):
        self.log_datei = Path(log_datei)
        self.logs = self.laden_logs()

    def laden_logs(self):
        """Lädt existierende Logs"""
        if self.log_datei.exists():
            with open(self.log_datei, 'r', encoding='utf-8') as f:
                return json.load(f)
        return []

    def log(self, level, message, kwargs):

        """Fügt Log-Eintrag hinzu"""
        eintrag = {
            "zeitstempel": datetime.now().isoformat(),
            "level": level,
            "nachricht": message,
            kwargs
        }
        self.logs.append(eintrag)
        self.speichern()

    def info(self, message, kwargs):

        self.log("INFO", message, kwargs)

    def error(self, message, kwargs):

        self.log("ERROR", message, kwargs)

    def speichern(self):
        """Speichert Logs"""
        with open(self.log_datei, 'w', encoding='utf-8') as f:
            json.dump(self.logs, f, indent=2, ensure_ascii=False)

# Verwendung
logger = JSONLogger()
logger.info("Anwendung gestartet")
logger.error("Fehler beim Laden", datei="daten.json")

Zusammenfassung

Wichtigste Funktionen

import json

# Laden
json.loads(string)      # String → Python
json.load(file)         # Datei → Python

# Speichern
json.dumps(obj)         # Python → String
json.dump(obj, file)    # Python → Datei

# Parameter
indent=2                # Formatierung
ensure_ascii=False      # Umlaute behalten
sort_keys=True         # Schlüssel sortieren

Best Practices Checkliste

✅ Verwenden Sie encoding='utf-8'

✅ Verwenden Sie ensure_ascii=False für Deutsch

✅ Behandeln Sie JSONDecodeError

✅ Validieren Sie Eingabedaten

✅ Verwenden Sie Context Manager (with)

✅ Dokumentieren Sie Datenstrukturen

✅ Nutzen Sie Type Hints

Weiterführende Ressourcen

• JavaScript und JSON
• JSON-Dateien erklärt
• Arbeiten mit großen JSON-Dateien
• JSON Schema verstehen