Wofür braucht man das?

Python ist eine dynamisch typisierte Sprache: Eine Variable kann alles Mögliche enthalten, und du siehst es dem Code nicht an.

1
2

def berechne(a, b):
    return a * b

Was ist a? Eine Zahl? Ein Text? Beides funktioniert – 3 * 4 ergibt 12, aber "ab" * 3 ergibt "ababab". Wer diese Funktion benutzt, muss raten oder den Code lesen.

Mit Type Hints schreibst du die Antwort direkt hin:

1
2

def berechne(a: float, b: float) -> float:
    return a * b

Gelesen: nimmt zwei Kommazahlen, gibt eine Kommazahl zurück.

Der Nutzen:

1
2
3
4

def gruss(name: str) -> str:
    return "Hallo " + name

print(gruss(42))  # Python startet – und stürzt erst bei "+" ab

Die Syntax

Variablen

Doppelpunkt hinter den Namen, dann der Typ.

1
2
3
4

name: str = "Alice"
alter: int = 30
groesse: float = 1.75
ist_schueler: bool = True

Bei so einfachen Fällen lässt man die Angabe meist weg – Python sieht ja selbst, dass "Alice" ein String ist. Richtig nützlich werden Type Hints bei Funktionen.

Funktionen

Typ hinter jedem Parameter, Rückgabetyp hinter dem Pfeil ->.

1
2
3
4
5

def gruss(name: str) -> str:
    return f"Hallo, {name}!"

def flaeche(laenge: float, breite: float) -> float:
    return laenge * breite

Funktionen ohne return bekommen -> None (“gibt nichts zurück”):

1
2

def zeige_info(name: str, alter: int) -> None:
    print(f"{name} ist {alter} Jahre alt.")

Listen und Dictionaries

In den eckigen Klammern steht, was drin ist.

1
2
3
4
5
6

zahlen: list[int] = [1, 2, 3, 4, 5]
namen: list[str] = ["Ali", "Beyza", "Tom"]
noten: dict[str, int] = {"Mathe": 12, "Deutsch": 9}

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

Mehrere Typen erlauben

Der senkrechte Strich | bedeutet “oder” (ab Python 3.10):

1
2

def zu_text(wert: int | str) -> str:
    return str(wert)

Häufigster Fall: Etwas ist da – oder eben None.

1
2
3
4

def finde_namen(id: int) -> str | None:
    if id == 1:
        return "Alice"
    return None  # nichts gefunden

Bezug zu UML-Klassendiagrammen

Bevor man objektorientiert programmiert, plant man mit einem UML-Klassendiagramm. Dort notiert man für jedes Attribut und jede Methode den Datentyp – genau die Information, die Type Hints im Code festhalten. Ohne Type Hints geht diese Information beim Übersetzen ins Programm verloren.

    classDiagram
    class Rechteck {
        -laenge: float
        -breite: float
        +flaeche() float
        +skaliere(faktor: float)
    }
  

Die Übersetzung ist fast Zeichen für Zeichen dieselbe:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

class Rechteck:
    def __init__(self, laenge: float, breite: float) -> None:
        self.laenge: float = laenge
        self.breite: float = breite

    def flaeche(self) -> float:
        return self.laenge * self.breite

    def skaliere(self, faktor: float) -> None:
        self.laenge = self.laenge * faktor
        self.breite = self.breite * faktor

Das funktioniert auch rückwärts: Aus getyptem Code kannst du das Diagramm direkt ablesen, aus untypisiertem Code musst du raten. Mehr dazu in OOP – UML-Klassendiagramm.

Aufgaben

1
2
3
4
5
6
7
8

def addiere(a, b):
    return a + b

def begruesse(name):
    print("Hallo " + name)

def groesste_zahl(zahlen):
    return max(zahlen)

1

def zaehle_woerter(text: str) -> dict[str, int]:

    classDiagram
    class Schueler {
        -name: str
        -noten: list~int~
        +note_hinzufuegen(note: int)
        +durchschnitt() float
        +ist_versetzt() bool
    }
  

1
2
3
4

def verdopple(zahl: int) -> int:
    return zahl * 2

print(verdopple("Hi"))

Fazit

• Type Hints sagen, welche Daten rein- und rausgehen.
• Sie machen Code lesbar, ermöglichen Editor-Warnungen und ersparen Kommentare.
• Python prüft sie nicht zur Laufzeit – Editor oder mypy tun das.
• Sie sind die Code-Entsprechung der Typangaben im UML-Klassendiagramm.