Python Academy · Les

TypeVar, generieke klassen en Protocol

Definieer herbruikbare generieke typen en structurele subtypering met Protocol.

Les 3 van 413 stappen

TypeVar, generieke klassen en Protocol is een gratis Python Academy-les op CoddyKit. Dit is les 3 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Python Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Python Academy bevat in totaal 4 lessen.

Wat is TypeVar

TypeVar declareert een typevariabele — een tijdelijke aanduiding die elk type kan hebben en desgewenst kan worden beperkt. Je gebruikt deze in generieke functies en klassen.

from typing import TypeVar

T = TypeVar("T")

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

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

Generieke functies

Met een functie die TypeVar zowel in de parameter- als in het retourtype gebruikt, kan mypy het retourtype afleiden uit het type van het argument.

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

TypeVar met beperkingen

Geef typebeperkingen door aan TypeVar om te beperken welke typen zijn toegestaan.

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

Generieke klassen

Erf over van Generic[T] om een klasse te maken die is geparametriseerd met een typevariabele.

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

Meerdere TypeVars

Gebruik meerdere TypeVars om een klasse of functie te parametriseren voor twee onafhankelijke typen.

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 — structurele subtypering

Protocol definieert een interface aan de hand van de methoden en attributen die een klasse moet hebben, zonder expliciete overerving te vereisen ("duck typing, met typecontrole").

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 met runtime_checkable

Voeg @runtime_checkable toe aan een Protocol om isinstance()-controles tijdens de uitvoering mogelijk te maken.

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 versus ABC

ABCs vereisen expliciete overerving (class Dog(Animal)). Protocols werken via structurele overeenkomst: als een klasse de juiste methoden heeft, voldoet deze aan het protocol, ongeacht de overerving.

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 met bound

TypeVar("T", bound=BaseClass) beperkt T tot BaseClass of een van de subklassen ervan.

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()

Generieke alias — Python 3.12

Python 3.12 introduceert de instructie type voor overzichtelijke typealiassen en de syntaxis class Foo[T] voor generieke typen, zonder TypeVar te importeren.

# 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-type

Self (uit typing in 3.11+) annoteert methoden die de huidige klasse retourneren. Dit is nuttig in vloeiende interfaces en subklassen.

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"]

Korte controle

Wat is in Python typing het belangrijkste verschil tussen een Protocol en een ABC?

Beantwoord dit in de interactieve les

Samenvatting

TypeVar maakt tijdelijke aanduidingen voor typen in generieke functies en klassen. Generic[T] parametrizeert klassen. Protocol maakt structurele subtypering zonder overerving mogelijk. Gebruik bound= of typebeperkingen bij TypeVar om toegestane typen te beperken.

Gratis beginnen

Leer Python met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 76
Lessen: 320

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “TypeVar, generieke klassen en Protocol” gratis?

Ja — de volledige tekst van “TypeVar, generieke klassen en Protocol” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Python Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Python Academy bevat in totaal 4 lessen.

Wat leer ik in “TypeVar, generieke klassen en Protocol”?

Definieer herbruikbare generieke typen en structurele subtypering met Protocol. Je oefent met Python Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Python Academy te beginnen?

Ervaring vooraf is niet nodig. Python Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.

Hoe lang duurt de les “TypeVar, generieke klassen en Protocol”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Python Academy?

Ja. Elke les over Python Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

Basisprincipes van typeannotaties
Complexe typen: List, Dict, Optional, Union
TypeVar, generieke klassen en Protocol
mypy uitvoeren en typefouten oplossen

← Terug naar Python Academy