CKTIS / Python
Typunion X | None und Annotationen mit Vorwärtsreferenzen
Mit `X | None` lässt du einen Wert vom Typ `X` oder `None` zu. Wird eine Klasse erst später definiert, setze die ganze Annotation in Anführungszeichen oder nutze den `__future__`-Import.
Version: Python 3.12
Syntax
# Without the future import
class X: ...
value: X | None
value: "X | None"
def make_board(ticket: "Ticket") -> "Board": ...
# Alternative in Python 3.12: copy the next three lines without
# their comment prefixes into a separate module, with the import first.
# from __future__ import annotations
# value: X | None
# def make_board(ticket: Ticket) -> Board: ...In Python 3.12 steht X | None für einen Wert vom Typ X oder für None. Die Schreibweise gibt es seit Python 3.10. Sie entspricht typing.Optional[X] und typing.Union[X, None], nicht einem Aufruf von typing.Union(...). | bildet hier normalerweise eine Typunion und kein bitweises Oder für Ganzzahlen; eine Metaklasse mit eigener Methode __or__ kann das Ergebnis ändern. Die Annotation erzwingt zur Laufzeit keinen Typ und erlaubt nicht, ein Argument ohne Standardwert wegzulassen.
Ohne den Future-Import wertet Python 3.12 gewöhnliche Funktionsannotationen beim Definieren der Funktion aus. Ist User noch nicht definiert, löst User | None einen NameError aus. Setze deshalb die ganze Union in Anführungszeichen: "User|None". Wird "User" | None sofort ausgewertet, entsteht ein TypeError. Ebenso verweisen "Ticket" und "Board" in einer Signatur auf später definierte Klassen, nicht auf Werte vom Typ str.
Alternativ setzt du from __future__ import annotations an den Anfang des Moduls und schreibst User | None, Ticket und Board in Annotationen ohne Anführungszeichen. Python 3.12 speichert die Annotationen dann als Zeichenketten. Eine gewöhnliche Zuweisung wie Alias = User | None wird dadurch nicht aufgeschoben.
Sobald die Klassen definiert sind, kann typing.get_type_hints() die in __annotations__ gespeicherten Referenzen auflösen. Die Namen müssen dann im passenden Namensraum verfügbar sein; bei Bedarf kannst du globalns oder localns angeben. Ein fehlender Name kann zu einem NameError führen. Die Auswertung kann beliebigen Code ausführen. Löse daher keine Annotationen aus nicht vertrauenswürdigen Quellen auf.
Beispiele
from typing import get_type_hints
def make_board(ticket: "Ticket") -> "Board":
return Board(ticket)
class Ticket:
def __init__(self, owner: "User|None") -> None:
self.owner = owner
class Board:
def __init__(self, ticket: Ticket) -> None:
self.ticket = ticket
class User:
pass
print(Ticket.__init__.__annotations__["owner"])
print(get_type_hints(Ticket.__init__)["owner"] == (User | None))
board_hints = get_type_hints(make_board)
print(board_hints["ticket"] is Ticket, board_hints["return"] is Board)
print(make_board(Ticket(None)).ticket.owner is None)
Ergebnis
User|None True True True True
Die erste Zeile zeigt die unveränderte Zeichenkette `User|None`. Die zweite bestätigt die Auflösung der Union, die dritte die Auflösung beider Klassenreferenzen. Die vierte zeigt, dass der Code ein `Ticket` mit `None` als Besitzer erstellt.
Zugehörige Lektionen
- Python · Lektion 1 · Fortgeschritten · Version: 5