Antwoord

Geschiedenis

Functie-annotaties zijn geïntroduceerd in Python 3.0, en het type hints mechanisme is beschreven in PEP 484, toegevoegd met 3.5. Dit hulpmiddel is ontworpen voor statische code-analyse, autocompletering en het verbeteren van de leesbaarheid — de standaard typing bibliotheek maakt het mogelijk om expliciet de verwachte types van variabelen, argumenten en teruggegeven waarden van functies aan te geven.

Probleem

Python is een dynamische taal, waar de types van variabelen in de loop van de uitvoering kunnen veranderen, wat kan leiden tot fouten die alleen tijdens de uitvoering van het programma optreden. Annotaties beïnvloeden de uitvoering van de code niet, maar bij verkeerd gebruik krijgen programmeurs een valse indruk van 'strikte typing'.

Oplossing

Type-annotaties worden gebruikt voor documentatie, automatische controle met behulp van mypy, pylance, pyright en soortgelijke tools, evenals voor integratie in IDE's. Ze worden geïmplementeerd via een dubbele punt na de naam van het argument en een pijl na de lijst van parameters:**

def greet(name: str, times: int = 1) -> None:
    for _ in range(times):
        print(f"Hallo, {name}!")

# Correcte annotatie voor een functie die een woordenboek verwerkt
from typing import Dict, List

def transform(data: Dict[str, List[int]]) -> float:
    return sum(sum(lst) for lst in data.values()) / 10

Belangrijkste kenmerken:

Annotaties worden niet gecontroleerd door de interpreter, ze blijven bestaan tijdens de uitvoering van de code, maar veranderen de uitvoering op geen enkele manier
Ze zijn relevant voor grote projecten, waar het belangrijk is om interfaces en de interactie van componenten te begrijpen
Voor complexe constructies zijn typing.List, typing.Dict, typing.Optional, typing.Union, enz. nodig.

Vragen met een valkuil.

Kan Python 'automatisch' controleren of types overeenkomen met de annotaties?

Nee! Typecontrole gebeurt alleen met externe statische analysetools, zoals mypy. Tijdens runtime negeert Python volledig de inhoud van annotaties.

def f(x: int):
    return x * 2

print(f('oops'))  # Type str, er zal geen fout zijn!

Waar worden annotaties opgeslagen en hoe kunnen ze tijdens runtime worden verkregen, waarom kan dit nodig zijn?

Ze worden opgeslagen in een speciale attribuut annotations:

def add(x: int, y: int) -> int:
    return x + y

print(add.__annotations__)  # {'x': <class 'int'>, 'y': <class 'int'>, 'return': <class 'int'>}

Dit wordt gebruikt door externe bibliotheken voor gegevensvalidatie, autogeneratie van documentatie, serialisatie, enz.

Kan elke variabele worden geannoteerd, alleen functies, wat zal er in de globale ruimte gebeuren?

Je kunt zowel lokale als globale variabelen annoteren met een dubbele punt, dit beïnvloedt ook de uitvoering niet:

index: int = 0

def func(x: 'User') -> None:
    ...

Typefouten en antipatterns

Denken dat type hints deel uitmaken van strikte typing en strikte typecontrole
Vergeten dat standaardwaarden compatibel moeten zijn met het aangegeven type (hoewel dit niet wordt gecontroleerd tijdens de uitvoering)
Onjuist gebruik van complexe types uit typing (bijvoorbeeld, List<int> in plaats van List[int])

Voorbeeld uit het leven

Negatieve casus

In een bedrijfsproject begonnen alle ontwikkelaars actief annotaties te gebruiken, terwijl de werkelijke types van functieargumenten vaak niet overeenkwamen met de opgegeven types. Python negeerde deze fouten, en onverwachte bugs verschenen alleen diep in de businesslogica. Er was geen configuratie voor mypy.

Voordelen:

Verbetering van autocompletering en documentatie

Nadelen:

Er bleven impliciete fouten bestaan, die de oorzaak ver van de annotatie leidden.

Positieve casus

Het gebruik van type hints en de verplichte uitvoering van mypy in CI, evenals de autogeneratie van documentatie via annotations: