Python None Optional: None-Werte sicher behandeln – einfach erklärt

Dein Skript bricht mit `TypeError: unsupported operand type(s) for +: 'int' and 'NoneType'` ab? Dann hat irgendwo eine Funktion `None` zurückgegeben - und dein Code hat damit gerechnet wie mit einer echten Zahl. Genau dieser Fehler trifft Azubis in der IHK-Projektprüfung genauso wie Studenten im ersten Semester und Berufseinsteiger im ersten Sprint. Die gute Nachricht: Mit ein paar klaren Regeln gehört er zu den leichtesten Fehlern, die du vermeiden kannst. Genau darum geht es bei Python None Optional - None verstehen, mit Optional dokumentieren und mit den richtigen Checks behandeln.

Was ist None in Python?

None ist Pythons festes Objekt für "kein Wert". Es existiert genau einmal pro laufendem Programm. Stell dir einen Parkplatz vor: Der Platz ist da - aber es steht kein Auto drauf.

Der Klassiker: Eine Funktion ohne `return` liefert automatisch `None`, auch wenn du das nie explizit hingeschrieben hast.

def begruessung(name):
    print("Hallo", name)


ergebnis = begruessung("Alex")
print(ergebnis)  # None, weil kein return vorhanden ist

Merke: None ist nicht 0, nicht `""` (leerer String) und nicht `False`. None heißt: Es gibt schlicht keinen Wert.

Python None Optional: Was bedeutet die Typannotation?

Optional ist eine Typannotation aus dem `typing`-Modul und bedeutet: "Dieser Wert kann vom Typ X sein - oder None." Seit Python 3.10 schreibst du dasselbe kürzer als `X | None` (offizielle typing-Dokumentation).

from typing import Optional


def finde_user(user_id: int) -> Optional[str]:
    # kann einen String ODER None zurueckgeben
    ...


# identische Bedeutung, ab Python 3.10:
def finde_user(user_id: int) -> str | None: ...

Wichtig zu wissen: Python prüft Annotationen zur Laufzeit nicht. Sie sind eine Zusage an Lesende und an Werkzeuge wie mypy, die deinen Code statisch überprüfen. Mehr dazu im Artikel zu Python Typannotationen und Generics.

Achtung, häufiges Missverständnis: `Optional[int]` bedeutet nicht, dass ein Argument weggelassen werden darf. Dafür gibt es Standardwerte (`def f(wert=0)`). Optional heißt nur: Der Wert ist int oder None.

Wie prüfst du korrekt auf None?

Geprüft wird immer mit `is None` beziehungsweise `is not None`. Warum `is` und nicht `==`? Weil es von `None` nur genau eine Instanz gibt - ein Identitätsvergleich passt also perfekt. Ein `==`-Vergleich könnte dagegen durch eine selbstgeschriebene `__eq__`-Methode manipuliert werden. Auch PEP 8, Pythons Stilrichtlinie, empfiehlt `is None` ausdrücklich.

Merke: Immer `is None` oder `is not None` - niemals `== None`.

# richtig
if ergebnis is None:
    print("Kein Wert vorhanden")

# funktioniert meist, ist aber schlechter Stil
if ergebnis == None:
    print("Kein Wert vorhanden")

`if x:` oder `if x is None:` - wo ist der Unterschied?

Kurz gesagt: `if x:` prüft den Wahrheitswert - und der ist für mehr als nur `None` "falsy". `if x is None:` prüft ausschließlich auf None. Auch `0`, `""`, `[]` und `{}` gelten als "falsy" (Wahrheitswerte in der Python-Doku).

Merke: Sind `0` oder `""` gültige Werte in deinem Programm, prüfe mit `is None`. Der Truthiness-Check würde sie fälschlich als "fehlend" einstufen - für die Einkommensteuer wäre ein Gehalt von 0 eben doch eine Angabe.

Wie behandelst du None-Werte sicher? Vier Techniken

1. Standardwert mit `or`:

name = liefer_name() or "Gast"

Vorsicht: Greift auch bei `""` oder `0` - nur nutzen, wenn das gewollt ist.

2. `dict.get()` mit Fallback - ideal beim Lookup in Dictionarys (Details im Artikel zum Python Dictionary):

email = benutzer.get("email", "keine@mail.de")

3. Bedingter Ausdruck:

anzeige = user.name if user is not None else "Unbekannt"

4. Early Return: Du prüfst den Problemfall zuerst und verlässt die Funktion sofort. Das hält den Rest der Funktion sauber.

Praxisbeispiel: Benutzersuche mit Optional

Ein vollständiges, lauffähiges Beispiel - eine Suche, die einen Treffer liefert oder `None`, plus eine Ausgabe-Funktion, die beides sauber behandelt:

from typing import Optional

