Antwoord

Historie van de vraag: Type hints zijn geïntroduceerd in Python 3.5 (PEP 484) ter ondersteuning van statische code-analyse, autocompleting, refactoring en autodocumentatie. Eerder kwam Python zonder strenge typing goed vooruit, maar met de groei van projecten en teams zijn ze nodig geworden om de kwaliteit van de code te verbeteren.

Probleem: Type annotaties zijn slechts aanwijzingen voor ontwikkelaars en externe tools (mypy, Pyright, enz.), de interpreter negeert ze tijdens de uitvoering. Fouten ontstaan vaak als:

• De annotaties incorrect zijn of niet overeenkomen met de werkelijke types
• De annotaties breken bij dynamische type verandering
• Fouten optreden bij complexe structuren met Generics (bijvoorbeeld, List[Dict[str, int]])

Oplossing: Gebruik type annotaties voor functies en variabelen voor betere leesbaarheid, analyse door linters en IDE's. Vertrouw niet uitsluitend op annotaties — een statische typechecker is nodig. Voorbeeld:

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

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

Complexere voorbeelden maken gebruik van de typing-module:

from typing import List, Dict, Optional

def process(data: List[Dict[str, Optional[int]]]) -> None:
    ...

Belangrijkste kenmerken:

• Annotaties beïnvloeden de gedraging van de code niet tijdens runtime
• Combineer altijd type hints met een externe analyser
• Voor complexe structuren, gebruik typing.

Vragen met een valstrik.

Verwerkt de Python-interpreter types uit annotaties tijdens de uitvoering?

Nee. Annotaties zijn beschikbaar via __annotations__, maar beheersen het gedrag niet tijdens de uitvoering.

Kun je variabelen zonder annotaties gebruiken in geannoteerde functies?

Ja. Annotaties zijn niet verplicht, maar hun afwezigheid kan verwarrend zijn.

Kun je het type van een variabele na annotatie opnieuw definiëren?

Ja, maar dit schendt de essentie van statische analyse en kan linters hinderen. Vermijd dit liever:

x: int = 5
x = 'string'  # Linter zal klagen, maar de code zal uitgevoerd worden.

Typefouten en antipatterns

• Onverenigbaarheid tussen het geïmplementeerde type en de waarde uit de annotatie
• Geen gebruik maken van een externe analyser (linters, mypy)
• Te ingewikkelde of overbodige type hints die het lezen bemoeilijken

Voorbeeld uit de praktijk

Negatieve case: Een functie wordt geannoteerd, maar de daadwerkelijk teruggegeven type is anders dan dat in de annotatie door een wijziging in de logica van de functie. Voordelen:

• De code draait Nadelen:
• Het is eenvoudig om een bug te krijgen die moeilijk te testen en op te sporen is

Positieve case: Alle functies en gegevens zijn geannoteerd, het project wordt gecontroleerd door mypy tijdens CI/CD. Voordelen:

• Hoge onderhoudbaarheid en leesbaarheid van de code Nadelen:
• Vereist tijd voor implementatie en training van het team