Python Academy · Les

Complexe typen: List, Dict, Optional, Union

Gebruik generieke typen uit de module typing en Optional/Union op de juiste manier.

Les 2 van 413 stappen

Complexe typen: List, Dict, Optional, Union is een gratis Python Academy-les op CoddyKit. Dit is les 2 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.

Overzicht van de module typing

Vóór Python 3.9 kwamen generieke typen zoals List, Dict en Tuple uit typing. Sinds 3.9 kun je de ingebouwde typen rechtstreeks gebruiken.

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 en Sequence

Gebruik list[T] voor veranderbare reeksen en Sequence[T] wanneer je elke geordende reeks accepteert, zoals list, tuple of str.

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 en Mapping

Gebruik dict[K,V] voor veranderbare dicts en Mapping[K,V] voor alleen-lezen dict-achtige objecten.

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

Tuple-annotaties

Vaste lengte: tuple[int, str, float]. Variabele lengte: 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] is een verkorte schrijfwijze voor T | None. Dit is altijd de juiste keuze wanneer een parameter kan ontbreken.

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

Union[X, Y] of X | Y (3.10+) voor waarden die een van meerdere typen kunnen hebben.

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"] beperkt een waarde tot een specifieke verzameling letterlijke waarden.

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 annoteert de vorm van dicts waarbij elke sleutel aan een specifiek type wordt gekoppeld.

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 en FrozenSet

Annoteer verzamelingen met set[T] en onveranderbare verzamelingen met frozenset[T].

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

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

Iterable en Iterator

Gebruik Iterable[T] voor elk object waarover je kunt itereren en Iterator[T] voor objecten met __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 en NoReturn

Any schakelt de typecontrole voor een waarde uit. NoReturn markeert functies die nooit terugkeren: ze werpen altijd een uitzondering of blijven oneindig lang lussen.

from typing import Any, NoReturn

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

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

Korte controle

Wat betekent Optional[str]?

Beantwoord dit in de interactieve les

Samenvatting

Gebruik list[T], dict[K,V] en tuple[T,...] voor verzamelingen. Optional[T] = T | None. Gebruik Union[X,Y] of X|Y voor meerdere typen. Gebruik Literal voor specifieke waarden, TypedDict voor getypeerde dict-vormen en Any om typecontrole uit te schakelen.

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 “Complexe typen: List, Dict, Optional, Union” gratis?

Ja — de volledige tekst van “Complexe typen: List, Dict, Optional, Union” 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 “Complexe typen: List, Dict, Optional, Union”?

Gebruik generieke typen uit de module typing en Optional/Union op de juiste manier. 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 2 van 4.

Hoe lang duurt de les “Complexe typen: List, Dict, Optional, Union”?

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