Python Language
Wpisz wskazówki

Składnia

• typing.Callable [[int, str], None] -> def func (a: int, b: str) -> None
• 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 lub int
• typing.Sequence [int] -> [1, 2, 3] lub (1, 2, 3)
• typing.Any -> Dowolny typ
• typing.Union [int, str] -> 1 lub „1”
• T = typing.TypeVar („T”) -> Rodzaj ogólny

Uwagi

Rodzaje ogólne

typing.TypeVar to fabryka typów ogólnych. Jego podstawowym celem jest służyć jako parametr / symbol zastępczy dla adnotacji funkcji / klasy / metody ogólnej:

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]

Dodawanie typów do funkcji

Weźmy przykład funkcji, która otrzymuje dwa argumenty i zwraca wartość wskazującą ich sumę:

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

Patrząc na ten kod, nie można bezpiecznie i bez wątpienia wskazać rodzaju argumentów dla funkcji two_sum . Działa zarówno w przypadku wartości int :

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

i ze sznurkami:

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

oraz z innymi wartościami, takimi jak list s, tuple s i tak dalej.

Ze względu na tę dynamiczną naturę typów python, gdzie wiele ma zastosowanie do danej operacji, żaden moduł sprawdzający typy nie byłby w stanie rozsądnie stwierdzić, czy wywołanie tej funkcji powinno być dozwolone, czy nie.

Aby wspomóc nasz moduł sprawdzania typu, możemy teraz podać dla niego podpowiedzi w definicji funkcji, wskazując dozwolony typ.

Aby wskazać, że chcemy dopuścić tylko typy int , możemy zmienić definicję naszej funkcji tak, aby wyglądała:

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

Adnotacje śledzić nazwy argumentów i oddzielone są : charakter.

Podobnie, aby wskazać, że dozwolone są tylko typy str , zmienilibyśmy naszą funkcję, aby ją określić:

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

Oprócz określenia rodzaju argumentów można również wskazać wartość zwracaną wywołania funkcji. Odbywa się to poprzez dodanie znaku -> po którym następuje typ po nawiasie zamykającym, na liście argumentów, ale przed : na końcu deklaracji funkcji:

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

Teraz wskazaliśmy, że zwracana wartość podczas wywoływania two_sum powinna być typu int . Podobnie możemy zdefiniować odpowiednie wartości dla str , float , list , set i innych.

Mimo że podpowiedzi są najczęściej używane przez kontrolery typów i środowiska IDE, czasem może być konieczne ich odzyskanie. Można to zrobić za pomocą specjalnego atrybutu __annotations__ :

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

Członkowie klasy i metody

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))

Konieczne jest przekazywanie do przodu bieżącej klasy, ponieważ adnotacje są oceniane, gdy funkcja jest zdefiniowana. Odwołania do przodu można również stosować w odniesieniu do klasy, która po zaimportowaniu spowodowałaby cykliczny import.

Zmienne i atrybuty

Zmienne są opatrzone adnotacjami za pomocą komentarzy:

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

Tworzenie tytułu o nazwie ze wskazówkami typu odbywa się za pomocą funkcji NamedTuple z modułu typing :

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

Zauważ, że nazwa typu wynikowego jest pierwszym argumentem funkcji, ale należy ją przypisać do zmiennej o tej samej nazwie, aby ułatwić pracę sprawdzania typów.

Wpisz podpowiedzi dla argumentów słów kluczowych

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

Zwróć uwagę na spacje wokół znaku równości, w przeciwieństwie do sposobu, w jaki argumenty słów kluczowych są zwykle stylizowane.