benutzer = [
    {"id": 1, "name": "Anna", "email": "anna@example.org"},
    {"id": 2, "name": "Ben", "email": "ben@example.org"},
]


def finde_benutzer(user_id: int) -> Optional[dict]:
    for eintrag in benutzer:
        if eintrag["id"] == user_id:
            return eintrag
    return None  # nichts gefunden -> explizit None


def zeige_profil(user_id: int) -> None:
    user = finde_benutzer(user_id)
    if user is None:
        # Early Return: Problemfall zuerst abgehandelt
        print(f"Kein Benutzer mit ID {user_id} gefunden")
        return
    print(f"{user['name']} <{user['email']}>")


zeige_profil(1)  # Anna <anna@example.org>
zeige_profil(99)  # Kein Benutzer mit ID 99 gefunden

Beachte zwei Dinge: Das `return None` steht explizit da (auch wenn es wegfallen könnte - so sieht jeder sofort, dass `None` ein erlaubtes Ergebnis ist), und `zeige_profil` stürzt in keinem Fall ab.

Welche typischen Fehler passieren bei None?

Fehler 1: Vergessenes `return`. Ein Zweig deiner Funktion vergisst die Rückgabe, und `None` landet unbeabsichtigt in einer Variablen. Prüfe jede Funktion: Kommt aus jedem Pfad ein Wert?

Fehler 2: Operation auf möglichem None-Wert.

# falsch: Absturz, wenn die Suche nichts liefert
email = finde_benutzer(99)["email"]  # TypeError!

# richtig: erst pruefen, dann zugreifen
user = finde_benutzer(99)
if user is not None:
    email = user["email"]

Fehler 3: Truthiness-Falle bei 0 und leerem String.

# richtig: 0 bleibt ein gueltiger Wert
if bestellwert is not None:
    print(f"Bestellung: {bestellwert} Euro")

# Falle: 0 ist "falsy" und wuerde hier uebersprungen
# if bestellwert:
#   print(f"Bestellung: {bestellwert} Euro")

Übungstipp: Baue dir eine eigene None-Falle

Schreibe eine kleine Funktion `suche_produkt(name)` über eine Liste von Dicts, mit dem Rückgabetyp `dict | None`. Rufe sie einmal mit einem existierenden und einmal mit einem unsinnigen Namen auf - und behandle beide Fälle mit `is None` und Early Return. Danach installierst du mypy (`pip install mypy`) und lässt `mypy deine_datei.py` laufen. mypy zeigt dir sofort, wenn du einen `Optional`-Wert unbehandelt verwendest. Das dauert zehn Minuten und setzt das Muster dauerhaft fest.

FAQ: Häufige Fragen zu Python None Optional

Was ist der Unterschied zwischen None und null in Java/C#?

`None` ist ein echtes Objekt vom Typ `NoneType`. Statt einer `NullPointerException` bekommst du in Python einen `TypeError` oder `AttributeError` - die Ursache ist aber dieselbe: unbeabsichtigter Zugriff auf `None`.

Prüft Python Optional zur Laufzeit?

Nein. `Optional[int]` ist nur eine Annotation und wird vom Interpreter nicht erzwungen. Geprüft wird ausschließlich von statischen Analysetools wie mypy oder den Type-Checkern in PyCharm und VS Code.

Seit wann funktioniert die Schreibweise `int | None`?

Seit Python 3.10. In älteren Versionen musst du `Optional[int]` aus dem `typing`-Modul importieren - in älteren Codebasen begegnet dir das ständig.

Kann ich None als Wert in einem Dictionary speichern?

Ja, problemlos: `d = {"email": None}` ist erlaubt. Prüfe beim Auslesen aber mit `is None` und nicht mit Truthiness, sonst verwechselst du `None` mit leeren Strings oder 0.

Warum liefert meine Funktion None, obwohl ich nichts zurückgebe?

Weil Python das automatisch macht: Jede Funktion ohne `return` (oder mit nur `return` ohne Wert) gibt `None` zurück.

Fazit

`None` ist Pythons Art zu sagen "kein Wert vorhanden" - und `Optional` bzw. `X | None` ist die Typannotation, die genau das dokumentiert. Die drei Kernregeln: Prüfe mit `is None`, behandle den None-Fall mit Early Return, und nutze Truthiness-Checks nur, wenn `0` und `""` keine gültigen Werte sind. Wer Python None Optional verinnerlicht, produziert deutlich weniger Abstürze - und versteht fremden Code mit `Optional` sofort.

Wenn du bei Python, Prüfungsvorbereitung oder deinen ersten Berufsjahren Unterstützung brauchst: Schau dir study-it.education an. Dort bekommst du individuelle IT-Nachhilfe - ob du Azubi, Student oder Quereinsteiger bist.