7. Fehlerbehandlung, Dateien und Datenformate¶

Fehler gehören zu jeder Software. Netzwerkverbindungen brechen ab, Dateien fehlen, Benutzereingaben enthalten ungültige Werte oder externe Systeme liefern unerwartete Ergebnisse. Professionelle Anwendungen müssen mit solchen Situationen kontrolliert umgehen können.

Python bietet mit Exceptions ein leistungsfähiges System zur Fehlerbehandlung. Gleichzeitig stellt die Standardbibliothek umfangreiche Werkzeuge für Logging, Dateiverarbeitung und den Austausch strukturierter Daten bereit.

Besonders Formate wie CSV, JSON und YAML spielen im Alltag vieler Entwickler eine zentrale Rolle. Sie werden für Konfigurationen, Datenaustausch, APIs und Automatisierungsaufgaben verwendet.

In diesem Kapitel lernen Sie, wie robuste Python-Anwendungen entwickelt werden, wie Fehler sinnvoll behandelt werden und wie strukturierte Daten effizient verarbeitet werden können.

Exceptions verstehen¶

Das Exception-System von Python: Ein Überblick¶

Python verfolgt im Exception-Handling eine klare, aber flexible Philosophie, die sich bewusst von der statisch typisierten Welt von Java oder C# unterscheidet. Anders als dort gibt es in Python keine Checked Exceptions – das heißt, Methoden müssen nicht explizit deklarieren, welche Exceptions sie werfen können. Dies fördert eine schlankere API und einen pragmatischen Umgang mit Fehlern.

Das Exception-System basiert auf einer Hierarchie von Klassen, die alle von der Basisklasse BaseException erben. Die meisten Fehler, mit denen man in Anwendungen umgeht, sind Unterklassen von Exception. Diese Trennung erlaubt es, kritische System-Exceptions wie SystemExit oder KeyboardInterrupt separat zu behandeln oder durchzulassen.

try:
    # Beispiel: Zugriff auf eine Datei
    with open("config.yaml") as file:
        data = file.read()
except FileNotFoundError as e:
    print(f"Datei nicht gefunden: {e}")
except IOError as e:
    print(f"E/A-Fehler: {e}")

Warum Python auf dynamische Exceptions setzt¶

Die Entscheidung gegen Checked Exceptions basiert auf der Überzeugung, dass Fehlerbehandlung kontextabhängig ist und nicht durch die Methodensignatur erzwungen werden sollte. Python-Entwickler bevorzugen oft eine robuste Fehlerbehandlung an der Stelle, wo sie sinnvoll ist, statt sie durch das gesamte Call-Stack zu propagieren.

Das bedeutet auch, dass Fehler in Python häufig erst zur Laufzeit auftreten und behandelt werden – was dynamische Typisierung und Duck Typing unterstützt. Im Gegensatz zu Java oder C# ist das Exception-Handling in Python also weniger strikt, dafür unter Umständen flexibler.

Exception-Objekte und ihre Attribute¶

Exceptions in Python sind Klasseninstanzen, die neben der Fehlermeldung oft weitere kontextspezifische Informationen enthalten. Die Standardattribute sind args, die die übergebenen Argumente enthalten, und oft spezifische Attribute je nach Exception-Typ.

try:
    1 / 0
except ZeroDivisionError as e:
    print(f"Fehler: {e}, args: {e.args}")

Diese Flexibilität erlaubt es, eigene Exception-Klassen mit zusätzlichen Attributen zu definieren, um Fehlerinformationen präzise zu transportieren.

Kontrollfluss bei Exceptions¶

Wird eine Exception ausgelöst (raise), sucht Python im aktuellen Block nach einem passenden except-Handler. Wird keiner gefunden, wandert die Suche die Aufrufkette hinauf. Findet sich kein Handler, terminiert das Programm mit einem Traceback.

Mermaid-Diagramm zur Veranschaulichung des Kontrollflusses:

flowchart TD
    A[Ausführung von try-Block] -->|keine Exception| B[Fortsetzung nach try-except]
    A -->|Exception ausgelöst| C{Passender except-Handler?}
    C -->|Ja| D[except-Block ausführen]
    D --> E[Fortsetzung nach try-except]
    C -->|Nein| F[Suche Handler in Aufrufstack]
    F -->|Handler gefunden| D
    F -->|Kein Handler| G[Programmabbruch mit Traceback]

Python-Idiome im Umgang mit Exceptions¶

EAFP (Easier to Ask for Forgiveness than Permission): Statt vorher zu prüfen, ob eine Operation sicher ist, versucht Python die Operation und fängt Fehler ab, falls sie auftreten.

try:
    value = my_dict[key]
except KeyError:
    value = default_value

Verwendung spezifischer Exceptions: Statt eine breite except Exception-Klausel zu verwenden, empfiehlt sich die gezielte Behandlung erwarteter Fehler, um unerwartete Fehler nicht zu verschleiern.
Keine leeren except-Blöcke: Anders als in manchen Legacy-Codes ist es in Python eine schlechte Praxis, Exceptions einfach zu schlucken. Stattdessen sollte man zumindest protokollieren oder gezielt behandeln.

Merksatz¶

Python setzt auf ein flexibles, dynamisches Exception-System, das pragmatische Fehlerbehandlung fördert und sich bewusst von statisch typisierten Checked Exceptions unterscheidet.

Dieser Abschnitt legt die Grundlage, um die späteren Konzepte wie try-except-else-finally, eigene Exceptions und Logging besser zu verstehen. Das Verständnis der Kontrollflussmechanismen und der Designentscheidungen hinter Pythons Exception-System ist essenziell für idiomatische und robuste Python-Programme.

try, except, else und finally¶

Den Ablauf der Fehlerbehandlung verstehen und typische Muster anwenden.

Grundlagen des try-except-else-finally Blocks¶

In Python ist die Fehlerbehandlung mit try, except, else und finally ein zentrales Idiom, das sich deutlich von den Konzepten in Java oder C# unterscheidet. Während dort oft strikt zwischen try-catch-finally unterschieden wird, bietet Python mit else eine elegante Möglichkeit, den Erfolgspfad explizit zu kennzeichnen.

Der Ablauf ist:

try: Code, der potenziell eine Exception auslösen kann.
except: Fängt definierte Exception-Typen ab und behandelt sie.
else: Wird nur ausgeführt, wenn kein Fehler auftrat.
finally: Läuft immer, unabhängig von Fehlern, für Aufräumarbeiten.

Diese Struktur fördert klaren, lesbaren Code und trennt Fehlerbehandlung vom normalen Ablauf.

Beispiel: API-Datenverarbeitung mit Fehlerbehandlung¶

from typing import Any
import requests

try:
    response = requests.get('https://api.example.com/data', timeout=5)
    response.raise_for_status()  # HTTPError bei Statuscode >= 400
except requests.exceptions.Timeout as e:
    print(f"Timeout beim Abruf der Daten: {e}")
except requests.exceptions.HTTPError as e:
    print(f"HTTP Fehler: {e}")
except requests.exceptions.RequestException as e:
    # Generische Fehlerbehandlung für requests
    print(f"Fehler bei der Anfrage: {e}")
else:
    data: Any = response.json()  # Nur wenn kein Fehler auftrat
    print(f"Daten erfolgreich geladen: {data}")
finally:
    print("Anfrage abgeschlossen.")

Warum `else`?¶

In anderen Sprachen fehlt oft ein Äquivalent zu else im Fehlerbehandlungsblock. In Python trennt else den normalen Ablauf vom Fehlerfall explizit. Das verbessert die Lesbarkeit und vermeidet, dass der Erfolgscode versehentlich im try-Block steht, wo er durch Exceptions gestört werden könnte.

Mehrere except-Blöcke und Exception-Filter¶

Python erlaubt mehrere except-Klauseln, um unterschiedliche Fehler gezielt zu behandeln. Anders als in C++ oder Java, wo man oft catch-Blöcke mit Typ-Hierarchie nutzt, ist in Python die Reihenfolge der except-Blöcke entscheidend, da der erste passende Block ausgeführt wird.

try:
    process_data()
except ValueError:
    print("Ungültige Daten")
except (TypeError, KeyError) as e:
    print(f"Typ- oder Schlüssel-Fehler: {e}")
except Exception as e:
    print(f"Allgemeiner Fehler: {e}")

finally: Garantierte Ausführung¶

Der finally-Block wird immer ausgeführt, egal ob eine Exception auftrat oder nicht. Das ist vergleichbar mit finally in Java/C#, aber in Python ist es üblich, Ressourcenmanagement eher mit Kontextmanagern (with) zu lösen. Dennoch ist finally nützlich für Fälle, in denen Kontextmanager nicht passen.

