Type Hints in Python: Typsicherheit ohne Compiler

Python ist eine dynamisch typisierte Sprache. Das bedeutet, du musst nicht angeben, ob eine Variable eine Zahl oder ein Text ist. Das ist bequem, kann aber bei größeren Projekten zu Verwirrung und Fehlern führen. Seit Python 3.5 gibt es deshalb Type Hints, also Typ-Annotationen. Sie machen deinen Code klarer, ohne ihn langsamer zu machen. In diesem Beitrag schauen wir uns an, wie und warum du sie nutzen solltest.

Was Type Hints sind und was nicht

Type Hints sind Hinweise, keine festen Regeln. Python prüft sie zur Laufzeit nicht und zwingt dich zu nichts. Sie dienen dem Menschen, der den Code liest, und Werkzeugen, die ihn analysieren.

# Ohne Type Hint
name = "Anna"

# Mit Type Hint
name: str = "Anna"
alter: int = 30
groesse: float = 1.75
aktiv: bool = True

Der Doppelpunkt nach dem Variablennamen kennzeichnet den erwarteten Typ. Diese Information macht sofort klar, was in der Variable stecken soll.

Funktionen annotieren

Am nützlichsten sind Type Hints bei Funktionen. Du gibst die Typen der Parameter an und mit einem Pfeil -> den Typ des Rückgabewerts. So sieht jeder sofort, womit die Funktion arbeitet.

def begruesse(name: str, anzahl: int) -> str:
    return f"Hallo {name}! " * anzahl

print(begruesse("Ben", 2))  # Hallo Ben! Hallo Ben!

Die Signatur begruesse(name: str, anzahl: int) -> str liest sich fast wie eine Dokumentation: zwei Eingaben mit klaren Typen und ein String als Ergebnis.

Komplexere Typen mit Listen und Dictionaries

Auch zusammengesetzte Typen lassen sich annotieren. Seit Python 3.9 kannst du dafür direkt die eingebauten Typen wie list und dict verwenden und in eckigen Klammern den Inhaltstyp angeben.

def durchschnitt(zahlen: list[float]) -> float:
    return sum(zahlen) / len(zahlen)

def zaehle_woerter(text: str) -> dict[str, int]:
    ergebnis: dict[str, int] = {}
    for wort in text.split():
        ergebnis[wort] = ergebnis.get(wort, 0) + 1
    return ergebnis

print(durchschnitt([1.0, 2.0, 3.0]))  # 2.0

So ist auf einen Blick klar, dass durchschnitt eine Liste von Fließkommazahlen erwartet und eine einzelne Zahl zurückgibt.

Optionale Werte und mehrere Typen

Manchmal kann ein Wert auch None sein oder einer von mehreren Typen. Dafür gibt es das Modul typing mit Optional und Union. Ab Python 3.10 kannst du auch die kurze Schreibweise mit dem senkrechten Strich nutzen.

from typing import Optional

def finde_nutzer(id: int) -> Optional[str]:
    nutzer = {1: "Anna", 2: "Ben"}
    return nutzer.get(id)  # gibt None zurück, wenn die id fehlt

# Kurzschreibweise ab Python 3.10
def laenge(wert: str | list) -> int:
    return len(wert)

Optional[str] bedeutet "ein String oder None". Die Schreibweise str | list bedeutet "entweder ein String oder eine Liste".

Typen mit mypy prüfen

Da Python die Hints selbst nicht prüft, brauchst du dafür ein zusätzliches Werkzeug. Das bekannteste ist mypy. Es analysiert deinen Code und meldet Stellen, an denen die Typen nicht zusammenpassen.

pip install mypy
mypy mein_programm.py

def addiere(a: int, b: int) -> int:
    return a + b

# mypy meldet hier einen Fehler, da "drei" kein int ist
ergebnis = addiere(1, "drei")

So findest du Tippfehler und falsche Annahmen schon vor dem Ausführen. mypy lässt sich gut in den Editor und in automatische Prüfungen einbinden.

Fazit

Type Hints kosten dich nur wenig zusätzliche Schreibarbeit, bringen aber viel: Dein Code wird lesbarer, dein Editor kann dir besser helfen, und Werkzeuge wie mypy finden Fehler, bevor sie zum Problem werden. Du hast gesehen, wie du Variablen, Funktionen und zusammengesetzte Typen annotierst und wie du optionale Werte abbildest. Mein Tipp: Fang bei deinen Funktionssignaturen an, denn dort ist der Nutzen am größten. Mit der Zeit wirst du Type Hints nicht mehr missen wollen.