Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Python

Unione di tipi X | None e annotazioni con riferimenti in avanti

Usa `X | None` per ammettere un valore di tipo `X` oppure `None`. Se una classe è definita più avanti, racchiudi l’intera annotazione tra virgolette o usa l’import da `__future__`.

Versione: Python 3.12

Sintassi

# 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, X | None ammette un valore di tipo X oppure None. Questa sintassi, disponibile da Python 3.10, equivale a typing.Optional[X] e a typing.Union[X, None], non a una chiamata a typing.Union(...). Qui | normalmente costruisce un’unione di tipi, non esegue un OR bit a bit tra interi; una metaclasse con un proprio metodo __or__ può cambiare il risultato. L’annotazione non impone il tipo in fase di esecuzione e non consente di omettere un argomento privo di valore predefinito.

Senza l’import da __future__, Python 3.12 valuta le normali annotazioni di una funzione quando la funzione viene definita. Se User non è ancora definito, User | None solleva NameError. Racchiudi tutta l’unione tra virgolette: "User|None". Se valutata subito, "User" | None solleva TypeError. Allo stesso modo, "Ticket" e "Board" in una firma indicano classi definite più avanti, non valori di tipo str.

In alternativa, inserisci from __future__ import annotations all’inizio del modulo e scrivi User | None, Ticket e Board senza virgolette nelle annotazioni. Python 3.12 memorizza così le annotazioni come stringhe. L’import non rinvia la valutazione di una normale assegnazione come Alias = User | None.

Una volta definite le classi, typing.get_type_hints() può risolvere i riferimenti memorizzati in __annotations__. A quel punto i nomi devono essere disponibili nello spazio dei nomi appropriato; se serve, specifica globalns o localns. Un nome mancante può causare NameError. Valutare le annotazioni può eseguire codice arbitrario: non risolvere annotazioni provenienti da fonti non attendibili.

Esempi

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)

Risultato

User|None
True
True True
True

La prima riga mostra la stringa originale `User|None`. La seconda conferma che l’unione è stata risolta, la terza che entrambi i riferimenti alle classi sono stati risolti. La quarta mostra che il codice crea un `Ticket` con `None` come proprietario.

Lezioni correlate

  • Python · Lezione 1 · Avanzato · Versione: 5

Fonti