file = open('config.yaml')
try:
    data = file.read()
finally:
    file.close()  # Sicherstellen, dass Datei immer geschlossen wird

Ablaufdiagramm der Fehlerbehandlung¶

flowchart TD
    A[try-Block starten]
    B{Exception aufgetreten?}
    C[except-Block ausführen]
    D[else-Block ausführen]
    E[finally-Block ausführen]
    F[weiter im Programm]

    A --> B
    B -- Ja --> C --> E --> F
    B -- Nein --> D --> E --> F

Best Practices¶

Vermeide zu breite except-Klauseln wie except Exception: ohne spezifische Behandlung — das kann Fehler verschleiern.
Nutze else für Code, der nur bei Erfolg ausgeführt werden soll, um Fehlerfälle sauber zu trennen.
Verwende finally nur, wenn kein Kontextmanager passt, z.B. bei komplexen Cleanup-Operationen.
Bevorzuge Kontextmanager (with) für Ressourcenmanagement, da sie klarer und idiomatischer sind.

Vergleich zu Java und C¶

In Java/C# ist der try-catch-finally-Block ähnlich, aber es gibt kein else. Python trennt den Fehlerfall explizit mit else, was den normalen Ablauf klarer macht. Zudem ist die Verwendung von Kontextmanagern in Python eine elegante Alternative zu finally für Ressourcen.

Merksatz¶

In Python trennt else den fehlerfreien Ablauf vom Fehlerfall, finally garantiert Aufräumarbeiten – zusammen ermöglichen sie eine klare und idiomatische Fehlerbehandlung.

Die Exception-Hierarchie¶

Die wichtigsten Exception-Typen kennenlernen und sinnvoll nutzen.

Die Exception-Hierarchie in Python¶

Python verwendet eine klar strukturierte Exception-Hierarchie, die auf der Basisklasse BaseException aufbaut. Im Gegensatz zu Java oder C#, wo Checked und Unchecked Exceptions unterschieden werden, kennt Python nur eine Hierarchie, die flexibel und dynamisch genutzt wird.

Die meisten Fehler, die Sie in der Praxis behandeln, erben von Exception, während BaseException auch systemkritische Ausnahmen wie KeyboardInterrupt und SystemExit umfasst, die in der Regel nicht abgefangen werden sollten.

classDiagram
    class BaseException {
        <<abstract>>
    }
    class Exception {
    }
    class SystemExit {
    }
    class KeyboardInterrupt {
    }
    class GeneratorExit {
    }
    BaseException <|-- Exception
    BaseException <|-- SystemExit
    BaseException <|-- KeyboardInterrupt
    BaseException <|-- GeneratorExit

    class ArithmeticError {
    }
    class LookupError {
    }
    Exception <|-- ArithmeticError
    Exception <|-- LookupError

    class ZeroDivisionError {
    }
    class OverflowError {
    }
    ArithmeticError <|-- ZeroDivisionError
    ArithmeticError <|-- OverflowError

    class IndexError {
    }
    class KeyError {
    }
    LookupError <|-- IndexError
    LookupError <|-- KeyError

    class ValueError {
    }
    Exception <|-- ValueError

    class FileNotFoundError {
    }
    Exception <|-- FileNotFoundError

    class ImportError {
    }
    Exception <|-- ImportError

    class RuntimeError {
    }
    Exception <|-- RuntimeError

    class StopIteration {
    }
    Exception <|-- StopIteration

Wesentliche Exception-Typen und ihre Bedeutung¶

BaseException: Oberste Basisklasse, von der alle Exceptions erben. Normalerweise nicht direkt abgefangen.
Exception: Die Basis für alle anwendungsbezogenen Fehler.
ArithmeticError: Für mathematische Fehler, z.B. ZeroDivisionError oder OverflowError.
LookupError: Fehler bei Suchoperationen, z.B. IndexError (Listen) oder KeyError (Dictionaries).
ValueError: Fehlerhafte Werte, die zwar vom Typ her passen, aber inhaltlich ungültig sind.
FileNotFoundError: Spezifisch für fehlende Dateien, ersetzt in Python 3 IOError.
ImportError: Fehler beim Importieren von Modulen.
RuntimeError: Allgemeiner Laufzeitfehler, der nicht spezifischer passt.
StopIteration: Signalisiert das Ende eines Iterators, wird intern von for-Schleifen behandelt.

Unterschiede zu Java und C¶

In Java und C# ist die Exception-Hierarchie stärker typisiert mit Checked Exceptions (Java) oder Unchecked Exceptions (C#). Python verzichtet bewusst auf Checked Exceptions, um den Codefluss nicht mit Ausnahme-Deklarationen zu überfrachten. Stattdessen setzt Python auf "Easier to ask for forgiveness than permission" (EAFP), was bedeutet, dass man Fehler erst behandelt, wenn sie auftreten.

Best Practice: Spezifische Exceptions abfangen¶

Fangen Sie möglichst spezifische Exception-Typen ab, um unerwartete Fehler nicht zu verschleiern. Ein zu allgemeines except Exception kann Debugging erschweren und unerwartete Fehler verdecken.

try:
    result = 10 / divisor
except ZeroDivisionError as e:
    # Nur Division durch Null abfangen
    print(f"Fehler: Division durch Null ist nicht erlaubt: {e}")
except Exception as e:
    # Andere unerwartete Fehler
    print(f"Unbekannter Fehler: {e}")

Eigene Exceptions sinnvoll einordnen¶

Eigene Exceptions sollten von Exception oder einer passenden Unterklasse erben, um sich nahtlos in die Hierarchie einzufügen. Vermeiden Sie es, direkt von BaseException zu erben, da dies z.B. das Abfangen von KeyboardInterrupt erschwert.

Merksatz¶

Python nutzt eine klare, aber flexible Exception-Hierarchie ohne Checked Exceptions. Das ermöglicht dynamische Fehlerbehandlung und fördert idiomatischen Code, der Fehler dort behandelt, wo sie auftreten.

Zusammenfassung¶

BaseException ist die Wurzel, Exception die Basis für anwendungsbezogene Fehler.
Systemausnahmen wie KeyboardInterrupt sollten selten abgefangen werden.
Spezifische Exceptions abzufangen ist idiomatisch und verbessert Wartbarkeit.
Python verzichtet auf Checked Exceptions zugunsten von EAFP.
Eigene Exceptions sollten sinnvoll in die Hierarchie integriert werden.

Diese Struktur erleichtert es, Fehler gezielt und transparent zu behandeln, ohne den Code mit unnötigen Deklarationen zu überfrachten.

Exceptions mit raise auslösen¶

Eigene Fehler erzeugen und aussagekräftige Fehlermeldungen bereitstellen.

Exceptions mit `raise` auslösen¶

In Python ist das explizite Auslösen von Exceptions mit dem Schlüsselwort raise ein zentrales Mittel, um Fehlerzustände kontrolliert zu signalisieren. Im Gegensatz zu Sprachen wie Java oder C#, wo das Werfen von Exceptions häufig mit umfangreichen Deklarationen und Checked Exceptions verbunden ist, folgt Python einer dynamischen Fehlerbehandlung, die auf Vertrauen („Easier to ask for forgiveness than permission“) basiert.

Grundlagen von `raise`¶

Mit raise wird eine Exception-Instanz ausgelöst, die den aktuellen Kontrollfluss unterbricht und eine Fehlerbehandlung einleitet. Dabei kann entweder eine neue Exception erzeugt oder eine bereits gefangene weitergereicht werden:

raise ValueError("Ungültiger Wert")  # Neue Exception auslösen

try:
    ...
except Exception as e:
    # Exception weiterreichen
    raise

Der zweite Fall entspricht dem Re-Throw in C# oder Java, wobei in Python das erneute Werfen ohne Argument die ursprüngliche Exception unverändert weitergibt.

Eigene Exceptions mit `raise` erzeugen¶

Das bewusste Auslösen eigener Exceptions ist essenziell, um Fehler semantisch klar zu kommunizieren und die Fehlerbehandlung granular zu gestalten. Üblicherweise definiert man eigene Exception-Klassen als Subklassen von Exception oder einer passenden Basisklasse:

class ConfigurationError(Exception):
    """Fehler bei der Konfiguration der Anwendung."""
    pass


def load_config(path: str) -> dict:
    if not path.endswith('.yaml'):
        raise ConfigurationError(f"Nur YAML-Dateien werden unterstützt, nicht: {path}")
    # ...

Das explizite raise ConfigurationError(...) macht den Fehlerfall sofort und präzise erkennbar.

`raise` mit Traceback: Fehler neu auslösen und anreichern¶

Ein häufiges Muster ist das Abfangen einer Exception, um Kontext hinzuzufügen, und dann das erneute Auslösen mit raise ... from .... Dies erzeugt eine Exception-Chaining-Hierarchie, die die Fehlerquelle nachvollziehbar macht:

try:
    data = json.loads(raw_data)
except json.JSONDecodeError as e:
    raise ConfigurationError("Fehler beim Parsen der Konfiguration") from e

Dieses idiomatische Muster verbessert die Diagnose, indem es die ursprüngliche Ursache (json.JSONDecodeError) sichtbar hält.

Best Practices für `raise`¶

Klarheit vor Kürze: Die Exception sollte eine aussagekräftige Fehlermeldung enthalten, die den Fehlerkontext beschreibt.
Spezifische Exception-Typen: Verwenden Sie eigene Exception-Klassen für verschiedene Fehlerarten, um differenzierte Behandlung zu ermöglichen.
Exception Chaining nutzen: Verwenden Sie raise ... from ..., um Fehlerursachen transparent zu machen.
Keine unnötigen Catch-and-Raise: Fangen Sie Exceptions nur ab, wenn Sie sie sinnvoll verarbeiten oder anreichern können.

Vergleich zu Java und C¶

In Java oder C# ist das Werfen von Exceptions oft mit der Deklaration von Checked Exceptions verbunden, was zu umfangreicher Methodensignatur und Fehlerpropagation führt. Python verzichtet bewusst darauf, was zu schlankeren APIs führt, aber auch erfordert, dass Entwickler Exceptions gezielt und mit Bedacht auslösen und dokumentieren.

Beispiel: API-Request mit `raise`¶

import requests

class APIError(Exception):
    pass


def fetch_user(user_id: int) -> dict:
    response = requests.get(f"https://api.example.com/users/{user_id}")
    if response.status_code != 200:
        raise APIError(f"API returned status {response.status_code} für user_id={user_id}")
    return response.json()

Hier wird mit raise ein Fehlerzustand explizit signalisiert, anstatt etwa None zurückzugeben oder Fehlercodes zu verwenden. Das entspricht der Python-Philosophie, Fehler nicht zu verschleiern.

Mermaid-Diagramm: Exception-Fluss mit `raise`¶

sequenceDiagram
    participant Caller
    participant Function
    participant ExceptionHandler

    Caller->>Function: Aufruf
    Function->>Function: Prüfe Fehlerbedingung
    alt Fehler
        Function-->>Caller: raise Exception
        Caller->>ExceptionHandler: fange Exception
    else Kein Fehler
        Function-->>Caller: Ergebnis
    end

Merksatz¶

raise ist in Python das idiomatische Mittel, um Fehlerzustände präzise und lesbar zu signalisieren – mit klaren, aussagekräftigen Exceptions und optionalem Exception Chaining für bessere Diagnosen.

Eigene Exceptions entwickeln¶

Anwendungsbezogene Fehlertypen erstellen und professionell einsetzen.

Warum eigene Exceptions?¶

In Python ist das Exception-System bewusst flexibel und offen gestaltet. Anders als in Java oder C# gibt es keine zwingende Pflicht, eigene Exceptions zu definieren, um Fehler differenziert zu behandeln. Dennoch ist das Erstellen anwendungsspezifischer Exceptions eine bewährte Praxis, um Fehler semantisch klar zu kennzeichnen, die Lesbarkeit des Codes zu erhöhen und die Fehlerbehandlung präzise zu steuern.

Eigene Exceptions dienen als Selbstbeschreibung des Fehlers und ermöglichen es, in except-Blöcken gezielt auf bestimmte Fehlerfälle zu reagieren, ohne auf generische Ausnahmen wie ValueError oder RuntimeError zurückgreifen zu müssen.

Exception-Klassen definieren¶

In Python erben eigene Exceptions üblicherweise direkt oder indirekt von Exception. Die Basisklasse BaseException sollte nur in sehr speziellen Fällen verwendet werden, da sie auch SystemExit oder KeyboardInterrupt umfasst.

class ConfigError(Exception):
    """Basisklasse für Konfigurationsfehler."""
    pass

class MissingConfigFileError(ConfigError):
    def __init__(self, filename: str) -> None:
        super().__init__(f"Config file not found: {filename}")
        self.filename = filename

class InvalidConfigValueError(ConfigError):
    def __init__(self, key: str, value: str) -> None:
        super().__init__(f"Invalid value '{value}' for config key '{key}'")
        self.key = key
        self.value = value

Diese Struktur erlaubt es, alle Konfigurationsfehler über ConfigError abzufangen, aber bei Bedarf auch spezifischere Fehler zu behandeln.

Vergleich zu Java und C¶

In Java oder C# ist das Definieren eigener Exceptions oft mit dem Konzept der Checked Exceptions verbunden, die explizit deklariert und behandelt werden müssen. Python verzichtet bewusst darauf, um die Lesbarkeit und Flexibilität zu erhöhen. Stattdessen liegt die Verantwortung beim Entwickler, Exceptions sinnvoll zu strukturieren und zu dokumentieren.

Idiomatische Verwendung eigener Exceptions¶

Vererbungshierarchie nutzen: Gruppieren Sie verwandte Fehler unter einer gemeinsamen Basisklasse, um granulare oder generische Fehlerbehandlung zu ermöglichen.
Aussagekräftige Nachrichten: Übergeben Sie im Konstruktor aussagekräftige Fehlermeldungen, idealerweise mit Kontextdaten als Attribute.
Keine Logik in Exceptions: Exceptions sollten Daten und Nachricht transportieren, aber keine komplexe Logik enthalten.

Beispiel: API-Client mit eigenen Exceptions¶

class ApiError(Exception):
    """Basisklasse für API-bezogene Fehler."""
    pass

class ApiConnectionError(ApiError):
    def __init__(self, endpoint: str) -> None:
        super().__init__(f"Failed to connect to API endpoint: {endpoint}")
        self.endpoint = endpoint

class ApiResponseError(ApiError):
    def __init__(self, status_code: int, message: str) -> None:
        super().__init__(f"API returned status {status_code}: {message}")
        self.status_code = status_code
        self.message = message


def fetch_data(endpoint: str) -> dict:
    # Simulierter API-Aufruf
    raise ApiConnectionError(endpoint)

try:
    data = fetch_data("https://api.example.com/data")
except ApiConnectionError as e:
    # Spezifische Behandlung der Verbindungsprobleme
    print(e)
except ApiResponseError as e:
    # Behandlung von fehlerhaften Antworten
    print(e)
except ApiError:
    # Generische Fehlerbehandlung für API-Probleme
    print("Ein unbekannter API-Fehler ist aufgetreten.")

Mermaid-Klassendiagramm zur Exception-Hierarchie¶

classDiagram
    class Exception {
        <<builtin>>
    }
    class ConfigError {
        <<custom>>
    }
    class MissingConfigFileError {
        <<custom>>
    }
    class InvalidConfigValueError {
        <<custom>>
    }
    class ApiError {
        <<custom>>
    }
    class ApiConnectionError {
        <<custom>>
    }
    class ApiResponseError {
        <<custom>>
    }

    Exception <|-- ConfigError
    ConfigError <|-- MissingConfigFileError
    ConfigError <|-- InvalidConfigValueError

    Exception <|-- ApiError
    ApiError <|-- ApiConnectionError
    ApiError <|-- ApiResponseError

Best Practices¶

Definieren Sie eigene Exceptions nur, wenn sie einen Mehrwert bringen (z.B. differenzierte Fehlerbehandlung oder bessere Lesbarkeit).
Verwenden Sie sprechende Namen, die den Fehlerkontext klar machen.
Dokumentieren Sie Ihre Exceptions, insbesondere welche Fehlerbedingungen sie repräsentieren.
Nutzen Sie Attribute in Exceptions, um relevante Kontextinformationen bereitzustellen, anstatt nur eine Fehlermeldung.

Merksatz¶

Eigene Exceptions sind in Python ein Werkzeug zur klaren Kommunikation von Fehlerbedingungen und zur gezielten Steuerung der Fehlerbehandlung – sie sind kein Zwang, sondern eine bewusste Designentscheidung, die den Code wartbarer und verständlicher macht.

Einführung in Logging¶

Den Unterschied zwischen Logging und Debug-Ausgaben verstehen.

Logging versus Debug-Ausgaben¶

In vielen etablierten Sprachen wie Java, C# oder C++ ist das Debugging oft eng mit der Verwendung von print-Statements oder Debugger-Tools verbunden. Python bietet ebenfalls einfache print-Ausgaben, doch für professionelle Anwendungen ist das integrierte Logging-System unverzichtbar.

