0Pricing
Python Academy · Lektion

Komplexe Typen: List, Dict, Optional, Union

Verwenden Sie Generics des typing-Moduls sowie Optional und Union korrekt.

Komplexe Typen: List, Dict, Optional, Union ist eine kostenlose Python Academy-Lektion auf CoddyKit. Dies ist Lektion 2 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.

Überblick über das Modul typing

Vor Python 3.9 stammten generische Typen wie List, Dict und Tuple aus typing. Seit 3.9 können Sie direkt die eingebauten Typen verwenden.

from typing import List, Dict, Tuple, Optional, Union

# Python 3.9+: use list[int], dict[str,int] directly
# Python 3.8-: use typing.List[int], typing.Dict[str,int]

List und Sequence

Verwenden Sie list[T] für veränderbare Sequenzen und Sequence[T], wenn Sie jede geordnete Sequenz akzeptieren (Liste, Tupel oder String).

from typing import Sequence

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

def first(items: Sequence[str]) -> str:
    return items[0]   # works with list, tuple, str

Dict und Mapping

Verwenden Sie dict[K,V] für veränderbare Dicts und Mapping[K,V] für schreibgeschützte, dict-ähnliche Objekte.

from typing import Mapping

def lookup(data: Mapping[str, int], key: str) -> int | None:
    return data.get(key)

result = lookup({"a": 1, "b": 2}, "a")
print(result)   # 1

Tupel-Annotationen

Feste Länge: tuple[int, str, float]. Variable Länge: tuple[int, ...].

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

def first_n(n: int) -> tuple[int, ...]:
    return tuple(range(n))

# Named tuple with types:
from typing import NamedTuple
class Point(NamedTuple):
    x: float
    y: float

Optional[T]

Optional[T] ist die Kurzform für T | None. Dies ist immer die richtige Wahl, wenn ein Parameter fehlen kann.

from typing import Optional

def find_user(user_id: int) -> Optional[dict[str, str]]:
    db: dict[int, dict[str, str]] = {
        1: {"name": "Alice"}
    }
    return db.get(user_id)

Union-Typen

Verwenden Sie Union[X, Y] oder X | Y (3.10+) für Werte, die einer von mehreren Typen sein können.

from typing import Union

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

# Python 3.10+:
def stringify2(value: int | float | str) -> str:
    return str(value)

Literal-Typen

Literal["a","b","c"] beschränkt einen Wert auf eine bestimmte Menge von Literalen.

from typing import Literal

Mode = Literal["read", "write", "append"]

def open_file(path: str, mode: Mode) -> None:
    with open(path, mode):
        pass

open_file("data.txt", "read")    # ok
# open_file("data.txt", "exec")  # mypy error

TypedDict

TypedDict annotiert die Struktur von Dicts, bei denen jeder Schlüssel einem bestimmten Typ zugeordnet ist.

from typing import TypedDict

class User(TypedDict):
    name: str
    age: int
    email: str | None

def greet(user: User) -> str:
    return f"Hello, {user['name']}"

alice: User = {"name": "Alice", "age": 30, "email": None}

Set und FrozenSet

Annotieren Sie Mengen mit set[T] und unveränderliche Mengen mit frozenset[T].

def unique(items: list[int]) -> set[int]:
    return set(items)

def allowed_methods() -> frozenset[str]:
    return frozenset({"GET", "POST", "DELETE"})

Iterable und Iterator

Verwenden Sie Iterable[T] für jedes Objekt, das Sie durchlaufen können, und Iterator[T] für Objekte mit __next__.

from typing import Iterable, Iterator

def evens(numbers: Iterable[int]) -> Iterator[int]:
    return (n for n in numbers if n % 2 == 0)

for n in evens([1, 2, 3, 4, 5]):
    print(n)   # 2 4

Any und NoReturn

Any deaktiviert die Typprüfung für einen Wert. NoReturn kennzeichnet Funktionen, die nie zurückkehren (sie lösen immer eine Ausnahme aus oder laufen endlos).

from typing import Any, NoReturn

def accept_all(x: Any) -> None:
    print(x)

def crash(msg: str) -> NoReturn:
    raise RuntimeError(msg)   # never returns normally

Kurzer Test

Was bedeutet Optional[str]?

Zusammenfassung

Verwenden Sie list[T], dict[K,V] und tuple[T,...] für Collections. Optional[T] = T | None. Union[X,Y] oder X|Y für mehrere Typen. Literal für bestimmte Werte, TypedDict für typisierte Dict-Strukturen und Any zum Deaktivieren der Typprüfung.

Häufig gestellte Fragen

Ist die Lektion „Komplexe Typen: List, Dict, Optional, Union“ kostenlos?

Ja — der vollständige Text von „Komplexe Typen: List, Dict, Optional, Union“ 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 „Komplexe Typen: List, Dict, Optional, Union“?

Verwenden Sie Generics des typing-Moduls sowie Optional und Union korrekt. 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 2 von 4.

Wie lange dauert die Lektion „Komplexe Typen: List, Dict, Optional, Union“?

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

  1. Grundlegende Typannotationen
  2. Komplexe Typen: List, Dict, Optional, Union
  3. TypeVar, generische Klassen und Protocol
  4. mypy ausführen und Typfehler beheben
← Zurück zu Python Academy