0Pricing
Python Academy · Lektion

TypeVar, generische Klassen und Protocol

Definieren Sie wiederverwendbare generische Typen und strukturelle Subtypisierung mit Protocol.

TypeVar, generische Klassen und Protocol ist eine kostenlose Python Academy-Lektion auf CoddyKit. Dies ist Lektion 3 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 ist TypeVar

TypeVar deklariert eine Typvariable – einen Platzhalter, der jeden Typ annehmen kann und bei Bedarf eingeschränkt wird. Sie wird in generischen Funktionen und Klassen verwendet.

from typing import TypeVar

T = TypeVar("T")

def identity(value: T) -> T:
    return value

print(identity(42))      # int
print(identity("hello")) # str

Generische Funktionen

Eine Funktion, die TypeVar sowohl in Parameter- als auch Rückgabetypen verwendet, ermöglicht es mypy, den Rückgabetyp aus dem Argumenttyp abzuleiten.

from typing import TypeVar

T = TypeVar("T")

def first(items: list[T]) -> T:
    return items[0]

x: int = first([1, 2, 3])     # mypy knows x is int
s: str = first(["a","b","c"]) # mypy knows s is str

Eingeschränkte TypeVar

Übergeben Sie TypeVar Typbeschränkungen, um die zulässigen Typen einzuschränken.

from typing import TypeVar

Numeric = TypeVar("Numeric", int, float)

def double(n: Numeric) -> Numeric:
    return n * 2

print(double(5))    # 10
print(double(2.5))  # 5.0
# double("x")  # mypy error

Generische Klassen

Erben Sie von Generic[T], um eine Klasse zu erstellen, die durch eine Typvariable parametrisiert wird.

from typing import Generic, TypeVar

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:
        return self._items.pop()

stack: Stack[int] = Stack()
stack.push(1)
print(stack.pop())   # 1

Mehrere TypeVars

Verwenden Sie mehrere TypeVars, um eine Klasse oder Funktion über zwei unabhängige Typen zu parametrisieren.

from typing import Generic, TypeVar

K = TypeVar("K")
V = TypeVar("V")

class Pair(Generic[K, V]):
    def __init__(self, key: K, value: V) -> None:
        self.key = key
        self.value = value

p: Pair[str, int] = Pair("age", 30)
print(p.key, p.value)   # age 30

Protocol — Strukturelles Subtyping

Protocol definiert eine Schnittstelle anhand der Methoden und Attribute, die eine Klasse besitzen muss, ohne explizite Vererbung zu verlangen ("Duck-Typing, typgeprüft").

from typing import Protocol

class Drawable(Protocol):
    def draw(self) -> None: ...

def render(obj: Drawable) -> None:
    obj.draw()

class Circle:
    def draw(self) -> None:
        print("Drawing circle")

render(Circle())   # works — Circle satisfies Drawable

Protocol mit runtime_checkable

Fügen Sie @runtime_checkable zu einem Protocol hinzu, um isinstance()-Prüfungen zur Laufzeit zu ermöglichen.

from typing import Protocol, runtime_checkable

@runtime_checkable
class Closeable(Protocol):
    def close(self) -> None: ...

class File:
    def close(self) -> None: print("closed")

print(isinstance(File(), Closeable))   # True

Protocol im Vergleich zu ABC

ABCs erfordern explizite Vererbung (class Dog(Animal)). Protocols basieren auf struktureller Übereinstimmung: Wenn eine Klasse die richtigen Methoden besitzt, erfüllt sie das Protocol unabhängig von ihrer Vererbung.

from typing import Protocol
from abc import ABC, abstractmethod

# ABC: nominal typing
class Printable(ABC):
    @abstractmethod
    def display(self) -> None: ...

# Protocol: structural typing
class Displayable(Protocol):
    def display(self) -> None: ...

TypeVar mit bound

TypeVar("T", bound=BaseClass) beschränkt T auf BaseClass oder eine ihrer Unterklassen.

from typing import TypeVar

class Animal:
    def speak(self) -> str: return "..."

A = TypeVar("A", bound=Animal)

def make_speak(animal: A) -> str:
    return animal.speak()

Generischer Alias — Python 3.12

Python 3.12 führt die type-Anweisung für übersichtliche Typ-Aliase sowie die class Foo[T]-Syntax für Generics ein, ohne TypeVar importieren zu müssen.

# Python 3.12+
type Vector = list[float]
type Matrix = list[Vector]

class Stack[T]:
    def __init__(self) -> None: self._items: list[T] = []
    def push(self, item: T) -> None: self._items.append(item)
    def pop(self) -> T: return self._items.pop()

Self-Typ

Self (ab 3.11 aus typing) annotiert Methoden, die die aktuelle Klasse zurückgeben – nützlich bei Fluent Interfaces und Unterklassen.

from typing import Self

class Builder:
    def __init__(self) -> None:
        self.parts: list[str] = []

    def add(self, part: str) -> Self:
        self.parts.append(part)
        return self

b = Builder().add("a").add("b")
print(b.parts)   # ["a", "b"]

Kurzer Test

Was ist der entscheidende Unterschied zwischen einem Protocol und einer ABC bei der Python-Typisierung?

Zusammenfassung

TypeVar erstellt Typplatzhalter für generische Funktionen und Klassen. Generic[T] parametrisiert Klassen. Protocol ermöglicht strukturelles Subtyping ohne Vererbung. Verwenden Sie bound= oder Typbeschränkungen bei TypeVar, um zulässige Typen einzuschränken.

Häufig gestellte Fragen

Ist die Lektion „TypeVar, generische Klassen und Protocol“ kostenlos?

Ja — der vollständige Text von „TypeVar, generische Klassen und Protocol“ 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 „TypeVar, generische Klassen und Protocol“?

Definieren Sie wiederverwendbare generische Typen und strukturelle Subtypisierung mit Protocol. 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 3 von 4.

Wie lange dauert die Lektion „TypeVar, generische Klassen und Protocol“?

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