Python Academy · Lektion

Grundlegende Typannotationen

Annotieren Sie Variablen, Funktionsparameter und Rückgabetypen.

Grundlegende Typannotationen ist eine kostenlose Python Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Python Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Python Academy-Kurs umfasst insgesamt 4 Lektionen.

Was sind Typannotationen

Typannotationen sind Hinweise, die den erwarteten Typ von Variablen, Parametern und Rückgabewerten angeben. Sie werden zur Laufzeit nicht erzwungen, sondern von Typprüfern wie mypy gelesen.

def greet(name: str) -> str:
    return f"Hello, {name}"

result: str = greet("Alice")
print(result)

Variablenannotationen

Annotieren Sie Variablen auf Modul- oder Klassenebene sowie lokale Variablen mit einem Doppelpunkt, gefolgt vom Typ.

count: int = 0
pi: float = 3.14159
name: str = "Python"
flag: bool = True

# Annotation without assignment (declaration only)
future_value: int

Funktionsparameter annotieren

Annotieren Sie jeden Parameter in der Funktionssignatur. Verwenden Sie -> type, um den Rückgabetyp zu annotieren.

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

def repeat(text: str, times: int = 1) -> str:
    return text * times

def no_return() -> None:
    print("side effect only")

Eingebaute Collection-Typen (Python 3.9+)

Verwenden Sie ab Python 3.9 eingebaute Typen in Kleinbuchstaben direkt als Generics: list[int], dict[str, int], tuple[int, ...].

def total(numbers: list[int]) -> int:
    return sum(numbers)

def config() -> dict[str, str]:
    return {"host": "localhost", "port": "8080"}

def coords() -> tuple[float, float]:
    return (1.0, 2.0)

Optional und Union

X | None (Python 3.10+) oder Optional[X] bedeutet, dass ein Wert X oder None sein kann. X | Y bedeutet X oder Y.

from typing import Optional

def find(items: list[int], target: int) -> int | None:
    return next((x for x in items if x == target), None)

# Older style:
# def find(...) -> Optional[int]:

Union-Typen

int | str (Python 3.10+) oder Union[int, str] annotiert einen Wert, der einer von mehreren Typen sein kann.

from typing import Union

def process(value: int | str) -> str:
    return str(value)

# Older style:
# def process(value: Union[int, str]) -> str:

Typ-Aliase

Weisen Sie einem Namen einen Ty-Ausdruck zu, um einen wiederverwendbaren Alias zu erstellen und die Lesbarkeit zu verbessern.

from typing import TypeAlias

Vector: TypeAlias = list[float]
Matrix: TypeAlias = list[Vector]

def dot(a: Vector, b: Vector) -> float:
    return sum(x * y for x, y in zip(a, b))

Callable-Annotationen

Verwenden Sie Callable[[arg_types], return_type], um Funktionen zu annotieren, die als Argumente übergeben werden.

from typing import Callable

def apply(func: Callable[[int, int], int], x: int, y: int) -> int:
    return func(x, y)

result = apply(lambda a, b: a + b, 3, 4)
print(result)  # 7

*args und **kwargs annotieren

Annotieren Sie *args mit dem Elementtyp (nicht mit einem Tupel) und **kwargs mit dem Werttyp.

def log(*messages: str, level: str = "INFO") -> None:
    for msg in messages:
        print(f"[{level}] {msg}")

def configure(**options: int) -> None:
    for key, val in options.items():
        print(f"{key}: {val}")

from future import annotations

Fügen Sie diesen Import am Anfang der Datei ein, um die verzögerte Auswertung von Annotationen zu aktivieren. Dadurch sind Vorwärtsreferenzen ohne Anführungszeichen möglich.

from __future__ import annotations

class Node:
    def __init__(self, value: int, next: Node | None = None):
        self.value = value
        self.next = next   # forward ref to Node works here

TYPE_CHECKING-Schutz

Importieren Sie Typen nur während der Typprüfung, nicht zur Laufzeit, um zirkuläre oder umfangreiche Importe zu vermeiden.

from __future__ import annotations
from typing import TYPE_CHECKING

if TYPE_CHECKING:
    from mymodule import HeavyClass

def process(obj: HeavyClass) -> None:
    ...   # HeavyClass not imported at runtime

Kurzer Test

Welche Annotationssyntax kennzeichnet eine Funktion, die nichts zurückgibt?

Zusammenfassung

Annotieren Sie Variablen mit name: Type, Parameter mit param: Type und Rückgabewerte mit -> Type. Verwenden Sie list[T], dict[K,V] (Python 3.9+), X | None (3.10+) und from __future__ import annotations für Vorwärtsreferenzen.

Häufig gestellte Fragen

Ist die Lektion „Grundlegende Typannotationen“ kostenlos?

Ja — der vollständige Text von „Grundlegende Typannotationen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Python Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Python Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Grundlegende Typannotationen“?

Annotieren Sie Variablen, Funktionsparameter und Rückgabetypen. Du übst Python Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Python Academy zu starten?

Keine Vorkenntnisse erforderlich. Python Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Grundlegende Typannotationen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Python Academy-Lektion Code schreiben und ausführen?

Ja. Jede Python Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

Grundlegende Typannotationen
Komplexe Typen: List, Dict, Optional, Union
TypeVar, generische Klassen und Protocol
mypy ausführen und Typfehler beheben

← Zurück zu Python Academy