Warum nicht einfach print verwenden?

Fehlende Steuerbarkeit: print gibt immer aus, ohne Filter oder Priorisierung.
Kein konfigurierbares Ausgabeziel: print schreibt standardmäßig auf die Konsole, nicht in Dateien oder entfernte Systeme.
Kein Kontext: Logs können automatisch Zeitstempel, Modulnamen, Thread-IDs und mehr enthalten.

Das Python-Logging-Modul bietet eine flexible, konfigurierbare Infrastruktur, die sich von einfachen Debug-Ausgaben deutlich unterscheidet.

Grundlegende Konzepte des Logging¶

Das Logging-Modul ist so konzipiert, dass es verschiedene Schichten abstrahiert:

Logger: Erzeugt Log-Nachrichten. Es können beliebig viele Logger mit unterschiedlichen Namen existieren.
Handler: Bestimmt, wohin die Log-Nachrichten gesendet werden (Konsole, Datei, Netzwerk).
Formatter: Definiert das Ausgabeformat der Log-Nachrichten.

Diese Trennung ermöglicht komplexe, aber übersichtliche Konfigurationen.

Beispiel: Einfache Log-Nachricht¶

import logging

logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)  # Einfachste Konfiguration

logger.info("Starte Datenverarbeitung")

Im Gegensatz zu print kann hier mit level=logging.INFO gesteuert werden, welche Nachrichten ausgegeben werden. In produktiven Systemen lassen sich so Debug-Informationen bei Bedarf aktivieren, ohne den Code zu ändern.

Vergleich zu Java und C# Logging¶

In Java oder C# sind Logging-Frameworks wie Log4j oder NLog ebenfalls modular aufgebaut. Python verfolgt eine ähnliche Designphilosophie, jedoch mit einer standardisierten Bibliothek im Kern.

Python: Integriertes logging-Modul, keine externe Abhängigkeit nötig.
Java/C#: Separate Bibliotheken, oft mit umfangreicher Konfiguration via XML oder JSON.

Python setzt auf einfache Konventionen und eine API, die sich gut in Skripte und Anwendungen aller Größenordnungen einfügt.

Best Practices¶

Verwenden Sie logging statt print für alle produktiven Anwendungen.
Nutzen Sie unterschiedliche Log-Level (DEBUG, INFO, WARNING, ERROR, CRITICAL) für feingranulare Steuerung.
Konfigurieren Sie Handler und Formatter zentral, um Konsistenz zu gewährleisten.
Verzichten Sie auf das Entfernen von Debug-Ausgaben im Code; steuern Sie die Sichtbarkeit über Log-Level.

Merksatz¶

Logging ist nicht nur Debug-Ausgabe – es ist ein strukturierter Kommunikationskanal für den Zustand und das Verhalten einer Anwendung, der flexibel konfiguriert und zentral gesteuert wird.

Das logging-Modul¶

Log-Nachrichten erzeugen und verschiedene Log-Level verwenden und konfigurieren.

Grundlagen des logging-Moduls¶

Das logging-Modul in Python ist das zentrale Werkzeug zur Erzeugung von Log-Nachrichten und bietet eine flexible, konfigurierbare Alternative zu einfachen print-Debug-Ausgaben. Anders als in Java oder C# ist Logging in Python von Haus aus sehr dynamisch und modular aufgebaut, was eine feingranulare Steuerung der Ausgabe erlaubt.

Ein Kernkonzept ist die Trennung von Logger, Handler und Formatter:

Logger: Erzeugt Log-Einträge, organisiert in einer hierarchischen Namensstruktur.
Handler: Bestimmt, wohin die Log-Nachrichten gesendet werden (Konsole, Datei, Netzwerk, etc.).
Formatter: Definiert das Ausgabeformat der Log-Nachrichten.

Diese Trennung ermöglicht es, verschiedene Ausgabekanäle und Formate gleichzeitig zu konfigurieren, ohne den Anwendungscode zu ändern.

Log-Level und ihre Bedeutung¶

Python unterstützt standardmäßig folgende Log-Level (in aufsteigender Priorität):

DEBUG: Detaillierte Informationen, meist für Entwickler.
INFO: Allgemeine Laufzeitinformationen.
WARNING: Hinweise auf potenzielle Probleme.
ERROR: Laufzeitfehler, die eine Funktionalität beeinträchtigen.
CRITICAL: Sehr schwere Fehler, die das Programm möglicherweise beenden.

Diese Levels sind analog zu Log-Leveln in Java (java.util.logging) oder C# (Microsoft.Extensions.Logging), jedoch ist die Hierarchie in Python oft flacher und die Konfiguration einfacher.

Einfache Verwendung¶

import logging

logging.basicConfig(level=logging.INFO)

logging.debug("Dies ist eine Debug-Nachricht, die nicht angezeigt wird.")
logging.info("Anwendung gestartet.")
logging.warning("Warnung: Ressourcen sind knapp.")
logging.error("Fehler beim Lesen der Datei.")
logging.critical("Kritischer Fehler: Systemabsturz möglich.")

basicConfig ist ein einfacher Einstieg, der einen Root-Logger mit einem StreamHandler auf die Konsole konfiguriert.

Erweiterte Logger-Konfiguration¶

Für professionelle Anwendungen empfiehlt sich eine explizite Logger-Konfiguration, um Log-Ausgaben gezielt zu steuern.

import logging

logger = logging.getLogger("myapp.module")
logger.setLevel(logging.DEBUG)  # Logger-Level setzen

# Handler für Konsolenausgabe
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.INFO)  # Handler-Level

