CKTIS / Python
Voorwaartse verwijzingen in typeannotaties
Zet in Python 3.12 een typenaam tussen aanhalingstekens als die bij het definiëren van een methode nog niet beschikbaar is. Los de verwijzing later op als je het klasseobject nodig hebt.
Versie: Python 3.12
Syntax
# Quote a name that is not bound yet:
def f(value: "Later") -> "Later": ...
# For a union, quote the entire expression:
def g(value: "int | Later") -> None: ...
# Alternatively, as a separate module using postponed evaluation:
from __future__ import annotations
def f(value: Later) -> Later: ...Een voorwaartse verwijzing in een typeannotatie verwijst naar een type waarvan de naam nog niet beschikbaar is op de plek waar je de functie definieert. In Python 3.12 worden functieannotaties zonder uitstel geëvalueerd bij het uitvoeren van def, niet wanneer je de functie aanroept. Is de typenaam dan niet beschikbaar, dan geeft die naam zonder aanhalingstekens een NameError. Annotaties helpen bij statische typecontrole; Python zelf controleert er geen argumenten of retourwaarden mee.
In WorkItem.from_dict verwijst -> "WorkItem" naar de klasse waarvan de body nog wordt uitgevoerd. In Project.add_module verwijst module: "Module" naar een klasse die verderop wordt gedefinieerd. In beide gevallen legt de letterlijke tekenreeks de verwijzing vast zonder de naam direct op te zoeken. Zet bij een unietype de hele expressie tussen aanhalingstekens: "int | Module". Zonder uitgestelde evaluatie geeft int | "Module" een TypeError, omdat | een type en een tekenreeks krijgt.
Je kunt ook from __future__ import annotations bovenaan de module zetten, na de eventuele docstring. In Python 3.12 slaat deze import functieannotaties op als tekenreeksen, zodat je -> WorkItem en module: Module zonder aanhalingstekens kunt schrijven. Gewone expressies buiten annotaties, zoals standaardwaarden van parameters, worden hierdoor niet uitgesteld.
In het voorbeeld bevat __annotations__ tekenreeksen. Zodra beide klassen zijn gedefinieerd, zoekt typing.get_type_hints() de namen op in de juiste naamruimten en zet het de verwijzingen om in klasseobjecten. Een ontbrekende naam kan nog steeds een NameError geven, bijvoorbeeld als die uitsluitend in if TYPE_CHECKING: is geïmporteerd. Los geen onbetrouwbare annotaties op: bij het evalueren van hun expressies kan code worden uitgevoerd.
Voorbeelden
from typing import get_type_hints
class WorkItem:
def __init__(self, title: str) -> None:
self.title = title
@classmethod
def from_dict(cls, data: dict[str, str]) -> "WorkItem":
return cls(data["title"])
class Project:
def __init__(self) -> None:
self.modules = []
def add_module(self, module: "Module") -> None:
self.modules.append(module)
class Module:
pass
print(repr(WorkItem.from_dict.__annotations__["return"]))
print(repr(Project.add_module.__annotations__["module"]))
print(get_type_hints(WorkItem.from_dict)["return"] is WorkItem)
print(get_type_hints(Project.add_module)["module"] is Module)
Resultaat
'WorkItem' 'Module' True True
De eerste twee regels tonen de representaties van de tekenreeksen uit `__annotations__`. De twee uitkomsten `True` bevestigen dat de opgeloste annotaties precies de klasseobjecten `WorkItem` en `Module` zijn.
Gerelateerde lessen
- Python · Les 3 · Gevorderd · Versie: 5
- Python · Les 7 · Gevorderd · Versie: 5