Хабрахабр

Введение в аннотации типов Python. Продолжение


Автор иллюстрации — Magdalena Tomczyk

Однако несколько важных моментов остались не рассмотрены. В первой части статьи я описал основы использования аннотаций типов. Но начать хотелось с более простых вещей Во-первых, дженерики — важный механизм, во-вторых иногда может оказаться полезным узнать информацию об ожидаемых типах в рантайме.

Предварительное объявление

Например, следующий код даже не запустится: Обычно вы не можете использовать тип до того, как он создан.

class LinkedList: data: Any next: LinkedList # NameError: name 'LinkedList' is not defined

В этом случае аннотации будут вычислены отложенно. Чтобы это исправить, допустимо использовать строковый литарал.

class LinkedList: data: Any next: 'LinkedList'

SomeClass' Так же вы можете обращаться к классам из других модулей (конечно, если модуль импортирован): some_variable: 'somemodule.

Замечание

Однако рекомендуется их делать максимально простыми, чтобы утилиты статического анализа могли их использовать. Вообще говоря, в качестве аннотации можно использовать любое вычислимое выражение. Подробнее про ограничения тут: PEP 484 — Type Hints # Acceptable type hints В частности, скорее всего ими не будут поняты динамически вычислимые типы.

Например, следующий код будет работать и даже аннотации будут доступны в рантайме, однако mypy на него выдаст ошибку

def get_next_type(arg=None): if arg: return LinkedList else: return Any class LinkedList: data: Any next: 'get_next_type()' # error: invalid type comment or annotation

0 планируется включить отложенное вычисление аннотаций типов (PEP 563), которое позволит избавиться от этого приема со строковыми литералами. UPD: В Python 4. 7 можно включить новое поведение с помощью конструкции from __future__ import annotations с Python 3.

Функции и вызываемые объекты

Для ситуаций, когда необходимо передать функцию или другой вызываем объект (например, в качестве callback) нужно использовать аннотацию Callable[[ArgType1, ArgType2,...], ReturnType]
Например,

def help() -> None: print("This is help string") def render_hundreds(num: int) -> str: return str(num // 100) def app(helper: Callable[[], None], renderer: Callable[[int], str]): helper() num = 12345 print(renderer(num)) app(help, render_hundreds)
app(help, help) # error: Argument 2 to "app" has incompatible type "Callable[[], None]"; expected "Callable[[int], str]"

В этом случае используется многоточие: Callable[..., ReturnType]. Допустимо указать только возвращаемый тип функции без указания её параметров. Обратите внимание, что квадратные скобки вокруг многоточия отсутствуют.

На текущий момент невозможно описать сигнатуру функции с переменным числом параметров определенного типа или указать именованные аргументы.

Generic-типы

Например, если вы пишете контейнер, который хранит однотипные данные. Иногда необходимо сохранить информацию о типе, при этом не фиксируя его жестко. Или функцию, которая возвращает данные того же типа, что и один из аргументов.

Но кроме стандартных типов, вы можете создать свои дженерик-типы. Такие типы как List или Callable, которые, мы видели раньше как раз используют механизм дженериков. Для этого надо, во-первых, завести TypeVar переменную, которая будет атрибутом дженерика, и, во-вторых, непосредственно объявить generic-тип:

T = TypeVar("T") class LinkedList(Generic[T]): data: T next: "LinkedList[T]" def __init__(self, data: T): self.data = data head_int: LinkedList[int] = LinkedList(1)
head_int.next = LinkedList(2)
head_int.next = 2 # error: Incompatible types in assignment (expression has type "int", variable has type "LinkedList[int]")
head_int.data += 1
head_int.data.replace("0", "1") # error: "int" has no attribute "replace" head_str: LinkedList[str] = LinkedList("1")
head_str.data.replace("0", "1") head_str = LinkedList[str](1) # error: Argument 1 to "LinkedList" has incompatible type "int"; expected "str"

Как вы можете заметить, для generic-типов работает автоматический вывод типа параметра.

Если требуется, дженерик может иметь любое количеством параметров: Generic[T1, T2, T3].

Также, при определении TypeVar вы можете ограничить допустимые типы:

T2 = TypeVar("T2", int, float) class SomethingNumeric(Generic[T2]): pass x = SomethingNumeric[str]() # error: Value of type variable "T2" of "SomethingNumeric" cannot be "str"

Cast

Её единственная задача — показать анализатору, что выражение имеет определённый тип. Иногда анализатор статический анализатор не может корректно определить тип переменной, в этом случае можно использовать функцию cast. Например:

from typing import List, cast def find_first_str(a: List[object]) -> str: index = next(i for i, x in enumerate(a) if isinstance(x, str)) return cast(str, a[index])

Также это может быть полезно для декораторов:

MyCallable = TypeVar("MyCallable", bound=Callable) def logged(func: MyCallable) -> MyCallable: @wraps(func) def wrapper(*args, **kwargs): print(func.__name__, args, kwargs) return func(*args, **kwargs) return cast(MyCallable, wrapper) @logged
def mysum(a: int, b: int) -> int: return a + b mysum(a=1) # error: Missing positional argument "b" in call to "mysum"

Работа с аннотациями во время выполнения

Для этого предусмотрен атрибут объектов __annotations__, содержащий словарь с указаннами аннотациями. Хотя интерпретатор и не использует аннотации самостоятельно, они доступны для вашего кода во время работы программы. Для функций это — аннотации параметров и возвращаемого типа, для объекта — аннотации полей, для глобального scope — переменные и их аннотации.

def render_int(num: int) -> str: return str(num) print(render_int.annotations) #

Так же доступна get_type_hints — она возвращает аннотации для переданного ей объекта, во многих ситуациях это совпадает с содержимым __annotations__, но есть отличия: он также добавляет аннотации родительских объектов (в порядке обратном __mro__), а так же разрешает предварительные объявления типов указанные как строки.

T = TypeVar("T") class LinkedList(Generic[T]): data: T next: "LinkedList[T]" print(LinkedList.__annotations__)
# {'data': ~T, 'next': 'LinkedList[T]'}
print(get_type_hints(LinkedList))
# {'data': ~T, 'next': __main__.LinkedList[~T]}

6 и 3. Для generic-типов доступна информация о самом типе и его параметрах через атрибуты __origin__ и __args__, но это не является частью стандарта и поведение уже менялось между версиями 3. 7

Теги
Показать больше

Похожие статьи

Добавить комментарий

Ваш e-mail не будет опубликован. Обязательные поля помечены *

Кнопка «Наверх»
Закрыть