# Formatierung
formatter = logging.Formatter(
    '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
console_handler.setFormatter(formatter)

logger.addHandler(console_handler)

logger.debug("Debug-Informationen")  # Wird nicht angezeigt, da Handler auf INFO
logger.info("Info-Nachricht")

Hier sehen Sie, dass Logger und Handler eigene Level besitzen. Die Log-Nachricht wird nur ausgegeben, wenn sie beide Level überschreitet.

Logger-Hierarchie und Vererbung¶

Logger sind hierarchisch organisiert, ähnlich wie Paketstrukturen in Java oder Namespaces in C#:

classDiagram
    class Logger {
        +name: str
        +level: int
        +handlers: list
        +parent: Logger
        +log(level: int, msg: str)
        +addHandler(handler: Handler)
    }

    Logger <|-- RootLogger

    class Handler {
        +level: int
        +formatter: Formatter
        +emit(record: LogRecord)
    }

    class Formatter {
        +format(record: LogRecord) -> str
    }

    Logger "*" -- "*" Handler : besitzt
    Logger --> Logger : parent

Wenn ein Logger keine Handler besitzt, werden die Log-Nachrichten an den Elternlogger weitergereicht. Das ermöglicht zentrale Steuerung und flexible Modularisierung.

Best Practices und Python-spezifische Tipps¶

Verwenden Sie logging.getLogger(__name__) in Modulen, um eine klare Namenshierarchie zu erzeugen.
Vermeiden Sie globale Konfigurationen in Bibliotheken; überlassen Sie die Konfiguration der Anwendung.
Nutzen Sie LoggerAdapter, um kontextbezogene Informationen (z. B. Benutzer-ID) in Logs einzufügen.
Verwenden Sie exc_info=True in Log-Aufrufen, um Stacktraces bei Exceptions automatisch zu loggen.

Vergleich zu Java und C¶

In Java oder C# ist die Logger-Konfiguration oft XML- oder JSON-basiert und erfordert externe Konfigurationsdateien. Python setzt auf einfache Konventionen und Programmier-APIs, was schnelleren Einstieg und dynamische Anpassungen ermöglicht.

Zudem ist das logging-Modul in Python so gestaltet, dass es auch in kleinen Skripten ohne großen Aufwand funktioniert, während es gleichzeitig für komplexe Anwendungen skalierbar bleibt.

Zusammenfassung¶

logging trennt Logger, Handler und Formatter für maximale Flexibilität.
Log-Level steuern, welche Nachrichten ausgegeben werden.
Logger sind hierarchisch organisiert und erben Einstellungen.
Explizite Konfiguration ist für professionelle Anwendungen essenziell.
Python-Logging ist dynamisch und integriert sich idiomatisch in den Programmfluss.

Mit diesem Verständnis können Sie robuste und wartbare Logging-Lösungen in Python entwickeln, die den Anforderungen professioneller Softwareentwicklung gerecht werden.

Dateien lesen und schreiben¶

Textdateien sicher öffnen, lesen und speichern.

Dateien sicher öffnen: Kontextmanager und Encoding¶

Im Gegensatz zu Java oder C# ist das Öffnen von Dateien in Python bewusst einfach und flexibel gestaltet. Der idiomatische Weg, Dateien zu öffnen, erfolgt mit dem with-Statement, das einen Kontextmanager nutzt. Dadurch wird sichergestellt, dass Dateien auch bei Ausnahmen zuverlässig geschlossen werden – ein Muster, das in Java etwa mit try-with-resources oder in C# mit using vergleichbar ist.

# Idiomatisches Öffnen einer Datei zum Lesen
with open("config.txt", "r", encoding="utf-8") as file:
    content = file.read()

Der Parameter encoding ist essentiell, da Python standardmäßig (je nach Plattform) unterschiedliche Encodings verwendet. Explizite Angabe von UTF-8 vermeidet plattformabhängige Fehler und ist Best Practice.

Lesen großer Dateien: Iteration statt vollständiges Einlesen¶

Für große Dateien ist das vollständige Einlesen mit read() oft ineffizient. Stattdessen empfiehlt sich die zeilenweise Iteration, die speicherschonend und performant ist:

with open("logs.txt", "r", encoding="utf-8") as file:
    for line in file:
        process(line.strip())  # Prozessschritt

Dies entspricht dem Iterator-Konzept, das in Python tief verankert ist und sich von typischen Java- oder C#-Streams unterscheidet, da es lazy und speichereffizient ist.

Schreiben von Dateien: Modus und atomare Operationen¶

Beim Schreiben ist der Modus "w" für Überschreiben und "a" für Anhängen üblich. Python unterstützt auch den Modus "x" für exklusives Erstellen, was in Java oder C# nicht direkt vorhanden ist.

with open("output.txt", "w", encoding="utf-8") as file:
    file.write("Ergebniszeile\n")

Für kritische Anwendungen empfiehlt sich das Schreiben in eine temporäre Datei und anschließendes atomares Umbenennen, um Datenverlust zu vermeiden. Python bietet dafür keine eingebaute Methode, aber das os.replace() ist plattformübergreifend atomar.

Beispiel: Logdatei rotieren¶

import os
from pathlib import Path

def rotate_log(log_path: Path, backup_path: Path) -> None:
    if log_path.exists():
        os.replace(log_path, backup_path)  # atomar umbenennen
    with log_path.open("w", encoding="utf-8") as f:
        f.write("")  # neue leere Logdatei

Unterschied zu Java und C¶

Ressourcenmanagement: Python nutzt Kontextmanager, die explizit mit with gekennzeichnet sind, während Java und C# try-with-resources bzw. using verwenden. Python trennt so klar Ressourcenkontrolle vom eigentlichen Code.
Encoding: Python verlangt explizite Kontrolle über Text-Encoding, da es keine implizite Plattformstandard-Konvertierung gibt. Java und C# haben standardisierte Unicode-Strings, aber Encoding beim Lesen/Schreiben ist oft implizit.
Dateimodi: Python bietet einfache, flexible Modi inklusive exklusivem Erstellen (x), was in Java oder C# explizitere APIs erfordert.

Häufige Fehler und Best Practices¶

Nicht geschlossene Dateien: Vermeide open() ohne with, da Dateien sonst nicht garantiert geschlossen werden.
Encoding weglassen: Führt zu plattformabhängigen Fehlern, besonders bei Sonderzeichen.
Fehlerbehandlung: Nutze gezielte try-except-Blöcke, um IO-Fehler abzufangen und sinnvoll zu reagieren.

Zusammenfassung¶

Python setzt auf einfache, explizite und sichere Dateioperationen durch Kontextmanager und klare Modus-/Encoding-Parameter. Die Trennung von Ressourcenmanagement und Logik ist ein zentrales Designprinzip, das sich von Java und C# unterscheidet, aber vergleichbare Sicherheit und Lesbarkeit bietet.

Mermaid-Diagramm: Ablauf beim sicheren Lesen einer Datei¶

sequenceDiagram
    participant User
    participant with_open
    participant FileObject

    User->>with_open: with open(path, mode, encoding)
    with_open->>FileObject: open file
    FileObject-->>with_open: file handle
    with_open-->>User: file handle
    User->>FileObject: read()/iter()
    FileObject-->>User: data
    User->>with_open: exit context
    with_open->>FileObject: close file
    FileObject-->>with_open: closed

Arbeiten mit pathlib¶

Moderne Dateisystemoperationen mit Path-Objekten durchführen.

Grundlagen von pathlib¶

Das pathlib-Modul ist seit Python 3.4 Teil der Standardbibliothek und stellt eine objektorientierte Schnittstelle für Dateisystempfade bereit. Im Gegensatz zu den traditionellen Funktionen in os und os.path kapselt pathlib Pfade als Path-Objekte, die plattformunabhängig und intuitiv zu handhaben sind.

Diese Designentscheidung folgt der Python-Philosophie, dass Objekte mehr Ausdruckskraft bieten als reine String-Manipulationen. Für Entwickler aus Java oder C# ist das vergleichbar mit der Verwendung von java.nio.file.Path oder System.IO.Path-Klassen, jedoch mit einem stärker idiomatischen Python-Fokus.

Path-Objekte erstellen und verwenden¶

from pathlib import Path

# Absoluter Pfad
p = Path('/var/log/syslog')

# Relativer Pfad
q = Path('src') / 'project' / 'main.py'

print(p.name)        # 'syslog'
print(q.parent)      # 'src/project'
print(q.suffix)      # '.py'

Das Operator-Overloading von / für Pfadverkettung ist ein zentrales idiomatisches Element, das im Vergleich zu String-Verkettung in Java oder C# eleganter und lesbarer ist.

Pfadabfragen und Dateisysteminteraktionen¶

Path-Objekte bieten Methoden für häufige Operationen, die in anderen Sprachen oft in Utility-Klassen versteckt sind:

if p.exists() and p.is_file():
    size = p.stat().st_size
    print(f'Dateigröße: {size} Bytes')

for child in p.parent.iterdir():
    print(child.name)

Wichtig ist, dass pathlib Pfadmanipulation und Dateisystemzugriff klar trennt: Methoden wie exists() greifen aufs Dateisystem zu, während name, suffix rein stringbasiert sind.

Plattformunabhängigkeit und Typen¶

pathlib abstrahiert plattformspezifische Unterschiede:

Unter Windows werden automatisch WindowsPath-Objekte erzeugt, unter Unix PosixPath.
Pfadtrennzeichen, Laufwerksbuchstaben und UNC-Pfade werden korrekt behandelt.

Dies erspart Entwicklern, manuell zwischen \ und / unterscheiden zu müssen, wie es in C# oder Java oft nötig ist.

Ein typischer Workflow: Dateien suchen und lesen¶

from pathlib import Path

def find_text_files(directory: Path) -> list[Path]:
    return list(directory.rglob('*.txt'))

root = Path('/var/log')
text_files = find_text_files(root)

for file in text_files:
    with file.open('r', encoding='utf-8') as f:
        content = f.read()
        # Verarbeitung

Die Methode rglob() kombiniert rekursive Suche mit Pattern-Matching, was in Java oder C# oft umständlicher mit FileVisitor oder LINQ ist.

Diagramm: Klassenhierarchie von pathlib¶

classDiagram
    class Path {
        +__truediv__(self, other) Path
        +exists() bool
        +is_file() bool
        +is_dir() bool
        +iterdir() Iterator[Path]
        +rglob(pattern: str) Iterator[Path]
        +open(mode: str, encoding: Optional[str]) IO
        +name: str
        +suffix: str
        +parent: Path
    }
    class PosixPath
    class WindowsPath

    Path <|-- PosixPath
    Path <|-- WindowsPath

Best Practices und häufige Fehler¶

Pfadverkettung immer mit / und Path-Objekten: Vermeidet Fehler durch falsche Trennzeichen.
Nicht mit Strings mischen: Path und str sollten nicht vermischt werden, außer bei expliziter Konvertierung (str(path)).
Dateizugriffe mit open() von Path: Nutzt den Kontextmanager, um Ressourcen sicher zu verwalten.
Beachten, dass Path-Objekte unveränderlich sind: Methoden wie with_name() erzeugen neue Objekte.

Vergleich zu Java und C¶

In Java und C# sind Pfadoperationen oft verteilt auf verschiedene Klassen und Utilities, z. B. File, Path, Files in Java oder FileInfo, DirectoryInfo in C#. Python bündelt diese Funktionalität in einem einzigen, konsistenten Objektmodell, was den Code lesbarer und wartbarer macht.

Merksatz¶

pathlib repräsentiert Pfade als Objekte, die sowohl Pfadmanipulation als auch Dateisystemzugriff auf idiomatische und plattformunabhängige Weise vereinen.

Mit pathlib wird der Umgang mit Dateisystemen in Python nicht nur sicherer und lesbarer, sondern auch deutlich eleganter als mit klassischen String-basierten APIs. Dies entspricht dem Python-Prinzip, dass Code lesbar und explizit sein soll, während er gleichzeitig mächtige Abstraktionen bietet.

CSV-Dateien verarbeiten¶

Tabellarische Daten mit dem csv-Modul importieren und exportieren.

Grundlagen des csv-Moduls¶

Python bietet mit dem integrierten csv-Modul eine robuste und flexible API zum Lesen und Schreiben von CSV-Dateien. Anders als in Java oder C#, wo man oft auf externe Bibliotheken oder aufwändige Parser zurückgreift, ist das csv-Modul in Python Teil der Standardbibliothek und unterstützt verschiedene Dialekte, Trennzeichen und Anführungszeichen-Strategien.

Das csv-Modul abstrahiert die Details des Parsings, sodass Sie sich auf die Datenverarbeitung konzentrieren können. Es arbeitet typischerweise mit Iteratoren, was eine speichereffiziente Verarbeitung großer Dateien ermöglicht.

CSV-Dateien lesen¶

Die zentrale Funktion zum Einlesen ist csv.reader. Sie liefert Zeilen als Listen von Strings. Für strukturierte Daten empfiehlt sich die Verwendung von csv.DictReader, das jede Zeile als dict mit Spaltennamen als Schlüssel zurückgibt – ähnlich zu Map<String,String> in Java, aber mit Python-typischer Einfachheit.

import csv
from typing import Iterator, Dict

def read_csv_as_dicts(file_path: str) -> Iterator[Dict[str, str]]:
    with open(file_path, encoding='utf-8', newline='') as csvfile:
        reader = csv.DictReader(csvfile)
        for row in reader:
            yield row

# Beispielnutzung
for record in read_csv_as_dicts('kunden.csv'):
    print(record['Name'], record['Email'])

Hinweis: Das Öffnen mit newline='' ist wichtig, um plattformunabhängig Zeilenenden korrekt zu behandeln. Dies ist ein häufig übersehener Unterschied zu Java, wo BufferedReader meist automatisch Zeilenenden behandelt.

CSV-Dateien schreiben¶

Zum Schreiben verwendet man csv.writer oder csv.DictWriter. Letzterer ist besonders nützlich, wenn man strukturierte Daten als Dictionaries vorliegen hat.

import csv
from typing import List, Dict

def write_csv(file_path: str, fieldnames: List[str], data: List[Dict[str, str]]) -> None:
    with open(file_path, 'w', encoding='utf-8', newline='') as csvfile:
        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
        writer.writeheader()
        writer.writerows(data)

# Beispiel
kunden = [
    {'Name': 'Alice', 'Email': 'alice@example.com'},
    {'Name': 'Bob', 'Email': 'bob@example.com'}
]
write_csv('output.csv', ['Name', 'Email'], kunden)

Umgang mit Dialekten und Sonderfällen¶

CSV-Dateien sind nicht standardisiert; Trennzeichen, Anführungszeichen und Escape-Zeichen variieren stark. Das csv-Modul erlaubt die Definition eigener Dialekte oder die Nutzung vordefinierter wie excel oder unix.

csv.register_dialect('semicolon', delimiter=';', quotechar='"')

with open('daten.csv', newline='') as f:
    reader = csv.reader(f, dialect='semicolon')
    for row in reader:
        print(row)

Vergleich zu Java/C¶

In Java oder C# ist CSV-Verarbeitung oft mit komplexeren Bibliotheken wie OpenCSV oder CsvHelper verbunden, die umfangreiche Features bieten, aber auch mehr Konfiguration erfordern. Python setzt auf einfache, aber flexible APIs, die durch Iteratoren und Kontextmanager idiomatisch und sicher sind.

Best Practices¶

Verwenden Sie immer newline='' beim Öffnen von CSV-Dateien, um Zeilenenden korrekt zu behandeln.
Nutzen Sie DictReader und DictWriter für klarere, selbstbeschreibende Datenverarbeitung.
Definieren Sie Dialekte, wenn Sie mit nicht-standardisierten CSV-Formaten arbeiten.
Verarbeiten Sie CSV-Daten iterativ, um Speicher zu sparen, insbesondere bei großen Dateien.

Zusammenfassung¶

Das csv-Modul ist ein leistungsfähiges Werkzeug für tabellarische Daten in Python. Es folgt der Python-Philosophie: einfache, lesbare und effiziente Lösungen. Für Entwickler aus Java oder C# ist es wichtig, sich auf die Iterator-basierte Verarbeitung und die flexible Dialekt-Definition einzustellen, statt auf komplexe Parser-Frameworks zu setzen.

Falls Sie CSV-Daten in komplexeren Szenarien verarbeiten, empfiehlt sich die Kombination mit pathlib für Pfadoperationen und robustes Exception-Handling, was in den folgenden Abschnitten behandelt wird.

JSON verarbeiten¶

Python-Objekte in JSON serialisieren und wieder einlesen. Eigenen Encoder und Decoder Beispiel.

JSON in Python: Serialisierung und Deserialisierung¶

Python nutzt das eingebaute json-Modul, um Datenstrukturen in das JSON-Format zu serialisieren und wieder zurück zu deserialisieren. JSON ist ein textbasiertes, sprachunabhängiges Datenformat, das sich hervorragend für den Datenaustausch zwischen Systemen eignet – ähnlich wie XML, aber kompakter und leichter lesbar.

Im Vergleich zu Java oder C# ist das Python-JSON-Modul bewusst einfach gehalten und folgt der Philosophie „Batteries included“: Es unterstützt die gängigen Typen (Dictionaries, Listen, Strings, Zahlen, Booleans, None) direkt, erfordert aber für komplexere Typen explizite Anpassungen.

Grundlegende Serialisierung und Deserialisierung¶

import json

# Python-Objekt
data: dict[str, object] = {
    "name": "Alice",
    "age": 30,
    "is_active": True,
    "roles": ["admin", "user"]
}

# Serialisieren (Python -> JSON-String)
json_str: str = json.dumps(data, indent=2)
print(json_str)

# Deserialisieren (JSON-String -> Python)
parsed_data: dict = json.loads(json_str)
print(parsed_data["name"])

Warum eigene Encoder/Decoder?¶

Standardmäßig unterstützt json nur die Basistypen. Für eigene Klassen oder komplexe Datentypen (z.B. datetime, UUID, benutzerdefinierte Objekte) müssen Sie eigene Encoder und Decoder implementieren.

In Java oder C# verwenden Sie häufig Annotationen oder Interfaces (z.B. Serializable), um die Serialisierung zu steuern. Python setzt hier auf Flexibilität durch die Übergabe von Funktionen oder das Überschreiben von Methoden.

Eigener JSONEncoder¶

Sie erweitern json.JSONEncoder und überschreiben die default-Methode, um eigene Typen zu serialisieren. Beispiel:

from json import JSONEncoder
from datetime import datetime

class DateTimeEncoder(JSONEncoder):
    def default(self, obj: object) -> object:
        if isinstance(obj, datetime):
            return obj.isoformat()  # ISO 8601-Format
        return super().default(obj)

now = datetime.now()
json_str = json.dumps({"timestamp": now}, cls=DateTimeEncoder)
print(json_str)

Eigener Decoder mit object_hook¶

Zum Einlesen können Sie object_hook verwenden, um JSON-Objekte beim Parsen in eigene Typen umzuwandeln:

from datetime import datetime

def datetime_object_hook(dct: dict) -> dict:
    if "timestamp" in dct:
        dct["timestamp"] = datetime.fromisoformat(dct["timestamp"])
    return dct

json_str = '{"timestamp": "2024-06-01T12:34:56"}'
data = json.loads(json_str, object_hook=datetime_object_hook)
print(data["timestamp"].year)  # 2024

Best Practices¶

Verwenden Sie indent beim Dumpen, um lesbare JSON-Dateien zu erzeugen, besonders bei Konfigurations- oder Logdateien.
Nutzen Sie object_hook und eigene Encoder, um die Serialisierung bidirektional konsistent zu halten.
Vermeiden Sie die Verwendung von eval oder unsicheren Methoden zur Deserialisierung.
Beachten Sie, dass JSON keine Kommentare oder komplexe Datentypen unterstützt – für komplexe Konfigurationen sind Formate wie YAML oder TOML oft besser geeignet.

Merksatz¶

Python trennt strikt zwischen Datenrepräsentation (JSON-Text) und Objektrepräsentation (Python-Objekte). Eigene Encoder/Decoder sind der idiomatische Weg, um diese Brücke zu schlagen.

Mermaid-Diagramm: JSONEncoder-Erweiterung¶

classDiagram
    class JSONEncoder {
        <<abstract>>
        +default(obj: object) object
        +encode(obj: object) str
    }
    class DateTimeEncoder {
        +default(obj: object) object
    }
    JSONEncoder <|-- DateTimeEncoder

Dieses Diagramm zeigt die Vererbungshierarchie: DateTimeEncoder erweitert JSONEncoder und überschreibt default, um zusätzliche Typen zu unterstützen.

YAML und TOML verarbeiten¶

Konfigurationsdateien und strukturierte Daten mit YAML nutzen.

YAML und TOML als moderne Konfigurationsformate¶

YAML und TOML sind in der Python-Welt etablierte Formate für Konfigurationsdateien und strukturierte Daten. Im Gegensatz zu XML oder INI bieten sie eine klarere Syntax und bessere Unterstützung für komplexe Datenstrukturen. Während YAML sehr mächtig und flexibel ist, punktet TOML mit Einfachheit und Vorhersagbarkeit.

Python-Entwickler schätzen diese Formate, weil sie sich gut in Python-Datenstrukturen abbilden lassen und durch entsprechende Bibliotheken einfach zu verarbeiten sind. Im Vergleich zu Java oder C# sind YAML und TOML in Python häufiger erste Wahl für Konfigurationen, da sie weniger Boilerplate benötigen und idiomatischer wirken.

YAML mit PyYAML verarbeiten¶

Das am weitesten verbreitete YAML-Paket ist PyYAML. Es unterstützt das Einlesen (yaml.safe_load) und Schreiben (yaml.safe_dump) von YAML-Daten. Wichtig ist, safe_load zu verwenden, um Sicherheitsrisiken durch potenziell ausführbaren Code zu vermeiden.

import yaml
from typing import Any

config_yaml = """
server:
  host: localhost
  port: 8080
features:
  - auth
  - logging
"""

config: dict[str, Any] = yaml.safe_load(config_yaml)
print(config['server']['host'])  # localhost

# YAML schreiben
config['server']['port'] = 9090
yaml_str = yaml.safe_dump(config, sort_keys=False)
print(yaml_str)

Besonderheiten von YAML¶

YAML unterstützt Kommentare, was für Konfigurationsdateien oft wichtig ist.
Es erlaubt komplexe Datenstrukturen wie verschachtelte Maps, Listen und Skalare.
Die Einrückung ist signifikant, ähnlich wie in Python.

Vergleich zu Java/C¶

In Java oder C# werden oft XML oder JSON für Konfigurationen verwendet, da YAML-Parsing weniger verbreitet ist. Python nutzt YAML, weil es lesbarer ist und sich natürlich in Python-Datenstrukturen übersetzen lässt.

TOML mit tomli und tomli-w¶

TOML ist ein jüngeres Format, das explizit für Konfigurationsdateien entwickelt wurde. Es setzt auf eine klare, einfache Syntax und vermeidet die Komplexität von YAML. Python 3.11+ bietet tomllib für das Einlesen, für ältere Versionen ist tomli der Standard. Zum Schreiben von TOML-Dateien kann tomli-w verwendet werden, das muss aber separat installiert werden, zum Beispiel mit uv add tomli-w.

import tomllib
import tomli_w
from typing import Any

config_toml = '''
[server]
host = "localhost"
port = 8080

features = ["auth", "logging"]
'''

# Schreiben von TOML-Daten in eine neue Datei
with open("config.toml", "wb") as f:
    tomli_w.dump(tomllib.loads(config_toml), f)

# Einlesen
with open("config.toml", "rb") as f:
    config = tomllib.load(f)

# Alternativ aus String
config = tomllib.loads(config_toml)
print(config["server"]["host"])  # localhost

# Schreiben
config["server"]["port"] = 9090
with open("config.toml", "wb") as f:
    tomli_w.dump(config, f)

TOML ist ein Textformat und kein Binärformat. Das Modul tomllib erwartet beim Einlesen mit load(f) jedoch einen binären Dateistream (rb), damit es die UTF-8-kodierten Daten selbst dekodieren und verarbeiten kann.

Charakteristika von TOML¶

Klare Trennung von Tabellen (Abschnitten) und Schlüssel-Wert-Paaren.
Unterstützt einfache Datentypen und Arrays, aber keine komplexen YAML-Features wie Verweise oder Mehrfachdokumente.
Explizite Typisierung (z.B. Datum, Integer, Float) erleichtert Validierung.

Designphilosophie¶

TOML ist bewusst weniger flexibel als YAML, um Fehler zu vermeiden und Parsing vorhersehbar zu machen. Das entspricht dem Python-Prinzip „There should be one—and preferably only one—obvious way to do it."

Wann YAML, wann TOML?¶

Kriterium	YAML	TOML
Komplexität	Hoch, unterstützt komplexe Strukturen	Niedrig, fokussiert auf Konfiguration
Lesbarkeit	Sehr gut, aber Einrückungen kritisch	Sehr gut, klar strukturiert
Sicherheit	`safe_load` nötig, sonst riskant	Einfacher und sicherer
Kommentarunterstützung	Ja	Ja
Typunterstützung	Sehr flexibel	Explizit und strikt

Für einfache, strikt typisierte Konfigurationen ist TOML oft die bessere Wahl. YAML eignet sich, wenn komplexe Datenstrukturen oder Kommentare benötigt werden.

Beispiel: Konfigurationsobjekt mit YAML und TOML¶

from dataclasses import dataclass
from typing import list

@dataclass
class Config:
    host: str
    port: int
    features: list[str]

# YAML laden
import yaml

def load_config_yaml(yaml_str: str) -> Config:
    data = yaml.safe_load(yaml_str)
    server = data['server']
    return Config(
        host=server['host'],
        port=server['port'],
        features=data.get('features', [])
    )

# TOML laden
import tomllib

def load_config_toml(toml_text: str) -> Config:
    data = tomllib.loads(toml_text)
    server = data['server']
    return Config(
        host=server['host'],
        port=server['port'],
        features=data.get('features', [])
    )

CSV oder JSON?¶

Die Stärken und Schwächen der verschiedenen Datenformate vergleichen und passende Einsatzgebiete identifizieren.

Datenformate im Vergleich: CSV und JSON¶

Beim Umgang mit strukturierten Daten in Python stehen häufig CSV und JSON zur Auswahl. Jedes Format hat seine Stärken, Schwächen und typische Anwendungsfälle.

CSV – Einfachheit für tabellarische Daten¶

CSV (Comma-Separated Values) ist das älteste und einfachste Format. Es eignet sich hervorragend für flache, tabellarische Daten, z.B. Export/Import von Datenbanken oder Tabellenkalkulationen.

Vorteile:
Sehr weit verbreitet und von fast allen Tools unterstützt
Einfach zu lesen und zu schreiben
Geringer Overhead, gut für große Datenmengen
Nachteile:
Keine Unterstützung für verschachtelte oder hierarchische Daten
Keine Datentypen, alles ist String (muss manuell geparst werden)
Unterschiedliche Konventionen bei Trennzeichen, Zeilenumbrüchen, Escape-Zeichen

import csv
from pathlib import Path

path = Path("data.csv")
with path.open(newline='', encoding='utf-8') as f:
    reader = csv.DictReader(f)
    for row in reader:
        print(row)  # Alle Werte als Strings

JSON – Standard für strukturierte, hierarchische Daten¶

JSON ist das de-facto-Datenformat für Web-APIs und Konfigurationsdateien. Es unterstützt komplexe, verschachtelte Strukturen aus Listen und Dictionaries.

Vorteile:
Klar definierte Syntax und Datentypen (Strings, Zahlen, Booleans, null)
Breite Unterstützung in praktisch allen Programmiersprachen
Leichtgewichtig und maschinenlesbar
Nachteile:
Kein Kommentar-Support (Workaround: separate Dokumentation oder spezielle Schlüssel)
Keine Unterstützung für komplexe Datentypen wie Datum oder Binärdaten ohne Kodierung

import json

config_json = '''
{
  "server": "localhost",
  "port": 8080,
  "features": ["logging", "metrics"]
}
'''
config = json.loads(config_json)
print(config["server"])  # localhost

Praxisbeispiel: Konfigurierbare Anwendung¶

Logging, Fehlerbehandlung und Konfigurationsdateien in einer realistischen Anwendung kombinieren.

Architektur der konfigurierbaren Anwendung¶

Eine typische konfigurierbare Anwendung kombiniert mehrere Aspekte: Konfigurationsmanagement, Logging und Fehlerbehandlung. In Python ist es üblich, diese Komponenten klar zu trennen und durch einfache, aber flexible Schnittstellen zu verbinden.

classDiagram
    class Config {
        +dict settings
        +load(path: str) void
        +get(key: str, default: Any) Any
    }

    class Logger {
        +Logger(name: str)
        +info(msg: str) void
        +error(msg: str) void
        +debug(msg: str) void
    }

    class Application {
        -config: Config
        -logger: Logger
        +run() void
    }

    Application --> Config : nutzt
    Application --> Logger : nutzt

Konfigurationsdateien einbinden¶

Python bietet mit pathlib eine moderne API für Dateisystemzugriffe. Konfigurationsdateien wie YAML oder JSON sind Standardformate, die sich leicht mit yaml oder json laden lassen.

from pathlib import Path
import json
import yaml
from typing import Any

class Config:
    def __init__(self, path: Path) -> None:
        self.settings: dict[str, Any] = {}
        self.load(path)

    def load(self, path: Path) -> None:
        if not path.exists():
            raise FileNotFoundError(f"Konfigurationsdatei {path} nicht gefunden")
        if path.suffix == '.json':
            with path.open('r', encoding='utf-8') as f:
                self.settings = json.load(f)
        elif path.suffix in ('.yaml', '.yml'):
            with path.open('r', encoding='utf-8') as f:
                self.settings = yaml.safe_load(f)
        else:
            raise ValueError(f"Unbekanntes Konfigurationsformat: {path.suffix}")

    def get(self, key: str, default: Any = None) -> Any:
        return self.settings.get(key, default)

Hinweis: Anders als in Java oder C# ist es in Python üblich, die Konfiguration als einfaches Wörterbuch (dict) zu behandeln, statt komplexe POJOs oder DTOs zu definieren. Das fördert Flexibilität und schnelle Anpassungen.

Logging konfigurieren und nutzen¶

Das logging-Modul ist der Standardweg, um strukturierte Log-Nachrichten zu erzeugen. Anders als in statisch typisierten Sprachen ist die Konfiguration in Python oft deklarativ und kann dynamisch angepasst werden.

import logging

class Logger:
    def __init__(self, name: str) -> None:
        self.logger = logging.getLogger(name)
        self.configure()

    def configure(self) -> None:
        handler = logging.StreamHandler()
        formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
        handler.setFormatter(formatter)
        self.logger.addHandler(handler)
        self.logger.setLevel(logging.DEBUG)

    def info(self, msg: str) -> None:
        self.logger.info(msg)

    def error(self, msg: str) -> None:
        self.logger.error(msg)

    def debug(self, msg: str) -> None:
        self.logger.debug(msg)

Fehlerbehandlung idiomatisch gestalten¶

Python nutzt Exceptions und das try-except-else-finally-Konstrukt, um Fehler gezielt zu behandeln. Im Zusammenspiel mit Konfiguration und Logging empfiehlt sich folgendes Muster:

Fehler in der Konfiguration führen zu kontrolliertem Abbruch mit klarer Fehlermeldung.
Laufzeitfehler werden geloggt und ggf. behandelt, um Programmabstürze zu vermeiden.

class Application:
    def __init__(self, config_path: Path) -> None:
        self.config = Config(config_path)
        self.logger = Logger('app')

    def run(self) -> None:
        try:
            self.logger.info('Starte Anwendung')
            # Beispiel: API-Endpunkt aus Konfiguration lesen
            api_url = self.config.get('api_url')
            if not api_url:
                raise ValueError('API-URL nicht in Konfiguration angegeben')
            self.logger.debug(f'API-URL: {api_url}')
            # Weitere Logik hier

        except FileNotFoundError as e:
            self.logger.error(f'Konfigurationsdatei fehlt: {e}')
        except ValueError as e:
            self.logger.error(f'Konfigurationsfehler: {e}')
        except Exception as e:
            self.logger.error(f'Unerwarteter Fehler: {e}')
        else:
            self.logger.info('Anwendung erfolgreich beendet')
        finally:
            self.logger.info('Aufräumarbeiten abgeschlossen')

Zusammenfassung¶

Dieses Praxisbeispiel zeigt, wie Python-typisch Konfiguration, Logging und Fehlerbehandlung modular und idiomatisch kombiniert werden:

pathlib und dynamische Datenstrukturen erlauben flexible Konfigurationsverwaltung ohne viel Boilerplate.
Das logging-Modul ist zentraler Bestandteil für aussagekräftige Laufzeitinformationen.
Fehler werden gezielt mit spezifischen Exceptions behandelt, um robuste Anwendungen zu schreiben.

7. Fehlerbehandlung, Dateien und Datenformate¶

Exceptions verstehen¶

Das Exception-System von Python: Ein Überblick¶

Warum Python auf dynamische Exceptions setzt¶

Exception-Objekte und ihre Attribute¶

Kontrollfluss bei Exceptions¶

Python-Idiome im Umgang mit Exceptions¶

Merksatz¶

try, except, else und finally¶

Grundlagen des try-except-else-finally Blocks¶

Beispiel: API-Datenverarbeitung mit Fehlerbehandlung¶

Warum else?¶

Mehrere except-Blöcke und Exception-Filter¶

finally: Garantierte Ausführung¶

Ablaufdiagramm der Fehlerbehandlung¶

Best Practices¶

Vergleich zu Java und C¶

Merksatz¶

Die Exception-Hierarchie¶

Die Exception-Hierarchie in Python¶

Wesentliche Exception-Typen und ihre Bedeutung¶

Unterschiede zu Java und C¶

Best Practice: Spezifische Exceptions abfangen¶

Eigene Exceptions sinnvoll einordnen¶

Merksatz¶

Zusammenfassung¶

Exceptions mit raise auslösen¶

Exceptions mit raise auslösen¶

Grundlagen von raise¶

Eigene Exceptions mit raise erzeugen¶

raise mit Traceback: Fehler neu auslösen und anreichern¶

Best Practices für raise¶

Vergleich zu Java und C¶

Beispiel: API-Request mit raise¶

Mermaid-Diagramm: Exception-Fluss mit raise¶

Merksatz¶

Eigene Exceptions entwickeln¶

Warum eigene Exceptions?¶

Exception-Klassen definieren¶

Vergleich zu Java und C¶

Idiomatische Verwendung eigener Exceptions¶

Beispiel: API-Client mit eigenen Exceptions¶

Mermaid-Klassendiagramm zur Exception-Hierarchie¶

Best Practices¶

Merksatz¶

Einführung in Logging¶

Logging versus Debug-Ausgaben¶

Grundlegende Konzepte des Logging¶

Beispiel: Einfache Log-Nachricht¶

Vergleich zu Java und C# Logging¶

Best Practices¶

Merksatz¶

Das logging-Modul¶

Grundlagen des logging-Moduls¶

Log-Level und ihre Bedeutung¶

Einfache Verwendung¶

Erweiterte Logger-Konfiguration¶

Logger-Hierarchie und Vererbung¶

Best Practices und Python-spezifische Tipps¶

Vergleich zu Java und C¶

Zusammenfassung¶

Dateien lesen und schreiben¶

Dateien sicher öffnen: Kontextmanager und Encoding¶

Lesen großer Dateien: Iteration statt vollständiges Einlesen¶

Schreiben von Dateien: Modus und atomare Operationen¶

Beispiel: Logdatei rotieren¶

Unterschied zu Java und C¶

Häufige Fehler und Best Practices¶

Zusammenfassung¶

Mermaid-Diagramm: Ablauf beim sicheren Lesen einer Datei¶

Arbeiten mit pathlib¶

Grundlagen von pathlib¶

Path-Objekte erstellen und verwenden¶

Pfadabfragen und Dateisysteminteraktionen¶

Plattformunabhängigkeit und Typen¶

Ein typischer Workflow: Dateien suchen und lesen¶

Diagramm: Klassenhierarchie von pathlib¶

Best Practices und häufige Fehler¶

Vergleich zu Java und C¶

Merksatz¶

Warum `else`?¶

Exceptions mit `raise` auslösen¶

Grundlagen von `raise`¶

Eigene Exceptions mit `raise` erzeugen¶

`raise` mit Traceback: Fehler neu auslösen und anreichern¶

Best Practices für `raise`¶

Beispiel: API-Request mit `raise`¶

Mermaid-Diagramm: Exception-Fluss mit `raise`¶