Python Language
Tipo Suggerimenti

Sintassi

• typing.Callable [[int, str], None] -> def func (a: int, b: str) -> Nessuno
• typing.Mapping [str, int] -> {"a": 1, "b": 2, "c": 3}
• typing.List [int] -> [1, 2, 3]
• typing.Set [int] -> {1, 2, 3}
• typing.Optional [int] -> None o int
• typing.Sequence [int] -> [1, 2, 3] o (1, 2, 3)
• digitando. Qualsiasi -> Qualsiasi tipo
• typing.Union [int, str] -> 1 o "1"
• T = typing.TypeVar ('T') -> Tipo generico

Osservazioni

Tipi generici

typing.TypeVar è una fabbrica di tipo generico. L'obiettivo principale è quello di fungere da parametro / segnaposto per annotazioni di funzioni / classi / metodi generiche:

import typing

T = typing.TypeVar("T")

def get_first_element(l: typing.Sequence[T]) -> T:
    """Gets the first element of a sequence."""
    return l[0]

Aggiunta di tipi a una funzione

Prendiamo un esempio di una funzione che riceve due argomenti e restituisce un valore che indica la loro somma:

def two_sum(a, b):
    return a + b

Osservando questo codice, non si può sicuramente e senza dubbio indicare il tipo di argomenti per la funzione two_sum . Funziona sia quando è fornito con valori int :

print(two_sum(2, 1))  # result: 3

e con le stringhe:

print(two_sum("a", "b"))  # result: "ab"

e con altri valori, come list s, tuple s et cetera.

A causa di questa natura dinamica dei tipi Python, in cui molti sono applicabili per una determinata operazione, qualsiasi controllo di tipo non sarebbe in grado di affermare ragionevolmente se una chiamata per questa funzione debba essere consentita o meno.

Per aiutare il nostro correttore di tipi, ora possiamo fornire suggerimenti sui tipi nella definizione della funzione che indica il tipo che consentiamo.

Per indicare che vogliamo solo consentire i tipi int possiamo modificare la nostra definizione di funzione in modo che assomigli:

def two_sum(a: int, b: int):
    return a + b

Le annotazioni seguono il nome dell'argomento e sono separate da un : carattere.

Allo stesso modo, per indicare che sono consentiti solo i tipi str , cambieremo la nostra funzione per specificarlo:

def two_sum(a: str, b: str): 
    return a + b

Oltre a specificare il tipo di argomenti, si potrebbe anche indicare il valore di ritorno di una chiamata di funzione. Questo viene fatto aggiungendo il carattere -> seguito dal tipo dopo la parentesi chiusa nella lista degli argomenti ma prima : alla fine della dichiarazione della funzione:

def two_sum(a: int, b: int) -> int: 
    return a + b

Ora abbiamo indicato che il valore restituito quando si chiama two_sum dovrebbe essere di tipo int . Allo stesso modo possiamo definire valori appropriati per str , float , list , set e altri.

Sebbene i suggerimenti tipo siano principalmente utilizzati dai controllori dei tipi e dagli IDE, a volte potrebbe essere necessario recuperarli. Questo può essere fatto usando l' __annotations__ speciale __annotations__ :

two_sum.__annotations__
# {'a': <class 'int'>, 'b': <class 'int'>, 'return': <class 'int'>}

Membri e metodi della classe

class A:
    x = None  # type: float
    def __init__(self, x: float) -> None:
        """
        self should not be annotated
        init should be annotated to return None
        """
        self.x = x
    
    @classmethod
    def from_int(cls, x: int) -> 'A': 
        """
        cls should not be annotated
        Use forward reference to refer to current class with string literal 'A'
        """
        return cls(float(x))

Il riferimento diretto della classe corrente è necessario poiché le annotazioni vengono valutate quando la funzione è definita. I riferimenti diretti possono anche essere utilizzati quando si fa riferimento a una classe che causerebbe un'importazione circolare se importata.

Variabili e attributi

Le variabili sono annotate usando i commenti:

x = 3  # type: int
x = negate(x)
x = 'a type-checker might catch this error'

x: int = 3

y: int

class Foo:
    x: int
    y: str = 'abc'

print(typing.get_type_hints(Foo))
# ChainMap({'x': <class 'int'>, 'y': <class 'str'>}, {})

x: int
print(__annotations__)
# {'x': <class 'int'>}

class C:
    s: str
print(C.__annotations__)
# {'s': <class 'str'>}

namedtuple

La creazione di un namedtuple con hint del tipo viene eseguita utilizzando la funzione NamedTuple dal modulo di typing :

import typing
Point = typing.NamedTuple('Point', [('x', int), ('y', int)])

Si noti che il nome del tipo risultante è il primo argomento della funzione, ma dovrebbe essere assegnato a una variabile con lo stesso nome per facilitare il lavoro dei correttori di tipi.

Digita suggerimenti per gli argomenti delle parole chiave

def hello_world(greeting: str = 'Hello'):
    print(greeting + ' world!')

Nota gli spazi attorno al segno di uguale rispetto al modo in cui gli argomenti delle parole chiave sono solitamente in stile.