`typing.md`

1271 строк · 71.1 КБ · обычная страница · сырой текст · скачать
1> **Источник:** https://python-all.ru/3.8/library/typing.html2>3> «Документация Python на русском» – неофициальный перевод официальной документации Python: версии от 2.6 до 3.16, полнотекстовый поиск, английский оригинал рядом с переводом. Эта Markdown-версия страницы предназначена для работы с LLM: вставьте её в ChatGPT, Claude или Cursor.45---67# [`typing`](https://python-all.ru/3.8/library/typing.html#module-typing) – Поддержка аннотаций типов89Новое в версии 3.5.1011**Исходный код:** [Lib/typing.py](https://python-all.ru/src/3.8/Lib/typing.py)1213> **Примечание**14>15> Среда выполнения Python не проверяет аннотации типов функций и переменных. Они могут использоваться сторонними инструментами, такими как средства проверки типов, IDE, линтеры и т. д.1617---1819Этот модуль обеспечивает поддержку подсказок типов во время выполнения в соответствии с [**PEP 484**](https://python-all.ru/3.8/library/typing.html), [**PEP 526**](https://python-all.ru/3.8/library/typing.html), [**PEP 544**](https://python-all.ru/3.8/library/typing.html), [**PEP 586**](https://python-all.ru/3.8/library/typing.html), [**PEP 589**](https://python-all.ru/3.8/library/typing.html) и [**PEP 591**](https://python-all.ru/3.8/library/typing.html). Самая базовая поддержка включает типы [`Any`](https://python-all.ru/3.8/library/typing.html#typing.Any), [`Union`](https://python-all.ru/3.8/library/typing.html#typing.Union), [`Tuple`](https://python-all.ru/3.8/library/typing.html#typing.Tuple), [`Callable`](https://python-all.ru/3.8/library/typing.html#typing.Callable), [`TypeVar`](https://python-all.ru/3.8/library/typing.html#typing.TypeVar) и [`Generic`](https://python-all.ru/3.8/library/typing.html#typing.Generic). Полную спецификацию см. в [**PEP 484**](https://python-all.ru/3.8/library/typing.html). Для упрощённого введения в подсказки типов см. [**PEG 483**](https://python-all.ru/3.8/library/typing.html).2021Функция ниже принимает и возвращает строку и аннотирована следующим образом:2223```python24def greeting(name: str) -> str:25    return 'Hello ' + name26```2728В функции `greeting` аргумент `name` ожидается типа [`str`](https://python-all.ru/3.8/library/stdtypes.html#str), а возвращаемый тип – [`str`](https://python-all.ru/3.8/library/stdtypes.html#str). Подтипы допускаются в качестве аргументов.2930## Псевдонимы типов3132Псевдоним типа определяется присваиванием типа псевдониму. В этом примере `Vector` и `List[float]` будут рассматриваться как взаимозаменяемые синонимы:3334```python35from typing import List36Vector = List[float]3738def scale(scalar: float, vector: Vector) -> Vector:39    return [scalar * num for num in vector]4041# Проходит проверку типов; список чисел с плавающей запятой считается Vector.42new_vector = scale(2.0, [1.0, -4.2, 5.4])43```4445Псевдонимы типов полезны для упрощения сложных сигнатур типов. Например:4647```python48from typing import Dict, Tuple, Sequence4950ConnectionOptions = Dict[str, str]51Address = Tuple[str, int]52Server = Tuple[Address, ConnectionOptions]5354def broadcast_message(message: str, servers: Sequence[Server]) -> None:55    ...5657# Статическая проверка типов будет считать предыдущую сигнатуру типа как58# полностью эквивалентную этой.59def broadcast_message(60        message: str,61        servers: Sequence[Tuple[Tuple[str, int], Dict[str, str]]]) -> None:62    ...63```6465Обратите внимание, что `None` как аннотация типа является особым случаем и заменяется на `type(None)`.6667## NewType6869Для создания отдельных типов используется вспомогательная функция [`NewType()`](https://python-all.ru/3.8/library/typing.html#typing.NewType):7071```python72from typing import NewType7374UserId = NewType('UserId', int)75some_id = UserId(524313)76```7778Статический проверщик типов будет рассматривать новый тип как подкласс исходного типа. Это полезно для выявления логических ошибок:7980```python81def get_user_name(user_id: UserId) -> str:82    ...8384# Проходит проверку типов.85user_a = get_user_name(UserId(42351))8687# Не проходит проверку типов; int не является UserId.88user_b = get_user_name(-1)89```9091Можно по-прежнему выполнять все операции `int` над переменной типа `UserId`, но результат всегда будет типа `int`. Это позволяет передавать `UserId` везде, где может ожидаться `int`, но предотвращает случайное создание `UserId` недопустимым способом:9293```python94# 'output' имеет тип 'int', а не 'UserId'95output = UserId(23413) + UserId(54341)96```9798Обратите внимание, что эти проверки выполняются только статическим анализатором типов. Во время выполнения оператор `Derived = NewType('Derived', Base)` превращает `Derived` в функцию, которая немедленно возвращает любой переданный ей параметр. Это означает, что выражение `Derived(some_value)` не создаёт новый класс и не вносит никаких накладных расходов сверх обычного вызова функции.99100Точнее, выражение `some_value is Derived(some_value)` во время выполнения всегда истинно.101102Это также означает, что невозможно создать подтип `Derived`, поскольку во время выполнения это тождественная функция, а не реальный тип:103104```python105from typing import NewType106107UserId = NewType('UserId', int)108109# Завершается ошибкой во время выполнения и не проходит проверку типов.110class AdminUserId(UserId): pass111```112113Однако можно создать [`NewType()`](https://python-all.ru/3.8/library/typing.html#typing.NewType) на основе «производного» `NewType`:114115```python116from typing import NewType117118UserId = NewType('UserId', int)119120ProUserId = NewType('ProUserId', UserId)121```122123и проверка типов для `ProUserId` будет работать как ожидается.124125Подробнее см. [**PEP 484**](https://python-all.ru/3.8/library/typing.html).126127> **Примечание**128>129> Напомним, что использование псевдонима типа объявляет два типа *эквивалентными* друг другу. Использование `Alias = Original` заставит статический анализатор типов считать `Alias` *точно эквивалентным* `Original` во всех случаях. Это полезно, когда требуется упростить сложные сигнатуры типов.130>131> В отличие от этого, `NewType` объявляет один тип *подтипом* другого. Использование `Derived = NewType('Derived', Original)` заставит статический анализатор типов считать `Derived` *подклассом* `Original`, что означает, что значение типа `Original` не может использоваться там, где ожидается значение типа `Derived`. Это полезно для предотвращения логических ошибок с минимальными затратами времени выполнения.132133Новое в версии 3.5.2.134135## Callable136137Фреймворки, ожидающие функции обратного вызова с определённой сигнатурой, могут быть аннотированы с помощью `Callable[[Arg1Type, Arg2Type], ReturnType]`.138139Например:140141```python142from typing import Callable143144def feeder(get_next_item: Callable[[], str]) -> None:145    # Тело146147def async_query(on_success: Callable[[int], None],148                on_error: Callable[[int, Exception], None]) -> None:149    # Тело150```151152Можно объявить возвращаемый тип вызываемого объекта, не указывая сигнатуру вызова, заменив список аргументов многоточием в аннотации типа: `Callable[..., ReturnType]`.153154## Обобщённые типы155156Поскольку информацию о типах объектов, хранящихся в контейнерах, нельзя статически вывести обобщённым способом, абстрактные базовые классы были расширены для поддержки параметризации типами, чтобы обозначить ожидаемые типы элементов контейнера.157158```python159from typing import Mapping, Sequence160161def notify_by_email(employees: Sequence[Employee],162                    overrides: Mapping[str, str]) -> None: ...163```164165Обобщения (дженерики) можно параметризовать с помощью новой фабрики, доступной в typing, которая называется [`TypeVar`](https://python-all.ru/3.8/library/typing.html#typing.TypeVar).166167```python168from typing import Sequence, TypeVar169170T = TypeVar('T')      # Объявить переменную типа171172def first(l: Sequence[T]) -> T:   # Обобщённая функция173    return l[0]174```175176## Пользовательские обобщённые типы177178Пользовательский класс можно определить как обобщённый класс.179180```python181from typing import TypeVar, Generic182from logging import Logger183184T = TypeVar('T')185186class LoggedVar(Generic[T]):187    def __init__(self, value: T, name: str, logger: Logger) -> None:188        self.name = name189        self.logger = logger190        self.value = value191192    def set(self, new: T) -> None:193        self.log('Set ' + repr(self.value))194        self.value = new195196    def get(self) -> T:197        self.log('Get ' + repr(self.value))198        return self.value199200    def log(self, message: str) -> None:201        self.logger.info('%s: %s', self.name, message)202```203204`Generic[T]` в качестве базового класса определяет, что класс `LoggedVar` принимает один параметр типа `T`. Это также делает `T` допустимым типом внутри тела класса.205206Базовый класс [`Generic`](https://python-all.ru/3.8/library/typing.html#typing.Generic) определяет [`__class_getitem__()`](https://python-all.ru/3.8/reference/datamodel.html#object.__class_getitem__), что делает `LoggedVar[t]` допустимым в качестве типа:207208```python209from typing import Iterable210211def zero_all_vars(vars: Iterable[LoggedVar[int]]) -> None:212    for var in vars:213        var.set(0)214```215216Обобщённый тип может иметь любое количество переменных типа, и эти переменные могут быть ограничены:217218```python219from typing import TypeVar, Generic220...221222T = TypeVar('T')223S = TypeVar('S', int, str)224225class StrangePair(Generic[T, S]):226    ...227```228229Каждый аргумент-переменная типа для [`Generic`](https://python-all.ru/3.8/library/typing.html#typing.Generic) должен быть уникальным. Поэтому такой код некорректен:230231```python232from typing import TypeVar, Generic233...234235T = TypeVar('T')236237class Pair(Generic[T, T]):   # НЕДОПУСТИМО238    ...239```240241Можно использовать множественное наследование с [`Generic`](https://python-all.ru/3.8/library/typing.html#typing.Generic):242243```python244from typing import TypeVar, Generic, Sized245246T = TypeVar('T')247248class LinkedList(Sized, Generic[T]):249    ...250```251252При наследовании от обобщённых классов некоторые переменные типа могут быть зафиксированы:253254```python255from typing import TypeVar, Mapping256257T = TypeVar('T')258259class MyDict(Mapping[str, T]):260    ...261```262263В этом случае `MyDict` имеет один параметр – `T`.264265Использование обобщённого класса без указания параметров типа подразумевает [`Any`](https://python-all.ru/3.8/library/typing.html#typing.Any) для каждой позиции. В следующем примере `MyIterable` не является обобщённым, но неявно наследуется от `Iterable[Any]`:266267```python268from typing import Iterable269270class MyIterable(Iterable): # То же, что и Iterable[Any].271```272273Пользовательские обобщённые псевдонимы типов также поддерживаются. Примеры:274275```python276from typing import TypeVar, Iterable, Tuple, Union277S = TypeVar('S')278Response = Union[Iterable[S], int]279280# Тип возврата здесь такой же, как Union[Iterable[str], int]281def response(query: str) -> Response[str]:282    ...283284T = TypeVar('T', int, float, complex)285Vec = Iterable[Tuple[T, T]]286287def inproduct(v: Vec[T]) -> T: # То же, что Iterable[Tuple[T, T]]288    return sum(x*y for x, y in v)289```290291Изменено в версии 3.7: [`Generic`](https://python-all.ru/3.8/library/typing.html#typing.Generic) больше не имеет собственного метакласса.292293Пользовательский обобщённый класс может иметь ABC в качестве базовых классов без конфликта метаклассов. Обобщённые метаклассы не поддерживаются. Результат параметризации обобщений кэшируется, и большинство типов в модуле typing являются хешируемыми и сравнимыми на равенство.294295## Тип [`Any`](https://python-all.ru/3.8/library/typing.html#typing.Any)296297Особым видом типа является [`Any`](https://python-all.ru/3.8/library/typing.html#typing.Any). Статический проверяющий типов будет считать каждый тип совместимым с [`Any`](https://python-all.ru/3.8/library/typing.html#typing.Any), а [`Any`](https://python-all.ru/3.8/library/typing.html#typing.Any) – совместимым с каждым типом.298299Это означает, что над значением типа [`Any`](https://python-all.ru/3.8/library/typing.html#typing.Any) можно выполнять любые операции или вызовы методов и присваивать его любой переменной:300301```python302from typing import Any303304a = None    # type: Any305a = []      # ОК306a = 2       # ОК307308s = ''      # type: str309s = a       # ОК310311def foo(item: Any) -> int:312    # Проходит проверку типов; 'item' может быть любого типа,313    # и этот тип может иметь метод 'bar'314    item.bar()315    ...316```317318Обратите внимание, что никакая проверка типов не выполняется при присваивании значения типа [`Any`](https://python-all.ru/3.8/library/typing.html#typing.Any) более точному типу. Например, статический проверяющий типы не сообщил об ошибке при присваивании `a` переменной `s`, хотя `s` был объявлен как тип [`str`](https://python-all.ru/3.8/library/stdtypes.html#str) и получает значение [`int`](https://python-all.ru/3.8/library/functions.html#int) во время выполнения!319320Кроме того, все функции без указания типа возврата или типов параметров по умолчанию неявно используют [`Any`](https://python-all.ru/3.8/library/typing.html#typing.Any):321322```python323def legacy_parser(text):324    ...325    return data326327# Статический проверщик типов будет рассматривать вышеприведенное328# как имеющее ту же сигнатуру, что и:329def legacy_parser(text: Any) -> Any:330    ...331    return data332```333334Такое поведение позволяет использовать [`Any`](https://python-all.ru/3.8/library/typing.html#typing.Any) в качестве *запасного выхода*, когда нужно смешивать динамически и статически типизированный код.335336Сравните поведение [`Any`](https://python-all.ru/3.8/library/typing.html#typing.Any) с поведением [`object`](https://python-all.ru/3.8/library/functions.html#object). Как и [`Any`](https://python-all.ru/3.8/library/typing.html#typing.Any), каждый тип является подтипом [`object`](https://python-all.ru/3.8/library/functions.html#object). Однако, в отличие от [`Any`](https://python-all.ru/3.8/library/typing.html#typing.Any), обратное неверно: [`object`](https://python-all.ru/3.8/library/functions.html#object) *не* является подтипом любого другого типа.337338Это означает, что когда тип значения – [`object`](https://python-all.ru/3.8/library/functions.html#object), проверяющий типы будет отклонять почти все операции над ним, а присваивание его переменной (или использование в качестве возвращаемого значения) более специализированного типа является ошибкой типа. Например:339340```python341def hash_a(item: object) -> int:342    # Завершается ошибкой; у объекта нет метода 'magic'.343    item.magic()344    ...345346def hash_b(item: Any) -> int:347    # Проходит проверку типов.348    item.magic()349    ...350351# Проходит проверку типов, так как int и str являются подклассами object.352hash_a(42)353hash_a("foo")354355# Проходит проверку типов, так как Any совместим со всеми типами.356hash_b(42)357hash_b("foo")358```359360Используйте [`object`](https://python-all.ru/3.8/library/functions.html#object), чтобы указать, что значение может быть любого типа в типобезопасной манере. Используйте [`Any`](https://python-all.ru/3.8/library/typing.html#typing.Any), чтобы указать, что значение динамически типизировано.361362## Номинальная и структурная типизация363364Изначально [**PEP 484**](https://python-all.ru/3.8/library/typing.html) определял статическую систему типов Python как использующую *номинальное подтипирование*. Это означает, что класс `A` разрешён там, где ожидается класс `B`, только если `A` является подклассом `B`.365366Ранее это требование также применялось к абстрактным базовым классам, таким как [`Iterable`](https://python-all.ru/3.8/library/collections.abc.html#collections.abc.Iterable). Проблема такого подхода в том, что класс должен быть явно помечен для их поддержки, что непитонично и не похоже на то, что обычно делается в идиоматическом динамически типизированном коде Python. Например, следующее соответствует [**PEP 484**](https://python-all.ru/3.8/library/typing.html):367368```python369from typing import Sized, Iterable, Iterator370371class Bucket(Sized, Iterable[int]):372    ...373    def __len__(self) -> int: ...374    def __iter__(self) -> Iterator[int]: ...375```376377[**PEP 544**](https://python-all.ru/3.8/library/typing.html) позволяет решить эту проблему, разрешая пользователям писать приведённый выше код без явных базовых классов в определении класса, что позволяет `Bucket` неявно считаться подтипом как `Sized`, так и `Iterable[int]` статическими проверяющими типов. Это называется *структурной подтипизацией* (или статической утиной типизацией):378379```python380from typing import Iterator, Iterable381382class Bucket:  # Примечание: базовые классы отсутствуют383    ...384    def __len__(self) -> int: ...385    def __iter__(self) -> Iterator[int]: ...386387def collect(items: Iterable[int]) -> int: ...388result = collect(Bucket())  # Проходит проверку типов389```390391Более того, наследуя специальный класс [`Protocol`](https://python-all.ru/3.8/library/typing.html#typing.Protocol), пользователь может определять новые пользовательские протоколы, чтобы в полной мере использовать структурное подтипирование (см. примеры ниже).392393## Классы, функции и декораторы394395Модуль определяет следующие классы, функции и декораторы:396397#### `class typing.TypeVar`398399Переменная типа.400401Использование:402403```python404T = TypeVar('T')  # Может быть чем угодно405A = TypeVar('A', str, bytes)  # Должно быть str или bytes406```407408Переменные типа существуют в первую очередь для статических анализаторов типов. Они служат параметрами для обобщённых типов, а также для определений обобщённых функций. См. класс Generic для получения дополнительной информации об обобщённых типах. Обобщённые функции работают следующим образом:409410```python411def repeat(x: T, n: int) -> Sequence[T]:412    """Возвращает список, содержащий n ссылок на x."""413    return [x]*n414415def longest(x: A, y: A) -> A:416    """Возвращает самую длинную из двух строк."""417    return x if len(x) >= len(y) else y418```419420Сигнатура последнего примера по сути является перегрузкой `(str, str) -> str` и `(bytes, bytes) -> bytes`. Также обратите внимание, что если аргументы являются экземплярами какого-либо подкласса [`str`](https://python-all.ru/3.8/library/stdtypes.html#str), возвращаемый тип остаётся простым [`str`](https://python-all.ru/3.8/library/stdtypes.html#str).421422Во время выполнения `isinstance(x, T)` вызовет [`TypeError`](https://python-all.ru/3.8/library/exceptions.html#TypeError). В общем, [`isinstance()`](https://python-all.ru/3.8/library/functions.html#isinstance) и [`issubclass()`](https://python-all.ru/3.8/library/functions.html#issubclass) не должны использоваться с типами.423424Переменные типа могут быть помечены как ковариантные или контравариантные путём передачи `covariant=True` или `contravariant=True`. См. [**PEP 484**](https://python-all.ru/3.8/library/typing.html) для подробностей. По умолчанию переменные типа инвариантны. В качестве альтернативы, переменная типа может указывать верхнюю границу с помощью `bound=<type>`. Это означает, что фактический тип, подставленный (явно или неявно) для переменной типа, должен быть подклассом граничного типа, см. [**PEP 484**](https://python-all.ru/3.8/library/typing.html).425426#### `class typing.Generic`427428Абстрактный базовый класс для обобщённых типов.429430Обобщённый тип обычно объявляется наследованием от экземпляра этого класса с одной или несколькими переменными типа. Например, обобщённый тип отображения может быть определён так:431432```python433class Mapping(Generic[KT, VT]):434    def __getitem__(self, key: KT) -> VT:435        ...436        # И т.д.437```438439Затем этот класс можно использовать следующим образом:440441```python442X = TypeVar('X')443Y = TypeVar('Y')444445def lookup_name(mapping: Mapping[X, Y], key: X, default: Y) -> Y:446    try:447        return mapping[key]448    except KeyError:449        return default450```451452#### `class typing.Protocol(Generic)`453454Базовый класс для классов протоколов. Классы протоколов определяются следующим образом:455456```python457class Proto(Protocol):458    def meth(self) -> int:459        ...460```461462Такие классы в основном используются со статическими проверяющими типов, которые распознают структурную подтипизацию (статическую утиную типизацию), например:463464```python465class C:466    def meth(self) -> int:467        return 0468469def func(x: Proto) -> int:470    return x.meth()471472func(C())  # Проходит статическую проверку типов473```474475Подробности см. в [**PEP 544**](https://python-all.ru/3.8/library/typing.html). Классы протоколов, декорированные [`runtime_checkable()`](https://python-all.ru/3.8/library/typing.html#typing.runtime_checkable) (описаны далее), действуют как упрощённые протоколы времени выполнения, которые проверяют только наличие заданных атрибутов, игнорируя их сигнатуры типов.476477Протокольные классы могут быть обобщёнными, например:478479```python480class GenProto(Protocol[T]):481    def meth(self) -> T:482        ...483```484485Новое в версии 3.8.486487#### `class typing.Type(Generic[CT_co])`488489Переменная, аннотированная `C`, может принимать значение типа `C`. Напротив, переменная, аннотированная `Type[C]`, может принимать значения, которые сами являются классами – а именно, она принимает *объект класса* `C`. Например:490491```python492a = 3         # Имеет тип 'int'493b = int       # Имеет тип 'Type[int]'494c = type(a)   # Также имеет тип 'Type[int]'495```496497Обратите внимание, что `Type[C]` ковариантен:498499```python500class User: ...501class BasicUser(User): ...502class ProUser(User): ...503class TeamUser(User): ...504505# Принимает User, BasicUser, ProUser, TeamUser, ...506def make_new_user(user_class: Type[User]) -> User:507    # ...508    return user_class()509```510511Тот факт, что `Type[C]` ковариантен, подразумевает, что все подклассы `C` должны реализовывать те же сигнатуры конструктора и методов класса, что и `C`. Средство проверки типов должно отмечать нарушения этого, но также должно разрешать вызовы конструкторов в подклассах, которые соответствуют вызовам конструктора в указанном базовом классе. То, как средство проверки типов должно обрабатывать этот конкретный случай, может измениться в будущих версиях [**PEP 484**](https://python-all.ru/3.8/library/typing.html).512513Единственными допустимыми параметрами для [`Type`](https://python-all.ru/3.8/library/typing.html#typing.Type) являются классы, [`Any`](https://python-all.ru/3.8/library/typing.html#typing.Any), [переменные типа](https://python-all.ru/3.8/library/typing.html#generics) и объединения любых из этих типов. Например:514515```python516def new_non_team_user(user_class: Type[Union[BasicUser, ProUser]]): ...517```518519`Type[Any]` эквивалентен `Type`, который в свою очередь эквивалентен `type`, корню метаклассовой иерархии Python.520521Новое в версии 3.5.2.522523#### `class typing.Iterable(Generic[T_co])`524525Обобщённая версия [`collections.abc.Iterable`](https://python-all.ru/3.8/library/collections.abc.html#collections.abc.Iterable).526527#### `class typing.Iterator(Iterable[T_co])`528529Обобщённая версия [`collections.abc.Iterator`](https://python-all.ru/3.8/library/collections.abc.html#collections.abc.Iterator).530531#### `class typing.Reversible(Iterable[T_co])`532533Обобщённая версия [`collections.abc.Reversible`](https://python-all.ru/3.8/library/collections.abc.html#collections.abc.Reversible).534535#### `class typing.SupportsInt`536537ABC с одним абстрактным методом `__int__`.538539#### `class typing.SupportsFloat`540541ABC с одним абстрактным методом `__float__`.542543#### `class typing.SupportsComplex`544545ABC с одним абстрактным методом `__complex__`.546547#### `class typing.SupportsBytes`548549ABC с одним абстрактным методом `__bytes__`.550551#### `class typing.SupportsIndex`552553ABC с одним абстрактным методом `__index__`.554555Новое в версии 3.8.556557#### `class typing.SupportsAbs`558559ABC с одним абстрактным методом `__abs__`, ковариантным по типу возвращаемого значения.560561#### `class typing.SupportsRound`562563ABC с одним абстрактным методом `__round__` ковариантным по возвращаемому типу.564565#### `class typing.Container(Generic[T_co])`566567Обобщённая версия [`collections.abc.Container`](https://python-all.ru/3.8/library/collections.abc.html#collections.abc.Container).568569#### `class typing.Hashable`570571Псевдоним для [`collections.abc.Hashable`](https://python-all.ru/3.8/library/collections.abc.html#collections.abc.Hashable)572573#### `class typing.Sized`574575Псевдоним для [`collections.abc.Sized`](https://python-all.ru/3.8/library/collections.abc.html#collections.abc.Sized)576577#### `class typing.Collection(Sized, Iterable[T_co], Container[T_co])`578579Обобщённая версия [`collections.abc.Collection`](https://python-all.ru/3.8/library/collections.abc.html#collections.abc.Collection)580581Новое в версии 3.6.0.582583#### `class typing.AbstractSet(Sized, Collection[T_co])`584585Обобщённая версия [`collections.abc.Set`](https://python-all.ru/3.8/library/collections.abc.html#collections.abc.Set).586587#### `class typing.MutableSet(AbstractSet[T])`588589Обобщённая версия [`collections.abc.MutableSet`](https://python-all.ru/3.8/library/collections.abc.html#collections.abc.MutableSet).590591#### `class typing.Mapping(Sized, Collection[KT], Generic[VT_co])`592593Обобщённая версия [`collections.abc.Mapping`](https://python-all.ru/3.8/library/collections.abc.html#collections.abc.Mapping). Этот тип можно использовать следующим образом:594595```python596def get_position_in_index(word_list: Mapping[str, int], word: str) -> int:597    return word_list[word]598```599600#### `class typing.MutableMapping(Mapping[KT, VT])`601602Обобщённая версия [`collections.abc.MutableMapping`](https://python-all.ru/3.8/library/collections.abc.html#collections.abc.MutableMapping).603604#### `class typing.Sequence(Reversible[T_co], Collection[T_co])`605606Обобщённая версия [`collections.abc.Sequence`](https://python-all.ru/3.8/library/collections.abc.html#collections.abc.Sequence).607608#### `class typing.MutableSequence(Sequence[T])`609610Обобщённая версия [`collections.abc.MutableSequence`](https://python-all.ru/3.8/library/collections.abc.html#collections.abc.MutableSequence).611612#### `class typing.ByteString(Sequence[int])`613614Обобщённая версия [`collections.abc.ByteString`](https://python-all.ru/3.8/library/collections.abc.html#collections.abc.ByteString).615616Этот тип представляет типы [`bytes`](https://python-all.ru/3.8/library/stdtypes.html#bytes), [`bytearray`](https://python-all.ru/3.8/library/stdtypes.html#bytearray) и [`memoryview`](https://python-all.ru/3.8/library/stdtypes.html#memoryview) последовательностей байтов.617618В качестве сокращения для этого типа [`bytes`](https://python-all.ru/3.8/library/stdtypes.html#bytes) можно использовать для аннотации аргументов любого из упомянутых выше типов.619620#### `class typing.Deque(deque, MutableSequence[T])`621622Обобщённая версия [`collections.deque`](https://python-all.ru/3.8/library/collections.html#collections.deque).623624Новое в версии 3.5.4.625626Новое в версии 3.6.1.627628#### `class typing.List(list, MutableSequence[T])`629630Обобщённая версия [`list`](https://python-all.ru/3.8/library/stdtypes.html#list). Полезна для аннотирования возвращаемых типов. Для аннотирования аргументов предпочтительнее использовать абстрактный тип коллекции, например [`Sequence`](https://python-all.ru/3.8/library/typing.html#typing.Sequence) или [`Iterable`](https://python-all.ru/3.8/library/typing.html#typing.Iterable).631632Этот тип можно использовать следующим образом:633634```python635T = TypeVar('T', int, float)636637def vec2(x: T, y: T) -> List[T]:638    return [x, y]639640def keep_positives(vector: Sequence[T]) -> List[T]:641    return [item for item in vector if item > 0]642```643644#### `class typing.Set(set, MutableSet[T])`645646Обобщённая версия [`builtins.set`](https://python-all.ru/3.8/library/stdtypes.html#set). Полезна для аннотирования возвращаемых типов. Для аннотирования аргументов предпочтительнее использовать абстрактный тип коллекции, например [`AbstractSet`](https://python-all.ru/3.8/library/typing.html#typing.AbstractSet).647648#### `class typing.FrozenSet(frozenset, AbstractSet[T_co])`649650Обобщённая версия [`builtins.frozenset`](https://python-all.ru/3.8/library/stdtypes.html#frozenset).651652#### `class typing.MappingView(Sized, Iterable[T_co])`653654Обобщённая версия [`collections.abc.MappingView`](https://python-all.ru/3.8/library/collections.abc.html#collections.abc.MappingView).655656#### `class typing.KeysView(MappingView[KT_co], AbstractSet[KT_co])`657658Обобщённая версия [`collections.abc.KeysView`](https://python-all.ru/3.8/library/collections.abc.html#collections.abc.KeysView).659660#### `class typing.ItemsView(MappingView, Generic[KT_co, VT_co])`661662Обобщённая версия [`collections.abc.ItemsView`](https://python-all.ru/3.8/library/collections.abc.html#collections.abc.ItemsView).663664#### `class typing.ValuesView(MappingView[VT_co])`665666Обобщённая версия [`collections.abc.ValuesView`](https://python-all.ru/3.8/library/collections.abc.html#collections.abc.ValuesView).667668#### `class typing.Awaitable(Generic[T_co])`669670Обобщённая версия [`collections.abc.Awaitable`](https://python-all.ru/3.8/library/collections.abc.html#collections.abc.Awaitable).671672Новое в версии 3.5.2.673674#### `class typing.Coroutine(Awaitable[V_co], Generic[T_co, T_contra, V_co])`675676Обобщённая версия [`collections.abc.Coroutine`](https://python-all.ru/3.8/library/collections.abc.html#collections.abc.Coroutine). Вариантность и порядок переменных типа соответствуют таковым у [`Generator`](https://python-all.ru/3.8/library/typing.html#typing.Generator), например:677678```python679from typing import List, Coroutine680c = None # type: Coroutine[List[str], str, int]681...682x = c.send('hi') # type: List[str]683async def bar() -> None:684    x = await c # type: int685```686687Новое в версии 3.5.3.688689#### `class typing.AsyncIterable(Generic[T_co])`690691Обобщённая версия [`collections.abc.AsyncIterable`](https://python-all.ru/3.8/library/collections.abc.html#collections.abc.AsyncIterable).692693Новое в версии 3.5.2.694695#### `class typing.AsyncIterator(AsyncIterable[T_co])`696697Обобщённая версия [`collections.abc.AsyncIterator`](https://python-all.ru/3.8/library/collections.abc.html#collections.abc.AsyncIterator).698699Новое в версии 3.5.2.700701#### `class typing.ContextManager(Generic[T_co])`702703Обобщённая версия [`contextlib.AbstractContextManager`](https://python-all.ru/3.8/library/contextlib.html#contextlib.AbstractContextManager).704705Новое в версии 3.5.4.706707Новое в версии 3.6.0.708709#### `class typing.AsyncContextManager(Generic[T_co])`710711Обобщённая версия [`contextlib.AbstractAsyncContextManager`](https://python-all.ru/3.8/library/contextlib.html#contextlib.AbstractAsyncContextManager).712713Новое в версии 3.5.4.714715Новое в версии 3.6.2.716717#### `class typing.Dict(dict, MutableMapping[KT, VT])`718719Обобщённая версия [`dict`](https://python-all.ru/3.8/library/stdtypes.html#dict). Полезна для аннотирования возвращаемых типов. Для аннотирования аргументов предпочтительнее использовать абстрактный тип коллекции, например [`Mapping`](https://python-all.ru/3.8/library/typing.html#typing.Mapping).720721Этот тип можно использовать следующим образом:722723```python724def count_words(text: str) -> Dict[str, int]:725    ...726```727728#### `class typing.DefaultDict(collections.defaultdict, MutableMapping[KT, VT])`729730Обобщённая версия [`collections.defaultdict`](https://python-all.ru/3.8/library/collections.html#collections.defaultdict).731732Новое в версии 3.5.2.733734#### `class typing.OrderedDict(collections.OrderedDict, MutableMapping[KT, VT])`735736Обобщённая версия [`collections.OrderedDict`](https://python-all.ru/3.8/library/collections.html#collections.OrderedDict).737738Добавлено в версии 3.7.2.739740#### `class typing.Counter(collections.Counter, Dict[T, int])`741742Обобщённая версия [`collections.Counter`](https://python-all.ru/3.8/library/collections.html#collections.Counter).743744Новое в версии 3.5.4.745746Новое в версии 3.6.1.747748#### `class typing.ChainMap(collections.ChainMap, MutableMapping[KT, VT])`749750Обобщённая версия [`collections.ChainMap`](https://python-all.ru/3.8/library/collections.html#collections.ChainMap).751752Новое в версии 3.5.4.753754Новое в версии 3.6.1.755756#### `class typing.Generator(Iterator[T_co], Generic[T_co, T_contra, V_co])`757758Генератор можно аннотировать обобщённым типом `Generator[YieldType, SendType, ReturnType]`. Например:759760```python761def echo_round() -> Generator[int, float, str]:762    sent = yield 0763    while sent >= 0:764        sent = yield round(sent)765    return 'Done'766```767768Обратите внимание: в отличие от многих других обобщённых типов в модуле typing, `SendType` из [`Generator`](https://python-all.ru/3.8/library/typing.html#typing.Generator) ведёт себя контравариантно, а не ковариантно или инвариантно.769770Если ваш генератор будет только выдавать значения, установите `SendType` и `ReturnType` в `None`:771772```python773def infinite_stream(start: int) -> Generator[int, None, None]:774    while True:775        yield start776        start += 1777```778779В качестве альтернативы аннотируйте генератор как имеющий тип возвращаемого значения либо `Iterable[YieldType]`, либо `Iterator[YieldType]`:780781```python782def infinite_stream(start: int) -> Iterator[int]:783    while True:784        yield start785        start += 1786```787788#### `class typing.AsyncGenerator(AsyncIterator[T_co], Generic[T_co, T_contra])`789790Асинхронный генератор можно аннотировать обобщённым типом `AsyncGenerator[YieldType, SendType]`. Например:791792```python793async def echo_round() -> AsyncGenerator[int, float]:794    sent = yield 0795    while sent >= 0.0:796        rounded = await round(sent)797        sent = yield rounded798```799800В отличие от обычных генераторов, асинхронные генераторы не могут возвращать значение, поэтому параметр типа `ReturnType` отсутствует. Как и в случае с [`Generator`](https://python-all.ru/3.8/library/typing.html#typing.Generator), `SendType` ведёт себя контравариантно.801802Если генератор только выдаёт значения, установите `SendType` в `None`:803804```python805async def infinite_stream(start: int) -> AsyncGenerator[int, None]:806    while True:807        yield start808        start = await increment(start)809```810811В качестве альтернативы аннотируйте генератор как имеющий тип возвращаемого значения либо `AsyncIterable[YieldType]`, либо `AsyncIterator[YieldType]`:812813```python814async def infinite_stream(start: int) -> AsyncIterator[int]:815    while True:816        yield start817        start = await increment(start)818```819820Новое в версии 3.6.1.821822#### `class typing.Text`823824`Text` – это псевдоним для `str`. Он предоставляется для обеспечения совместимости с кодом Python 2: в Python 2 `Text` является псевдонимом для `unicode`.825826Используйте `Text`, чтобы указать, что значение должно содержать строку Unicode, совместимую как с Python 2, так и с Python 3:827828```python829def add_unicode_checkmark(text: Text) -> Text:830    return text + u' \u2713'831```832833Новое в версии 3.5.2.834835#### `class typing.IO`836837#### `class typing.TextIO`838839#### `class typing.BinaryIO`840841Обобщённый тип `IO[AnyStr]` и его подклассы `TextIO(IO[str])` и `BinaryIO(IO[bytes])` представляют типы потоков ввода-вывода, такие как возвращаемые [`open()`](https://python-all.ru/3.8/library/functions.html#open).842843#### `class typing.Pattern`844845#### `class typing.Match`846847Эти псевдонимы типов соответствуют возвращаемым типам из [`re.compile()`](https://python-all.ru/3.8/library/re.html#re.compile) и [`re.match()`](https://python-all.ru/3.8/library/re.html#re.match). Эти типы (и соответствующие функции) являются обобщёнными по `AnyStr` и могут быть конкретизированы записью `Pattern[str]`, `Pattern[bytes]`, `Match[str]` или `Match[bytes]`.848849#### `class typing.NamedTuple`850851Типизированная версия [`collections.namedtuple()`](https://python-all.ru/3.8/library/collections.html#collections.namedtuple).852853Использование:854855```python856class Employee(NamedTuple):857    name: str858    id: int859```860861Это эквивалентно:862863```python864Employee = collections.namedtuple('Employee', ['name', 'id'])865```866867Чтобы задать полю значение по умолчанию, можно присвоить его в теле класса:868869```python870class Employee(NamedTuple):871    name: str872    id: int = 3873874employee = Employee('Guido')875assert employee.id == 3876```877878Поля со значением по умолчанию должны следовать после полей без значения по умолчанию.879880Полученный класс имеет дополнительный атрибут `__annotations__`, который возвращает словарь, сопоставляющий имена полей с их типами. (Имена полей находятся в атрибуте `_fields`, а значения по умолчанию – в атрибуте `_field_defaults`; оба являются частью API namedtuple.)881882Подклассы `NamedTuple` также могут иметь докстринги и методы:883884```python885class Employee(NamedTuple):886    """Представляет сотрудника."""887    name: str888    id: int = 3889890    def __repr__(self) -> str:891        return f'<Employee {self.name}, id={self.id}>'892```893894Обратно совместимое использование:895896```python897Employee = NamedTuple('Employee', [('name', str), ('id', int)])898```899900Изменено в версии 3.6: Добавлена поддержка синтаксиса аннотации переменных [**PEP 526**](https://python-all.ru/3.8/library/typing.html).901902Изменено в версии 3.6.1: Добавлена поддержка значений по умолчанию, методов и строк документации.903904Устарело с версии 3.8, будет удалено в версии 3.9: Устарел атрибут `_field_types` в пользу более стандартного атрибута `__annotations__`, который содержит ту же информацию.905906Изменено в версии 3.8: Атрибуты `_field_types` и `__annotations__` теперь являются обычными словарями, а не экземплярами `OrderedDict`.907908#### `class typing.TypedDict(dict)`909910Простое типизированное пространство имён. Во время выполнения оно эквивалентно обычному [`dict`](https://python-all.ru/3.8/library/stdtypes.html#dict).911912`TypedDict` создаёт тип словаря, который ожидает, что все его экземпляры будут иметь определённый набор ключей, где каждый ключ связан со значением единого типа. Это ожидание не проверяется во время выполнения, а обеспечивается только средствами проверки типов. Использование:913914```python915class Point2D(TypedDict):916    x: int917    y: int918    label: str919920a: Point2D = {'x': 1, 'y': 2, 'label': 'good'}  # ОК921b: Point2D = {'z': 3, 'label': 'bad'}           # Не проходит проверку типов922923assert Point2D(x=1, y=2, label='first') == dict(x=1, y=2, label='first')924```925926Информацию о типе для интроспекции можно получить через `Point2D.__annotations__` и `Point2D.__total__`. Чтобы обеспечить возможность использования этой возможности в старых версиях Python, не поддерживающих [**PEP 526**](https://python-all.ru/3.8/library/typing.html), `TypedDict` поддерживает две дополнительные эквивалентные синтаксические формы:927928```python929Point2D = TypedDict('Point2D', x=int, y=int, label=str)930Point2D = TypedDict('Point2D', {'x': int, 'y': int, 'label': str})931```932933По умолчанию в TypedDict должны присутствовать все ключи. Это можно переопределить, указав totality. Использование:934935```python936class point2D(TypedDict, total=False):937    x: int938    y: int939```940941Это означает, что в TypedDict point2D любой из ключей может быть опущен. Средство проверки типов должно поддерживать только буквальные False или True в качестве значения аргумента total. Значение True используется по умолчанию и делает все элементы, определённые в теле класса, обязательными.942943Смотрите [**PEP 589**](https://python-all.ru/3.8/library/typing.html) для дополнительных примеров и подробных правил использования `TypedDict`.944945Новое в версии 3.8.946947#### `class typing.ForwardRef`948949Класс, используемый для внутреннего представления типов строковых прямых ссылок. Например, `List["SomeClass"]` неявно преобразуется в `List[ForwardRef("SomeClass")]`. Этот класс не должен создаваться пользователем, но может использоваться инструментами интроспекции.950951Новое в версии 3.7.4.952953#### `typing.NewType(name, tp)`954955Вспомогательная функция для указания отдельного типа проверяющему типы, см. [NewType](https://python-all.ru/3.8/library/typing.html#distinct). Во время выполнения она возвращает функцию, которая возвращает свой аргумент. Использование:956957```python958UserId = NewType('UserId', int)959first_user = UserId(1)960```961962Новое в версии 3.5.2.963964#### `typing.cast(typ, val)`965966Приводит значение к типу.967968Это возвращает значение без изменений. Для проверщика типов это сигнализирует, что возвращаемое значение имеет указанный тип, но во время выполнения мы намеренно ничего не проверяем (мы хотим, чтобы это было как можно быстрее).969970#### `typing.get_type_hints(obj[, globals[, locals]])`971972Возвращает словарь, содержащий аннотации типов для функции, метода, модуля или объекта класса.973974Это часто совпадает с `obj.__annotations__`. Кроме того, прямые ссылки, закодированные как строковые литералы, обрабатываются путём вычисления их в пространствах имён `globals` и `locals`. При необходимости `Optional[t]` добавляется для аннотаций функций и методов, если задано значение по умолчанию, равное `None`. Для класса `C` возвращается словарь, построенный объединением всех `__annotations__` по `C.__mro__` в обратном порядке.975976#### `typing.get_origin(tp)`977978#### `typing.get_args(tp)`979980Предоставляют базовую интроспекцию для обобщённых типов и специальных форм typing.981982Для объекта typing вида `X[Y, Z, ...]` эти функции возвращают `X` и `(Y, Z, ...)`. Если `X` является обобщённым псевдонимом встроенного класса или класса [`collections`](https://python-all.ru/3.8/library/collections.html#module-collections), он нормализуется до исходного класса. Для неподдерживаемых объектов возвращают `None` и `()` соответственно. Примеры:983984```python985assert get_origin(Dict[str, int]) is dict986assert get_args(Dict[int, str]) == (int, str)987988assert get_origin(Union[int, str]) is Union989assert get_args(Union[int, str]) == (int, str)990```991992Новое в версии 3.8.993994#### `@typing.overload`995996Декоратор `@overload` позволяет описывать функции и методы, поддерживающие несколько различных комбинаций типов аргументов. За серией определений, декорированных `@overload`, должно следовать ровно одно определение без `@overload` (для той же функции/метода). Определения с `@overload` предназначены только для проверки типов, так как они будут перезаписаны определением без `@overload`, которое используется во время выполнения, но должно игнорироваться проверщиком типов. Во время выполнения прямой вызов функции, декорированной `@overload`, вызовет [`NotImplementedError`](https://python-all.ru/3.8/library/exceptions.html#NotImplementedError). Пример перегрузки, дающей более точный тип, чем можно выразить с помощью объединения или переменной типа:997998```python999@overload1000def process(response: None) -> None:1001    ...1002@overload1003def process(response: int) -> Tuple[int, str]:1004    ...1005@overload1006def process(response: bytes) -> str:1007    ...1008def process(response):1009    <actual implementation>1010```10111012См. [**PEP 484**](https://python-all.ru/3.8/library/typing.html) для подробностей и сравнения с другими семантиками типизации.10131014#### `@typing.final`10151016Декоратор, указывающий проверщикам типов, что декорированный метод нельзя переопределить, а декорированный класс нельзя наследовать. Например:10171018```python1019class Base:1020    @final1021    def done(self) -> None:1022        ...1023class Sub(Base):1024    def done(self) -> None:  # Ошибка, выдаваемая проверщиком типов1025          ...10261027@final1028class Leaf:1029    ...1030class Other(Leaf):  # Ошибка, выдаваемая проверщиком типов1031    ...1032```10331034Проверка этих свойств во время выполнения не выполняется. Подробнее см. [**PEP 591**](https://python-all.ru/3.8/library/typing.html).10351036Новое в версии 3.8.10371038#### `@typing.no_type_check`10391040Декоратор, указывающий, что аннотации не являются подсказками типов.10411042Это работает как декоратор класса или функции [декоратор](https://python-all.ru/3.8/glossary.html#term-decorator). В случае класса он рекурсивно применяется ко всем методам, определённым в этом классе (но не к методам, определённым в его суперклассах или подклассах).10431044Это изменяет функцию(и) на месте.10451046#### `@typing.no_type_check_decorator`10471048Декоратор, придающий другому декоратору эффект [`no_type_check()`](https://python-all.ru/3.8/library/typing.html#typing.no_type_check).10491050Он оборачивает декоратор чем-то, что оборачивает декорированную функцию в [`no_type_check()`](https://python-all.ru/3.8/library/typing.html#typing.no_type_check).10511052#### `@typing.type_check_only`10531054Декоратор, помечающий класс или функцию как недоступные во время выполнения.10551056Сам этот декоратор недоступен во время выполнения. Он в основном предназначен для пометки классов, определённых в файлах заглушек типов (type stub), если реализация возвращает экземпляр закрытого класса:10571058```python1059@type_check_only1060class Response:  # приватный или недоступный во время выполнения1061    code: int1062    def get_header(self, name: str) -> str: ...10631064def fetch_response() -> Response: ...1065```10661067Обратите внимание, что возврат экземпляров закрытых классов не рекомендуется. Обычно предпочтительнее делать такие классы открытыми.10681069#### `@typing.runtime_checkable`10701071Помечает протокольный класс как протокол времени выполнения.10721073Такой протокол может использоваться с [`isinstance()`](https://python-all.ru/3.8/library/functions.html#isinstance) и [`issubclass()`](https://python-all.ru/3.8/library/functions.html#issubclass). При применении к классу, не являющемуся протоколом, возникает [`TypeError`](https://python-all.ru/3.8/library/exceptions.html#TypeError). Это позволяет выполнять простую структурную проверку, очень похожую на “one trick ponies” в [`collections.abc`](https://python-all.ru/3.8/library/collections.abc.html#module-collections.abc), таких как [`Iterable`](https://python-all.ru/3.8/library/collections.abc.html#collections.abc.Iterable). Например:10741075```python1076@runtime_checkable1077class Closable(Protocol):1078    def close(self): ...10791080assert isinstance(open('/some/file'), Closable)1081```10821083**Предупреждение:** это проверяет только наличие необходимых методов, а не их сигнатуры типов!10841085Новое в версии 3.8.10861087#### `typing.Any`10881089Специальный тип, указывающий на неограниченный тип.10901091- Каждый тип совместим с [`Any`](https://python-all.ru/3.8/library/typing.html#typing.Any).1092- [`Any`](https://python-all.ru/3.8/library/typing.html#typing.Any) совместим с каждым типом.10931094#### `typing.NoReturn`10951096Специальный тип, указывающий, что функция никогда не возвращает значение. Например:10971098```python1099from typing import NoReturn11001101def stop() -> NoReturn:1102    raise RuntimeError('no way')1103```11041105Новое в версии 3.5.4.11061107Новое в версии 3.6.2.11081109#### `typing.Union`11101111Тип объединения; `Union[X, Y]` означает либо X, либо Y.11121113Чтобы определить объединение, используйте, например, `Union[int, str]`. Подробности:11141115- Аргументы должны быть типами, и их должно быть как минимум один.1116- Объединения объединений разворачиваются, например:11171118  ```python1119  Union[Union[int, str], float] == Union[int, str, float]1120  ```1121- Объединения из одного аргумента исчезают, например:11221123  ```python1124  Union[int] == int  # Конструктор на самом деле возвращает int1125  ```1126- Повторяющиеся аргументы пропускаются, например:11271128  ```python1129  Union[int, str, int] == Union[int, str]1130  ```1131- При сравнении объединений порядок аргументов игнорируется, например:11321133  ```python1134  Union[int, str] == Union[str, int]1135  ```1136- Нельзя создавать подкласс или экземпляр объединения.1137- Нельзя записать `Union[X][Y]`.1138- Можно использовать `Optional[X]` как сокращение для `Union[X, None]`.11391140Изменено в версии 3.7: Явные подклассы не удаляются из объединений во время выполнения.11411142#### `typing.Optional`11431144Тип Optional.11451146`Optional[X]` эквивалентно `Union[X, None]`.11471148Обратите внимание, что это не то же самое, что необязательный аргумент, который имеет значение по умолчанию. Необязательный аргумент с значением по умолчанию не требует квалификатора `Optional` в своей аннотации типа только потому, что он необязателен. Например:11491150```python1151def foo(arg: int = 0) -> None:1152    ...1153```11541155С другой стороны, если явное значение `None` допускается, то использование `Optional` уместно, независимо от того, является ли аргумент необязательным или нет. Например:11561157```python1158def foo(arg: Optional[int] = None) -> None:1159    ...1160```11611162#### `typing.Tuple`11631164Тип кортежа; `Tuple[X, Y]` – это тип кортежа из двух элементов, где первый элемент имеет тип X, а второй – Y. Тип пустого кортежа может быть записан как `Tuple[()]`.11651166Пример: `Tuple[T1, T2]` – это кортеж из двух элементов, соответствующих переменным типа T1 и T2. `Tuple[int, float, str]` – это кортеж из int, float и строки.11671168Чтобы задать кортеж переменной длины из однотипных элементов, используйте литеральное многоточие, например `Tuple[int, ...]`. Простой [`Tuple`](https://python-all.ru/3.8/library/typing.html#typing.Tuple) эквивалентен `Tuple[Any, ...]`, а тот, в свою очередь, [`tuple`](https://python-all.ru/3.8/library/stdtypes.html#tuple).11691170#### `typing.Callable`11711172Тип Callable; `Callable[[int], str]` – это функция вида (int) -\> str.11731174Синтаксис индексирования всегда должен использоваться ровно с двумя значениями: списком аргументов и типом возвращаемого значения. Список аргументов должен быть списком типов или многоточием; тип возвращаемого значения должен быть одним типом.11751176Нет синтаксиса для указания необязательных или именованных аргументов; такие типы функций редко используются в качестве типов колбэков. `Callable[..., ReturnType]` (буквальное многоточие) можно использовать для аннотации вызываемого объекта, принимающего любое количество аргументов и возвращающего `ReturnType`. Обычное [`Callable`](https://python-all.ru/3.8/library/typing.html#typing.Callable) эквивалентно `Callable[..., Any]`, а в свою очередь – [`collections.abc.Callable`](https://python-all.ru/3.8/library/collections.abc.html#collections.abc.Callable).11771178#### `typing.Literal`11791180Тип, который можно использовать для указания средствам проверки типов, что соответствующая переменная или параметр функции имеет значение, эквивалентное предоставленному литералу (или одному из нескольких литералов). Например:11811182```python1183def validate_simple(data: Any) -> Literal[True]:  # всегда возвращает True1184    ...11851186MODE = Literal['r', 'rb', 'w', 'wb']1187def open_helper(file: str, mode: MODE) -> str:1188    ...11891190open_helper('/some/path', 'r')  # Проходит проверку типов1191open_helper('/other/path', 'typo')  # Ошибка в тайпчекере1192```11931194`Literal[...]` нельзя наследовать. Во время выполнения произвольное значение допускается в качестве аргумента типа для `Literal[...]`, но проверяющие типа могут накладывать ограничения. См. [**PEP 586**](https://python-all.ru/3.8/library/typing.html) для получения дополнительных сведений о литеральных типах.11951196Новое в версии 3.8.11971198#### `typing.ClassVar`11991200Специальная конструкция типа для пометки переменных класса.12011202Как представлено в [**PEP 526**](https://python-all.ru/3.8/library/typing.html), аннотация переменной, обёрнутая в ClassVar, указывает, что данный атрибут предназначен для использования в качестве переменной класса и не должен устанавливаться на экземплярах этого класса. Использование:12031204```python1205class Starship:1206    stats: ClassVar[Dict[str, int]] = {} # переменная класса1207    damage: int = 10                     # переменная экземпляра1208```12091210[`ClassVar`](https://python-all.ru/3.8/library/typing.html#typing.ClassVar) принимает только типы и не может быть дополнительно индексирован.12111212[`ClassVar`](https://python-all.ru/3.8/library/typing.html#typing.ClassVar) сам по себе не является классом и не должен использоваться с [`isinstance()`](https://python-all.ru/3.8/library/functions.html#isinstance) или [`issubclass()`](https://python-all.ru/3.8/library/functions.html#issubclass). [`ClassVar`](https://python-all.ru/3.8/library/typing.html#typing.ClassVar) не меняет поведение Python во время выполнения, но может использоваться сторонними проверяющими типов. Например, проверяющий типов может отметить следующий код как ошибочный:12131214```python1215enterprise_d = Starship(3000)1216enterprise_d.stats = {} # Ошибка: установка переменной класса на экземпляре1217Starship.stats = {}     # Это корректно.1218```12191220Новое в версии 3.5.3.12211222#### `typing.Final`12231224Специальная конструкция типов для указания средствам проверки типов, что имя не может быть переприсвоено или переопределено в подклассе. Например:12251226```python1227MAX_SIZE: Final = 90001228MAX_SIZE += 1  # Ошибка, выдаваемая проверщиком типов12291230class Connection:1231    TIMEOUT: Final[int] = 1012321233class FastConnector(Connection):1234    TIMEOUT = 1  # Ошибка, выдаваемая проверщиком типов1235```12361237Проверка этих свойств во время выполнения не выполняется. Подробнее см. [**PEP 591**](https://python-all.ru/3.8/library/typing.html).12381239Новое в версии 3.8.12401241#### `typing.AnyStr`12421243`AnyStr` – это переменная типа, определённая как `AnyStr = TypeVar('AnyStr', str, bytes)`.12441245Предназначен для функций, которые могут принимать строки любого типа, не допуская смешивания разных типов строк. Например:12461247```python1248def concat(a: AnyStr, b: AnyStr) -> AnyStr:1249    return a + b12501251concat(u"foo", u"bar")  # Ок, результат имеет тип 'unicode'1252concat(b"foo", b"bar")  # Ок, результат имеет тип 'bytes'1253concat(u"foo", b"bar")  # Ошибка, нельзя смешивать unicode и bytes1254```12551256#### `typing.TYPE_CHECKING`12571258Специальная константа, которая считается `True` сторонними статическими проверщиками типов. Во время выполнения она равна `False`. Применение:12591260```python1261if TYPE_CHECKING:1262    import expensive_mod12631264def fun(arg: 'expensive_mod.SomeType') -> None:1265    local_var: expensive_mod.AnotherType = other_fun()1266```12671268Обратите внимание, что первая аннотация типа должна быть заключена в кавычки, что делает её «отложенной ссылкой» (forward reference), чтобы скрыть ссылку `expensive_mod` от интерпретатора во время выполнения. Аннотации типов для локальных переменных не вычисляются, поэтому вторую аннотацию заключать в кавычки не нужно.12691270Новое в версии 3.5.2.1271