Type Hints in Python: Anleitung und Best Practices

Was sind Type Hints in Python?

Type Hints (Typannotationen) sind ein System zur Angabe erwarteter Datentypen im Python-Code. Sie steigern die Lesbarkeit, Zuverlässigkeit und Qualität von Software. Obwohl Python eine dynamisch typisierte Sprache bleibt, hilft die explizite Typangabe, viele Fehler bereits während der Entwicklung zu vermeiden.

Warum sind Typannotationen wichtig?

Python ist für seine Flexibilität bekannt, aber genau diese führt oft zu versteckten Fehlern durch unerwartete Datentypen. Betrachten wir ein Beispiel ohne Annotationen:

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

print(add(5, 10))    # 15
print(add("5", "10"))  # '510' — unerwartetes Ergebnis

Der Ausdruck add("5", "10") löst keinen Fehler aus, aber das Ergebnis kann für Entwickler überraschend sein.

Type Hints lösen folgende Aufgaben:

• Explizite Typangabe von Argumenten und Rückgabewerten
• Verbesserte Lesbarkeit des Codes für das Entwicklungsteam
• Statische Analyse zur Fehlersuche vor der Programmausführung
• Autovervollständigung in der IDE mit präziseren Vorschlägen
• API-Dokumentation ohne zusätzliche Kommentare

Grundlegende Beispiele für Type Hints

Funktionsannotationen

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

def calculate_area(radius: float) -> float:
    return 3.14159 * radius ** 2

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

Variablenannotationen

name: str = "Anna"
age: int = 30
pi: float = 3.14159
is_active: bool = True

Arbeit mit Sammlungen

from typing import List, Dict, Tuple, Set

def process_scores(scores: List[int]) -> float:
    return sum(scores) / len(scores)

def get_user_data() -> Dict[str, str]:
    return {"name": "Max", "email": "max@example.com"}

def get_coordinates() -> Tuple[float, float]:
    return (10.5, 20.3)

def unique_values(items: List[str]) -> Set[str]:
    return set(items)

Fortgeschrittene Type Hints

Optional und Union

from typing import Optional, Union

def greet(name: Optional[str] = None) -> str:
    if name:
        return f"Hallo, {name}!"
    return "Hallo, Gast!"

def process_value(value: Union[int, float, str]) -> str:
    return str(value)

# Ab Python 3.10 kann der | Operator verwendet werden
def process_new_syntax(value: int | float | str) -> str:
    return str(value)

Callable-Typen

from typing import Callable

def apply_function(func: Callable[[int, int], int], a: int, b: int) -> int:
    return func(a, b)

def multiply(x: int, y: int) -> int:
    return x * y

result = apply_function(multiply, 5, 3)  # 15

Generische Typen

from typing import TypeVar, Generic, List

T = TypeVar('T')

class Stack(Generic[T]):
    def __init__(self) -> None:
        self.items: List[T] = []
    
    def push(self, item: T) -> None:
        self.items.append(item)
    
    def pop(self) -> T:
        if not self.items:
            raise IndexError("Stack ist leer")
        return self.items.pop()
    
    def is_empty(self) -> bool:
        return len(self.items) == 0

# Verwendung
int_stack = Stack[int]()
int_stack.push(42)

Annotationen in Klassen

from typing import List, Optional
from dataclasses import dataclass

class Person:
    def __init__(self, name: str, age: int, email: Optional[str] = None) -> None:
        self.name = name
        self.age = age
        self.email = email

    def get_info(self) -> str:
        return f"{self.name}, {self.age} Jahre alt"

@dataclass
class Product:
    name: str
    price: float
    quantity: int = 0