typing.md

1> **Источник:** https://python-all.ru/3.10/library/typing.html2>3> «Документация Python на русском» – неофициальный перевод официальной документации Python: версии от 2.6 до 3.16, полнотекстовый поиск, английский оригинал рядом с переводом. Эта Markdown-версия страницы предназначена для работы с LLM: вставьте её в ChatGPT, Claude или Cursor.45---67# [`typing`](https://python-all.ru/3.10/library/typing.html#module-typing) – Поддержка аннотаций типов89Новое в версии 3.5.1011**Исходный код:** [Lib/typing.py](https://python-all.ru/src/3.10/Lib/typing.py)1213> **Примечание**14>15> Среда выполнения Python не проверяет аннотации типов функций и переменных. Они могут использоваться сторонними инструментами, такими как средства проверки типов, IDE, линтеры и т. д.1617---1819Данный модуль предоставляет поддержку аннотаций типов на уровне выполнения. Самая базовая поддержка включает типы [`Any`](https://python-all.ru/3.10/library/typing.html#typing.Any), [`Union`](https://python-all.ru/3.10/library/typing.html#typing.Union), [`Callable`](https://python-all.ru/3.10/library/typing.html#typing.Callable), [`TypeVar`](https://python-all.ru/3.10/library/typing.html#typing.TypeVar) и [`Generic`](https://python-all.ru/3.10/library/typing.html#typing.Generic). Полную спецификацию см. в [**PEP 484**](https://python-all.ru/3.10/library/typing.html). Для упрощённого введения в аннотации типов см. [**PEP 483**](https://python-all.ru/3.10/library/typing.html).2021Функция ниже принимает и возвращает строку и аннотирована следующим образом:2223```python24def greeting(name: str) -> str:25    return 'Hello ' + name26```2728В функции `greeting` аргумент `name` ожидается типа [`str`](https://python-all.ru/3.10/library/stdtypes.html#str), а возвращаемый тип – [`str`](https://python-all.ru/3.10/library/stdtypes.html#str). Подтипы допускаются в качестве аргументов.2930Новые функции часто добавляются в модуль `typing`. Пакет [typing\_extensions](https://python-all.ru/3.10/library/typing.html) предоставляет бэкпорты этих новых функций для старых версий Python.3132> **См. также**33>34> Для быстрого ознакомления с аннотациями типов обратитесь к [этому краткому справочнику](https://python-all.ru/3.10/library/typing.html).35>36> Раздел «Справочник по системе типов» из [https://mypy.readthedocs.io/](https://python-all.ru/3.10/library/typing.html) – поскольку система аннотаций Python стандартизирована через PEP, данный справочник должен быть в целом применим к большинству проверяющих типы, хотя некоторые части могут по-прежнему относиться к mypy.37>38> Документация на [https://typing.readthedocs.io/](https://python-all.ru/3.10/library/typing.html) служит полезным справочником по возможностям системы типов, полезным инструментам для аннотаций и лучшим практикам.3940## Соответствующие PEP4142С момента первого появления аннотаций типов в [**PEP 484**](https://python-all.ru/3.10/library/typing.html) и [**PEP 483**](https://python-all.ru/3.10/library/typing.html) ряд PEP изменил и расширил инфраструктуру Python для аннотаций типов. К ним относятся:4344- **[**PEP 526**](https://python-all.ru/3.10/library/typing.html): Синтаксис аннотаций переменных**4546  *Вводит* синтаксис аннотирования переменных вне определений функций, а также [`ClassVar`](https://python-all.ru/3.10/library/typing.html#typing.ClassVar)47- **[**PEP 544**](https://python-all.ru/3.10/library/typing.html): Протоколы: структурная типизация (статическая утиная типизация)**4849  *Вводит* [`Protocol`](https://python-all.ru/3.10/library/typing.html#typing.Protocol) и декоратор [`@runtime_checkable`](https://python-all.ru/3.10/library/typing.html#typing.runtime_checkable)50- **[**PEP 585**](https://python-all.ru/3.10/library/typing.html): Обобщённые типы в стандартных коллекциях**5152  *Вводит* [`types.GenericAlias`](https://python-all.ru/3.10/library/types.html#types.GenericAlias) и возможность использовать классы стандартной библиотеки как [обобщённые типы](https://python-all.ru/3.10/library/stdtypes.html#types-genericalias)53- **[**PEP 586**](https://python-all.ru/3.10/library/typing.html): Литеральные типы**5455  *Представлен* [`Literal`](https://python-all.ru/3.10/library/typing.html#typing.Literal)56- **[**PEP 589**](https://python-all.ru/3.10/library/typing.html): TypedDict: аннотации типов для словарей с фиксированным набором ключей**5758  *Представлен* [`TypedDict`](https://python-all.ru/3.10/library/typing.html#typing.TypedDict)59- **[**PEP 591**](https://python-all.ru/3.10/library/typing.html): Добавление квалификатора final в typing**6061  *Вводит* [`Final`](https://python-all.ru/3.10/library/typing.html#typing.Final) и декоратор [`@final`](https://python-all.ru/3.10/library/typing.html#typing.final)62- **[**PEP 593**](https://python-all.ru/3.10/library/typing.html): Гибкие аннотации функций и переменных**6364  *Представлен* [`Annotated`](https://python-all.ru/3.10/library/typing.html#typing.Annotated)65- **[**PEP 604**](https://python-all.ru/3.10/library/typing.html): Разрешение записи объединённых типов как `X | Y`**6667  *Вводит* [`types.UnionType`](https://python-all.ru/3.10/library/types.html#types.UnionType) и возможность использовать бинарный оператор ИЛИ `|` для обозначения [объединения типов](https://python-all.ru/3.10/library/stdtypes.html#types-union)68- **[**PEP 612**](https://python-all.ru/3.10/library/typing.html): Переменные спецификации параметров**6970  *Представлен* [`ParamSpec`](https://python-all.ru/3.10/library/typing.html#typing.ParamSpec) и [`Concatenate`](https://python-all.ru/3.10/library/typing.html#typing.Concatenate)71- **[**PEP 613**](https://python-all.ru/3.10/library/typing.html): Явные псевдонимы типов**7273  *Представлен* [`TypeAlias`](https://python-all.ru/3.10/library/typing.html#typing.TypeAlias)74- **[**PEP 647**](https://python-all.ru/3.10/library/typing.html): Защитники типов, определяемые пользователем**7576  *Представлен* [`TypeGuard`](https://python-all.ru/3.10/library/typing.html#typing.TypeGuard)7778## Псевдонимы типов7980Псевдоним типа определяется присваиванием типа псевдониму. В этом примере `Vector` и `list[float]` будут рассматриваться как взаимозаменяемые синонимы:8182```python83Vector = list[float]8485def scale(scalar: float, vector: Vector) -> Vector:86    return [scalar * num for num in vector]8788# проходит проверку типов; список чисел с плавающей точкой считается Vector.89new_vector = scale(2.0, [1.0, -4.2, 5.4])90```9192Псевдонимы типов полезны для упрощения сложных сигнатур типов. Например:9394```python95from collections.abc import Sequence9697ConnectionOptions = dict[str, str]98Address = tuple[str, int]99Server = tuple[Address, ConnectionOptions]100101def broadcast_message(message: str, servers: Sequence[Server]) -> None:102    ...103104# Статическая проверка типов будет считать предыдущую сигнатуру типа как105# полностью эквивалентную этой.106def broadcast_message(107        message: str,108        servers: Sequence[tuple[tuple[str, int], dict[str, str]]]) -> None:109    ...110```111112Обратите внимание, что `None` как аннотация типа является особым случаем и заменяется на `type(None)`.113114## NewType115116Используйте вспомогательную функцию [`NewType`](https://python-all.ru/3.10/library/typing.html#typing.NewType) для создания отдельных типов:117118```python119from typing import NewType120121UserId = NewType('UserId', int)122some_id = UserId(524313)123```124125Статический проверщик типов будет рассматривать новый тип как подкласс исходного типа. Это полезно для выявления логических ошибок:126127```python128def get_user_name(user_id: UserId) -> str:129    ...130131# проходит проверку типов132user_a = get_user_name(UserId(42351))133134# не проходит проверку типов; int не является UserId135user_b = get_user_name(-1)136```137138Можно по-прежнему выполнять все операции `int` над переменной типа `UserId`, но результат всегда будет типа `int`. Это позволяет передавать `UserId` везде, где может ожидаться `int`, но предотвращает случайное создание `UserId` недопустимым способом:139140```python141# 'output' имеет тип 'int', а не 'UserId'142output = UserId(23413) + UserId(54341)143```144145Обратите внимание, что эти проверки выполняются только статическим проверщиком типов. Во время выполнения оператор `Derived = NewType('Derived', Base)` сделает `Derived` вызываемым объектом, который немедленно возвращает любой переданный ему параметр. Это означает, что выражение `Derived(some_value)` не создаёт новый класс и не вносит значительных накладных расходов по сравнению с обычным вызовом функции.146147Точнее, выражение `some_value is Derived(some_value)` во время выполнения всегда истинно.148149Недопустимо создание подтипа `Derived`:150151```python152from typing import NewType153154UserId = NewType('UserId', int)155156# Завершается ошибкой во время выполнения и не проходит проверку типов157class AdminUserId(UserId): pass158```159160Однако можно создать [`NewType`](https://python-all.ru/3.10/library/typing.html#typing.NewType) на основе «производного» `NewType`:161162```python163from typing import NewType164165UserId = NewType('UserId', int)166167ProUserId = NewType('ProUserId', UserId)168```169170и проверка типов для `ProUserId` будет работать как ожидается.171172Подробнее см. [**PEP 484**](https://python-all.ru/3.10/library/typing.html).173174> **Примечание**175>176> Напомним, что использование псевдонима типа объявляет два типа *эквивалентными* друг другу. Использование `Alias = Original` заставит статический анализатор типов считать `Alias` *точно эквивалентным* `Original` во всех случаях. Это полезно, когда требуется упростить сложные сигнатуры типов.177>178> В отличие от этого, `NewType` объявляет один тип *подтипом* другого. Использование `Derived = NewType('Derived', Original)` заставит статический анализатор типов считать `Derived` *подклассом* `Original`, что означает, что значение типа `Original` не может использоваться там, где ожидается значение типа `Derived`. Это полезно для предотвращения логических ошибок с минимальными затратами времени выполнения.179180Новое в версии 3.5.2.181182Изменено в версии 3.10: `NewType` теперь является классом, а не функцией. Вызов `NewType` вместо обычной функции влечёт некоторые дополнительные накладные расходы во время выполнения. Однако эти расходы будут уменьшены в версии 3.11.0.183184## Callable185186Фреймворки, ожидающие функции обратного вызова с определённой сигнатурой, могут быть аннотированы с помощью `Callable[[Arg1Type, Arg2Type], ReturnType]`.187188Например:189190```python191from collections.abc import Callable192193def feeder(get_next_item: Callable[[], str]) -> None:194    # Тело195196def async_query(on_success: Callable[[int], None],197                on_error: Callable[[int, Exception], None]) -> None:198    # Тело199200async def on_update(value: str) -> None:201    # Тело202callback: Callable[[str], Awaitable[None]] = on_update203```204205Можно объявить возвращаемый тип вызываемого объекта, не указывая сигнатуру вызова, заменив список аргументов многоточием в аннотации типа: `Callable[..., ReturnType]`.206207Объекты, принимающие другие вызываемые объекты в качестве аргументов, могут указать, что их типы параметров зависят друг от друга, с помощью [`ParamSpec`](https://python-all.ru/3.10/library/typing.html#typing.ParamSpec). Кроме того, если такой вызываемый объект добавляет или удаляет аргументы из других вызываемых объектов, может использоваться оператор [`Concatenate`](https://python-all.ru/3.10/library/typing.html#typing.Concatenate). Они имеют соответственно форму `Callable[ParamSpecVariable, ReturnType]` и `Callable[Concatenate[Arg1Type, Arg2Type, ..., ParamSpecVariable], ReturnType]`.208209Changed in version 3.10: `Callable` now supports [`ParamSpec`](https://python-all.ru/3.10/library/typing.html#typing.ParamSpec) and [`Concatenate`](https://python-all.ru/3.10/library/typing.html#typing.Concatenate). See [**PEP 612**](https://python-all.ru/3.10/library/typing.html) for more details.210211> **См. также**212>213> В документации к [`ParamSpec`](https://python-all.ru/3.10/library/typing.html#typing.ParamSpec) и [`Concatenate`](https://python-all.ru/3.10/library/typing.html#typing.Concatenate) приведены примеры использования в `Callable`.214215## Обобщённые типы216217Поскольку информацию о типах объектов, хранящихся в контейнерах, нельзя статически вывести обобщённым способом, абстрактные базовые классы были расширены для поддержки параметризации типами, чтобы обозначить ожидаемые типы элементов контейнера.218219```python220from collections.abc import Mapping, Sequence221222def notify_by_email(employees: Sequence[Employee],223                    overrides: Mapping[str, str]) -> None: ...224```225226Обобщённые типы можно параметризовать с помощью фабрики, доступной в typing под названием [`TypeVar`](https://python-all.ru/3.10/library/typing.html#typing.TypeVar).227228```python229from collections.abc import Sequence230from typing import TypeVar231232T = TypeVar('T')      # Объявить переменную типа233234def first(l: Sequence[T]) -> T:   # Обобщённая функция235    return l[0]236```237238## Пользовательские обобщённые типы239240Пользовательский класс можно определить как обобщённый класс.241242```python243from typing import TypeVar, Generic244from logging import Logger245246T = TypeVar('T')247248class LoggedVar(Generic[T]):249    def __init__(self, value: T, name: str, logger: Logger) -> None:250        self.name = name251        self.logger = logger252        self.value = value253254    def set(self, new: T) -> None:255        self.log('Set ' + repr(self.value))256        self.value = new257258    def get(self) -> T:259        self.log('Get ' + repr(self.value))260        return self.value261262    def log(self, message: str) -> None:263        self.logger.info('%s: %s', self.name, message)264```265266`Generic[T]` в качестве базового класса определяет, что класс `LoggedVar` принимает один параметр типа `T`. Это также делает `T` допустимым типом внутри тела класса.267268Базовый класс [`Generic`](https://python-all.ru/3.10/library/typing.html#typing.Generic) определяет [`__class_getitem__()`](https://python-all.ru/3.10/reference/datamodel.html#object.__class_getitem__) так, что `LoggedVar[T]` является допустимым типом:269270```python271from collections.abc import Iterable272273def zero_all_vars(vars: Iterable[LoggedVar[int]]) -> None:274    for var in vars:275        var.set(0)276```277278Обобщённый тип может иметь любое количество переменных типа. Все разновидности [`TypeVar`](https://python-all.ru/3.10/library/typing.html#typing.TypeVar) допустимы в качестве параметров обобщённого типа:279280```python281from typing import TypeVar, Generic, Sequence282283T = TypeVar('T', contravariant=True)284B = TypeVar('B', bound=Sequence[bytes], covariant=True)285S = TypeVar('S', int, str)286287class WeirdTrio(Generic[T, B, S]):288    ...289```290291Каждый аргумент-переменная типа для [`Generic`](https://python-all.ru/3.10/library/typing.html#typing.Generic) должен быть уникальным. Поэтому такой код некорректен:292293```python294from typing import TypeVar, Generic295...296297T = TypeVar('T')298299class Pair(Generic[T, T]):   # INVALID300    ...301```302303Можно использовать множественное наследование с [`Generic`](https://python-all.ru/3.10/library/typing.html#typing.Generic):304305```python306from collections.abc import Sized307from typing import TypeVar, Generic308309T = TypeVar('T')310311class LinkedList(Sized, Generic[T]):312    ...313```314315При наследовании от обобщённых классов некоторые переменные типа могут быть зафиксированы:316317```python318from collections.abc import Mapping319from typing import TypeVar320321T = TypeVar('T')322323class MyDict(Mapping[str, T]):324    ...325```326327В этом случае `MyDict` имеет один параметр – `T`.328329Использование обобщённого класса без указания параметров типа подразумевает [`Any`](https://python-all.ru/3.10/library/typing.html#typing.Any) для каждой позиции. В следующем примере `MyIterable` не является обобщённым, но неявно наследуется от `Iterable[Any]`:330331```python332from collections.abc import Iterable333334class MyIterable(Iterable): # То же, что и Iterable[Any].335```336337Пользовательские обобщённые псевдонимы типов также поддерживаются. Примеры:338339```python340from collections.abc import Iterable341from typing import TypeVar342S = TypeVar('S')343Response = Iterable[S] | int344345# Тип возвращаемого значения здесь такой же, как Iterable[str] | int346def response(query: str) -> Response[str]:347    ...348349T = TypeVar('T', int, float, complex)350Vec = Iterable[tuple[T, T]]351352def inproduct(v: Vec[T]) -> T: # То же, что и Iterable[tuple[T, T]]353    return sum(x*y for x, y in v)354```355356Изменено в версии 3.7: [`Generic`](https://python-all.ru/3.10/library/typing.html#typing.Generic) больше не имеет собственного метакласса.357358Пользовательские обобщённые типы для выражений параметров также поддерживаются через переменные спецификации параметров в форме `Generic[P]`. Поведение согласуется с описанными выше переменными типов, так как переменные спецификации параметров обрабатываются модулем typing как специализированные переменные типов. Единственное исключение состоит в том, что список типов может использоваться для подстановки [`ParamSpec`](https://python-all.ru/3.10/library/typing.html#typing.ParamSpec):359360```python361>>> from typing import Generic, ParamSpec, TypeVar362363>>> T = TypeVar('T')364>>> P = ParamSpec('P')365366>>> class Z(Generic[T, P]): ...367...368>>> Z[int, [dict, float]]369__main__.Z[int, (<class 'dict'>, <class 'float'>)]370```371372Кроме того, обобщённый (generic) с единственной переменной спецификации параметра будет принимать списки параметров в виде `X[[Type1, Type2, ...]]`, а также `X[Type1, Type2, ...]` из эстетических соображений. Внутренне последний преобразуется в первый, поэтому следующие эквивалентны:373374```python375>>> class X(Generic[P]): ...376...377>>> X[int, str]378__main__.X[(<class 'int'>, <class 'str'>)]379>>> X[[int, str]]380__main__.X[(<class 'int'>, <class 'str'>)]381```382383Обратите внимание, что обобщённые типы с [`ParamSpec`](https://python-all.ru/3.10/library/typing.html#typing.ParamSpec) могут иметь некорректный `__parameters__` после подстановки в некоторых случаях, так как они предназначены в первую очередь для статической проверки типов.384385Изменено в версии 3.10: [`Generic`](https://python-all.ru/3.10/library/typing.html#typing.Generic) теперь можно параметризовать по выражениям параметров. Подробнее см. [`ParamSpec`](https://python-all.ru/3.10/library/typing.html#typing.ParamSpec) и [**PEP 612**](https://python-all.ru/3.10/library/typing.html).386387Пользовательский обобщённый класс может иметь ABC в качестве базовых классов без конфликта метаклассов. Обобщённые метаклассы не поддерживаются. Результат параметризации обобщённых типов кэшируется, и большинство типов в модуле typing являются [хэшируемыми](https://python-all.ru/3.10/glossary.html#term-hashable) и сравнимыми на равенство.388389## Тип [`Any`](https://python-all.ru/3.10/library/typing.html#typing.Any)390391Особым видом типа является [`Any`](https://python-all.ru/3.10/library/typing.html#typing.Any). Статический проверяющий типов будет считать каждый тип совместимым с [`Any`](https://python-all.ru/3.10/library/typing.html#typing.Any), а [`Any`](https://python-all.ru/3.10/library/typing.html#typing.Any) – совместимым с каждым типом.392393Это означает, что над значением типа [`Any`](https://python-all.ru/3.10/library/typing.html#typing.Any) можно выполнять любые операции или вызовы методов и присваивать его любой переменной:394395```python396from typing import Any397398a: Any = None399a = []          # ОК400a = 2           # ОК401402s: str = ''403s = a           # ОК404405def foo(item: Any) -> int:406    # Проходит проверку типов; 'item' может быть любого типа,407    # и этот тип может иметь метод 'bar'408    item.bar()409    ...410```411412Обратите внимание: при присваивании значения типа [`Any`](https://python-all.ru/3.10/library/typing.html#typing.Any) более точному типу проверка типов не выполняется. Например, статический анализатор типов не сообщил об ошибке при присваивании `a` переменной `s`, хотя `s` была объявлена как тип [`str`](https://python-all.ru/3.10/library/stdtypes.html#str) и во время выполнения получает значение [`int`](https://python-all.ru/3.10/library/functions.html#int)!413414Кроме того, все функции без указания типа возврата или типов параметров по умолчанию неявно используют [`Any`](https://python-all.ru/3.10/library/typing.html#typing.Any):415416```python417def legacy_parser(text):418    ...419    return data420421# Статический проверщик типов будет рассматривать вышеприведенное422# как имеющее ту же сигнатуру, что и:423def legacy_parser(text: Any) -> Any:424    ...425    return data426```427428Такое поведение позволяет использовать [`Any`](https://python-all.ru/3.10/library/typing.html#typing.Any) в качестве *запасного выхода*, когда нужно смешивать динамически и статически типизированный код.429430Сравните поведение [`Any`](https://python-all.ru/3.10/library/typing.html#typing.Any) с поведением [`object`](https://python-all.ru/3.10/library/functions.html#object). Как и [`Any`](https://python-all.ru/3.10/library/typing.html#typing.Any), каждый тип является подтипом [`object`](https://python-all.ru/3.10/library/functions.html#object). Однако, в отличие от [`Any`](https://python-all.ru/3.10/library/typing.html#typing.Any), обратное неверно: [`object`](https://python-all.ru/3.10/library/functions.html#object) *не* является подтипом любого другого типа.431432Это означает, что когда тип значения – [`object`](https://python-all.ru/3.10/library/functions.html#object), проверяющий типы будет отклонять почти все операции над ним, а присваивание его переменной (или использование в качестве возвращаемого значения) более специализированного типа является ошибкой типа. Например:433434```python435def hash_a(item: object) -> int:436    # Не проходит проверку типов; у объекта нет метода 'magic'.437    item.magic()438    ...439440def hash_b(item: Any) -> int:441    # Проходит проверку типов442    item.magic()443    ...444445# Проходит проверку типов, так как int и str являются подклассами object446hash_a(42)447hash_a("foo")448449# Проходит проверку типов, так как Any совместим со всеми типами450hash_b(42)451hash_b("foo")452```453454Используйте [`object`](https://python-all.ru/3.10/library/functions.html#object), чтобы указать, что значение может быть любого типа в типобезопасной манере. Используйте [`Any`](https://python-all.ru/3.10/library/typing.html#typing.Any), чтобы указать, что значение динамически типизировано.455456## Номинальная и структурная типизация457458Изначально [**PEP 484**](https://python-all.ru/3.10/library/typing.html) определял систему статической типизации Python как использующую *номинальное подтипирование*. Это означает, что класс `A` разрешён там, где ожидается класс `B`, если и только если `A` является подклассом `B`.459460Ранее это требование также применялось к абстрактным базовым классам, таким как [`Iterable`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.Iterable). Проблема такого подхода в том, что класс должен быть явно помечен для их поддержки, что непитонично и не похоже на то, что обычно делается в идиоматическом динамически типизированном коде Python. Например, следующее соответствует [**PEP 484**](https://python-all.ru/3.10/library/typing.html):461462```python463from collections.abc import Sized, Iterable, Iterator464465class Bucket(Sized, Iterable[int]):466    ...467    def __len__(self) -> int: ...468    def __iter__(self) -> Iterator[int]: ...469```470471[**PEP 544**](https://python-all.ru/3.10/library/typing.html) позволяет решить эту проблему, разрешая пользователям писать приведённый выше код без явных базовых классов в определении класса, что позволяет `Bucket` неявно считаться подтипом как `Sized`, так и `Iterable[int]` статическими проверяющими типов. Это называется *структурной подтипизацией* (или статической утиной типизацией):472473```python474from collections.abc import Iterator, Iterable475476class Bucket:  # Примечание: базовые классы отсутствуют477    ...478    def __len__(self) -> int: ...479    def __iter__(self) -> Iterator[int]: ...480481def collect(items: Iterable[int]) -> int: ...482result = collect(Bucket())  # Проходит проверку типов483```484485Более того, наследуя специальный класс [`Protocol`](https://python-all.ru/3.10/library/typing.html#typing.Protocol), пользователь может определять новые пользовательские протоколы, чтобы в полной мере использовать структурное подтипирование (см. примеры ниже).486487## Содержимое модуля488489Модуль определяет следующие классы, функции и декораторы.490491> **Примечание**492>493> Данный модуль определяет несколько типов, которые являются подклассами уже существующих классов стандартной библиотеки и которые также расширяют [`Generic`](https://python-all.ru/3.10/library/typing.html#typing.Generic) для поддержки переменных типа внутри `[]`. Эти типы стали избыточными в Python 3.9, когда соответствующие существовавшие классы были расширены для поддержки `[]`.494>495> Избыточные типы объявлены устаревшими начиная с Python 3.9, но интерпретатор не будет выдавать предупреждений об устаревании. Ожидается, что средства проверки типов будут помечать устаревшие типы, если проверяемая программа нацелена на Python 3.9 или новее.496>497> Устаревшие типы будут удалены из модуля [`typing`](https://python-all.ru/3.10/library/typing.html#module-typing) в первой версии Python, выпущенной через 5 лет после выхода Python 3.9.0. Подробнее см. в [**PEP 585**](https://python-all.ru/3.10/library/typing.html)–*Аннотации обобщённых типов в стандартных коллекциях*.498499### Специальные примитивы типизации500501#### Специальные типы502503Их можно использовать как типы в аннотациях, и они не поддерживают `[]`.504505#### `typing.Any`506507Специальный тип, указывающий на неограниченный тип.508509- Каждый тип совместим с [`Any`](https://python-all.ru/3.10/library/typing.html#typing.Any).510- [`Any`](https://python-all.ru/3.10/library/typing.html#typing.Any) совместим с каждым типом.511512#### `typing.NoReturn`513514Специальный тип, указывающий, что функция никогда не возвращает значение. Например:515516```python517from typing import NoReturn518519def stop() -> NoReturn:520    raise RuntimeError('no way')521```522523Новое в версии 3.5.4.524525Новое в версии 3.6.2.526527#### `typing.TypeAlias`528529Специальная аннотация для явного объявления [псевдонима типа](https://python-all.ru/3.10/library/typing.html#type-aliases). Например:530531```python532from typing import TypeAlias533534Factors: TypeAlias = list[int]535```536537См. [**PEP 613**](https://python-all.ru/3.10/library/typing.html) для получения дополнительных сведений о явных псевдонимах типов.538539Новое в версии 3.10.540541#### Специальные формы542543Их можно использовать как типы в аннотациях с помощью `[]`, каждый имеет уникальный синтаксис.544545#### `typing.Tuple`546547Тип кортежа; `Tuple[X, Y]` – это тип кортежа из двух элементов, где первый элемент имеет тип X, а второй – Y. Тип пустого кортежа может быть записан как `Tuple[()]`.548549Пример: `Tuple[T1, T2]` – это кортеж из двух элементов, соответствующих переменным типа T1 и T2. `Tuple[int, float, str]` – это кортеж из int, float и строки.550551Чтобы задать кортеж переменной длины из однотипных элементов, используйте литеральное многоточие, например `Tuple[int, ...]`. Простой [`Tuple`](https://python-all.ru/3.10/library/typing.html#typing.Tuple) эквивалентен `Tuple[Any, ...]`, а тот, в свою очередь, [`tuple`](https://python-all.ru/3.10/library/stdtypes.html#tuple).552553Deprecated since version 3.9: [`builtins.tuple`](https://python-all.ru/3.10/library/stdtypes.html#tuple) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.10/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.10/library/stdtypes.html#types-genericalias).554555#### `typing.Union`556557Тип объединения; `Union[X, Y]` эквивалентно `X | Y` и означает X или Y.558559Для определения объединения используйте, например, `Union[int, str]` или сокращённую запись `int | str`. Рекомендуется использовать сокращённую запись. Подробности:560561- Аргументы должны быть типами, и их должно быть как минимум один.562- Объединения объединений разворачиваются, например:563564  ```python565  Union[Union[int, str], float] == Union[int, str, float]566  ```567- Объединения из одного аргумента исчезают, например:568569  ```python570  Union[int] == int  # Конструктор на самом деле возвращает int571  ```572- Повторяющиеся аргументы пропускаются, например:573574  ```python575  Union[int, str, int] == Union[int, str] == int | str576  ```577- При сравнении объединений порядок аргументов игнорируется, например:578579  ```python580  Union[int, str] == Union[str, int]581  ```582- Нельзя наследовать или создавать экземпляр `Union`.583- Нельзя записать `Union[X][Y]`.584585Изменено в версии 3.7: Явные подклассы не удаляются из объединений во время выполнения.586587Изменено в версии 3.10: Объединения теперь можно записывать как `X | Y`. См. [выражения типов объединений](https://python-all.ru/3.10/library/stdtypes.html#types-union).588589#### `typing.Optional`590591Тип Optional.592593`Optional[X]` эквивалентен `X | None` (или `Union[X, None]`).594595Обратите внимание, что это не то же самое, что необязательный аргумент, который имеет значение по умолчанию. Необязательный аргумент с значением по умолчанию не требует квалификатора `Optional` в своей аннотации типа только потому, что он необязателен. Например:596597```python598def foo(arg: int = 0) -> None:599    ...600```601602С другой стороны, если явное значение `None` допускается, то использование `Optional` уместно, независимо от того, является ли аргумент необязательным или нет. Например:603604```python605def foo(arg: Optional[int] = None) -> None:606    ...607```608609Изменено в версии 3.10: Optional теперь можно записывать как `X | None`. См. [выражения типов объединений](https://python-all.ru/3.10/library/stdtypes.html#types-union).610611#### `typing.Callable`612613Тип Callable; `Callable[[int], str]` – это функция вида (int) -\> str.614615Синтаксис индексирования всегда должен использоваться ровно с двумя значениями: списком аргументов и типом возвращаемого значения. Список аргументов должен быть списком типов или многоточием; тип возвращаемого значения должен быть одним типом.616617Нет синтаксиса для указания необязательных или именованных аргументов; такие типы функций редко используются в качестве типов колбэков. `Callable[..., ReturnType]` (буквальное многоточие) можно использовать для аннотации вызываемого объекта, принимающего любое количество аргументов и возвращающего `ReturnType`. Обычное [`Callable`](https://python-all.ru/3.10/library/typing.html#typing.Callable) эквивалентно `Callable[..., Any]`, а в свою очередь – [`collections.abc.Callable`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.Callable).618619Объекты, принимающие другие вызываемые объекты в качестве аргументов, могут указать, что их типы параметров зависят друг от друга, с помощью [`ParamSpec`](https://python-all.ru/3.10/library/typing.html#typing.ParamSpec). Кроме того, если такой вызываемый объект добавляет или удаляет аргументы из других вызываемых объектов, может использоваться оператор [`Concatenate`](https://python-all.ru/3.10/library/typing.html#typing.Concatenate). Они имеют соответственно форму `Callable[ParamSpecVariable, ReturnType]` и `Callable[Concatenate[Arg1Type, Arg2Type, ..., ParamSpecVariable], ReturnType]`.620621Deprecated since version 3.9: [`collections.abc.Callable`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.Callable) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.10/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.10/library/stdtypes.html#types-genericalias).622623Changed in version 3.10: `Callable` now supports [`ParamSpec`](https://python-all.ru/3.10/library/typing.html#typing.ParamSpec) and [`Concatenate`](https://python-all.ru/3.10/library/typing.html#typing.Concatenate). See [**PEP 612**](https://python-all.ru/3.10/library/typing.html) for more details.624625> **См. также**626>627> Документация по [`ParamSpec`](https://python-all.ru/3.10/library/typing.html#typing.ParamSpec) и [`Concatenate`](https://python-all.ru/3.10/library/typing.html#typing.Concatenate) содержит примеры использования с `Callable`.628629#### `typing.Concatenate`630631Используется с [`Callable`](https://python-all.ru/3.10/library/typing.html#typing.Callable) и [`ParamSpec`](https://python-all.ru/3.10/library/typing.html#typing.ParamSpec) для аннотации типа вызываемого объекта высшего порядка, который добавляет, удаляет или преобразует параметры другого вызываемого объекта. Использование в форме `Concatenate[Arg1Type, Arg2Type, ..., ParamSpecVariable]`. `Concatenate` в настоящее время допустим только при использовании в качестве первого аргумента [`Callable`](https://python-all.ru/3.10/library/typing.html#typing.Callable). Последний параметр `Concatenate` должен быть [`ParamSpec`](https://python-all.ru/3.10/library/typing.html#typing.ParamSpec).632633Например, чтобы аннотировать декоратор `with_lock`, который предоставляет [`threading.Lock`](https://python-all.ru/3.10/library/threading.html#threading.Lock) декорируемой функции, можно использовать `Concatenate`, чтобы указать, что `with_lock` ожидает вызываемый объект, который принимает `Lock` в качестве первого аргумента, и возвращает вызываемый объект с другой сигнатурой типа. В этом случае [`ParamSpec`](https://python-all.ru/3.10/library/typing.html#typing.ParamSpec) указывает на то, что типы параметров возвращаемого вызываемого объекта зависят от типов параметров передаваемого вызываемого объекта:634635```python636from collections.abc import Callable637from threading import Lock638from typing import Concatenate, ParamSpec, TypeVar639640P = ParamSpec('P')641R = TypeVar('R')642643# Используйте эту блокировку, чтобы гарантировать, что только один поток выполняет функцию644# в любой момент времени.645my_lock = Lock()646647def with_lock(f: Callable[Concatenate[Lock, P], R]) -> Callable[P, R]:648    '''Типобезопасный декоратор, предоставляющий блокировку.'''649    def inner(*args: P.args, **kwargs: P.kwargs) -> R:650        # Передайте блокировку в качестве первого аргумента.651        return f(my_lock, *args, **kwargs)652    return inner653654@with_lock655def sum_threadsafe(lock: Lock, numbers: list[float]) -> float:656    '''Складывайте список чисел потокобезопасным способом.'''657    with lock:658        return sum(numbers)659660# Нам не нужно передавать блокировку вручную благодаря декоратору.661sum_threadsafe([1.1, 2.2, 3.3])662```663664Новое в версии 3.10.665666> **См. также**667>668> - [**PEP 612**](https://python-all.ru/3.10/library/typing.html) – переменные спецификации параметров (PEP, который ввёл `ParamSpec` и `Concatenate`).669> - [`ParamSpec`](https://python-all.ru/3.10/library/typing.html#typing.ParamSpec) и [`Callable`](https://python-all.ru/3.10/library/typing.html#typing.Callable).670671#### `class typing.Type(Generic[CT_co])`672673Переменная, аннотированная `C`, может принимать значение типа `C`. Напротив, переменная, аннотированная `Type[C]`, может принимать значения, которые сами являются классами – а именно, она принимает *объект класса* `C`. Например:674675```python676a = 3         # Имеет тип 'int'677b = int       # Имеет тип 'Type[int]'678c = type(a)   # Также имеет тип 'Type[int]'679```680681Обратите внимание, что `Type[C]` ковариантен:682683```python684class User: ...685class BasicUser(User): ...686class ProUser(User): ...687class TeamUser(User): ...688689# Принимает User, BasicUser, ProUser, TeamUser, ...690def make_new_user(user_class: Type[User]) -> User:691    # ...692    return user_class()693```694695Тот факт, что `Type[C]` ковариантен, подразумевает, что все подклассы `C` должны реализовывать те же сигнатуры конструктора и методов класса, что и `C`. Средство проверки типов должно отмечать нарушения этого, но также должно разрешать вызовы конструкторов в подклассах, которые соответствуют вызовам конструктора в указанном базовом классе. То, как средство проверки типов должно обрабатывать этот конкретный случай, может измениться в будущих версиях [**PEP 484**](https://python-all.ru/3.10/library/typing.html).696697Единственными допустимыми параметрами для [`Type`](https://python-all.ru/3.10/library/typing.html#typing.Type) являются классы, [`Any`](https://python-all.ru/3.10/library/typing.html#typing.Any), [переменные типа](https://python-all.ru/3.10/library/typing.html#generics) и объединения любых из этих типов. Например:698699```python700def new_non_team_user(user_class: Type[BasicUser | ProUser]): ...701```702703`Type[Any]` эквивалентен `Type`, который в свою очередь эквивалентен `type`, корню метаклассовой иерархии Python.704705Новое в версии 3.5.2.706707Deprecated since version 3.9: [`builtins.type`](https://python-all.ru/3.10/library/functions.html#type) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.10/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.10/library/stdtypes.html#types-genericalias).708709#### `typing.Literal`710711Тип, который можно использовать для указания средствам проверки типов, что соответствующая переменная или параметр функции имеет значение, эквивалентное предоставленному литералу (или одному из нескольких литералов). Например:712713```python714def validate_simple(data: Any) -> Literal[True]:  # всегда возвращает True715    ...716717MODE = Literal['r', 'rb', 'w', 'wb']718def open_helper(file: str, mode: MODE) -> str:719    ...720721open_helper('/some/path', 'r')  # Проходит проверку типов722open_helper('/other/path', 'typo')  # Ошибка в тайпчекере723```724725`Literal[...]` нельзя наследовать. Во время выполнения произвольное значение допускается в качестве аргумента типа для `Literal[...]`, но проверяющие типа могут накладывать ограничения. См. [**PEP 586**](https://python-all.ru/3.10/library/typing.html) для получения дополнительных сведений о литеральных типах.726727Новое в версии 3.8.728729Изменено в версии 3.9.1: `Literal` теперь дедуплицирует параметры. Сравнения на равенство объектов `Literal` больше не зависят от порядка. Объекты `Literal` теперь будут вызывать исключение [`TypeError`](https://python-all.ru/3.10/library/exceptions.html#TypeError) при сравнении на равенство, если один из их параметров не является [хешируемым](https://python-all.ru/3.10/glossary.html#term-hashable).730731#### `typing.ClassVar`732733Специальная конструкция типа для пометки переменных класса.734735Как представлено в [**PEP 526**](https://python-all.ru/3.10/library/typing.html), аннотация переменной, обёрнутая в ClassVar, указывает, что данный атрибут предназначен для использования в качестве переменной класса и не должен устанавливаться на экземплярах этого класса. Использование:736737```python738class Starship:739    stats: ClassVar[dict[str, int]] = {} # переменная класса740    damage: int = 10                     # переменная экземпляра741```742743[`ClassVar`](https://python-all.ru/3.10/library/typing.html#typing.ClassVar) принимает только типы и не может быть дополнительно индексирован.744745[`ClassVar`](https://python-all.ru/3.10/library/typing.html#typing.ClassVar) сам по себе не является классом и не должен использоваться с [`isinstance()`](https://python-all.ru/3.10/library/functions.html#isinstance) или [`issubclass()`](https://python-all.ru/3.10/library/functions.html#issubclass). [`ClassVar`](https://python-all.ru/3.10/library/typing.html#typing.ClassVar) не меняет поведение Python во время выполнения, но может использоваться сторонними проверяющими типов. Например, проверяющий типов может отметить следующий код как ошибочный:746747```python748enterprise_d = Starship(3000)749enterprise_d.stats = {} # Ошибка: установка переменной класса на экземпляре750Starship.stats = {}     # Это корректно.751```752753Новое в версии 3.5.3.754755#### `typing.Final`756757Специальная конструкция типов для указания средствам проверки типов, что имя не может быть переприсвоено или переопределено в подклассе. Например:758759```python760MAX_SIZE: Final = 9000761MAX_SIZE += 1  # Ошибка, выдаваемая проверщиком типов762763class Connection:764    TIMEOUT: Final[int] = 10765766class FastConnector(Connection):767    TIMEOUT = 1  # Ошибка, выдаваемая проверщиком типов768```769770Проверка этих свойств во время выполнения не выполняется. Подробнее см. [**PEP 591**](https://python-all.ru/3.10/library/typing.html).771772Новое в версии 3.8.773774#### `typing.Annotated`775776Тип, введённый в [**PEP 593**](https://python-all.ru/3.10/library/typing.html) (`Flexible function and variable annotations`), для декорирования существующих типов контекстно-зависимыми метаданными (возможно, несколькими их частями, так как `Annotated` вариадичен). В частности, тип `T` можно аннотировать метаданными `x` с помощью аннотации типа `Annotated[T, x]`. Эти метаданные можно использовать как для статического анализа, так и во время выполнения. Если библиотека (или инструмент) встречает аннотацию типа `Annotated[T, x]` и не имеет специальной логики для метаданных `x`, она должна игнорировать их и просто обрабатывать тип как `T`. В отличие от функциональности `no_type_check`, которая в настоящее время существует в модуле `typing` и полностью отключает проверку типов аннотаций для функции или класса, тип `Annotated` позволяет как статическую проверку типов `T` (которая может безопасно игнорировать `x`), так и доступ к `x` во время выполнения в рамках конкретного приложения.777778В конечном счёте, ответственность за интерпретацию аннотаций (если вообще) лежит на инструменте или библиотеке, встречающей тип `Annotated`. Инструмент или библиотека, встречающие тип `Annotated`, могут просматривать аннотации, чтобы определить, представляют ли они интерес (например, с помощью `isinstance()`).779780Когда инструмент или библиотека не поддерживает аннотации или встречает неизвестную аннотацию, она должна просто игнорировать её и обрабатывать аннотированный тип как базовый тип.781782Инструмент, потребляющий аннотации, сам решает, разрешено ли клиенту иметь несколько аннотаций на одном типе и как объединять эти аннотации.783784Поскольку тип `Annotated` позволяет помещать несколько аннотаций одного (или разных) типа на любой узел, инструменты или библиотеки, потребляющие эти аннотации, отвечают за обработку возможных дубликатов. Например, если вы выполняете анализ диапазона значений, вы можете разрешить это:785786```python787T1 = Annotated[int, ValueRange(-10, 5)]788T2 = Annotated[T1, ValueRange(-20, 3)]789```790791Передача `include_extras=True` в [`get_type_hints()`](https://python-all.ru/3.10/library/typing.html#typing.get_type_hints) позволяет получить доступ к дополнительным аннотациям во время выполнения.792793Подробности синтаксиса:794795- Первый аргумент `Annotated` должен быть допустимым типом796- Поддерживаются несколько аннотаций типов (`Annotated` поддерживает вариадические аргументы):797798  ```python799  Annotated[int, ValueRange(3, 10), ctype("char")]800  ```801- `Annotated` должен вызываться как минимум с двумя аргументами ( `Annotated[int]` недействителен)802- Порядок аннотаций сохраняется и важен для проверки на равенство:803804  ```python805  Annotated[int, ValueRange(3, 10), ctype("char")] != Annotated[806      int, ctype("char"), ValueRange(3, 10)807  ]808  ```809- Вложенные типы `Annotated` уплощаются, при этом метаданные упорядочиваются, начиная с самой внутренней аннотации:810811  ```python812  Annotated[Annotated[int, ValueRange(3, 10)], ctype("char")] == Annotated[813      int, ValueRange(3, 10), ctype("char")814  ]815  ```816- Дублирующиеся аннотации не удаляются:817818  ```python819  Annotated[int, ValueRange(3, 10)] != Annotated[820      int, ValueRange(3, 10), ValueRange(3, 10)821  ]822  ```823- `Annotated` можно использовать с вложенными и обобщёнными псевдонимами:824825  ```python826  T = TypeVar('T')827  Vec = Annotated[list[tuple[T, T]], MaxLen(10)]828  V = Vec[int]829830  V == Annotated[list[tuple[int, int]], MaxLen(10)]831  ```832833Новое в версии 3.9.834835#### `typing.TypeGuard`836837Специальная форма типов, используемая для аннотации возвращаемого типа определённой пользователем функции-охранника типа. `TypeGuard` принимает только один аргумент типа. Во время выполнения функции, помеченные таким образом, должны возвращать логическое значение.838839`TypeGuard` направлен на использование *сужения типа* – метода, используемого статическими проверками типов для определения более точного типа выражения в потоке кода программы. Обычно сужение типа выполняется путем анализа условного потока кода и применения сужения к блоку кода. Условное выражение в этом случае иногда называют «охранником типа»:840841```python842def is_str(val: str | float):843    # защита типа "isinstance"844    if isinstance(val, str):845        # Тип ``val`` сужается до ``str``846        ...847    else:848        # Иначе тип ``val`` сужается до ``float``.849        ...850```851852Иногда бывает удобно использовать пользовательскую логическую функцию в качестве охранника типа. Такая функция должна использовать `TypeGuard[...]` в качестве своего возвращаемого типа, чтобы предупредить статические проверки типов об этом намерении.853854Использование `-> TypeGuard` сообщает статическому анализатору типов, что для данной функции:8558561. Возвращаемое значение – boolean.8572. Если возвращаемое значение – `True`, то тип аргумента – это тип внутри `TypeGuard`.858859Например:860861```python862def is_str_list(val: List[object]) -> TypeGuard[List[str]]:863    '''Определяет, все ли объекты в списке являются строками'''864    return all(isinstance(x, str) for x in val)865866def func1(val: List[object]):867    if is_str_list(val):868        # Тип ``val`` сужен до ``List[str]``.869        print(" ".join(val))870    else:871        # Тип ``val`` остаётся ``List[object]``.872        print("Not a list of strings!")873```874875Если `is_str_list` является методом класса или экземпляра, то тип в `TypeGuard` соответствует типу второго параметра после `cls` или `self`.876877Короче говоря, форма `def foo(arg: TypeA) -> TypeGuard[TypeB]: ...` означает, что если `foo(arg)` возвращает `True`, то `arg` сужается с `TypeA` до `TypeB`.878879> **Примечание**880>881> `TypeB` не обязательно должен быть более узкой формой `TypeA` – он может быть даже более широкой формой. Основная причина – допускать такие ситуации, как сужение `List[object]` до `List[str]`, даже если последний не является подтипом первого, поскольку `List` инвариантен. Ответственность за написание типобезопасных охранников типа возлагается на пользователя.882883`TypeGuard` также работает с переменными типа. См. [**PEP 647**](https://python-all.ru/3.10/library/typing.html) для подробностей.884885Новое в версии 3.10.886887#### Построение обобщённых типов888889Они не используются в аннотациях. Это строительные блоки для создания обобщённых типов.890891#### `class typing.Generic`892893Абстрактный базовый класс для обобщённых типов.894895Обобщённый тип обычно объявляется наследованием от экземпляра этого класса с одной или несколькими переменными типа. Например, обобщённый тип отображения может быть определён так:896897```python898class Mapping(Generic[KT, VT]):899    def __getitem__(self, key: KT) -> VT:900        ...901        # И т.д.902```903904Затем этот класс можно использовать следующим образом:905906```python907X = TypeVar('X')908Y = TypeVar('Y')909910def lookup_name(mapping: Mapping[X, Y], key: X, default: Y) -> Y:911    try:912        return mapping[key]913    except KeyError:914        return default915```916917#### `class typing.TypeVar`918919Переменная типа.920921Использование:922923```python924T = TypeVar('T')  # Может быть чем угодно925S = TypeVar('S', bound=str)  # Может быть любым подтипом str926A = TypeVar('A', str, bytes)  # Должно быть ровно str или bytes927```928929Переменные типов существуют в первую очередь для пользы статических средств проверки типов. Они служат параметрами для обобщённых типов, а также для определений обобщённых функций. Смотрите [`Generic`](https://python-all.ru/3.10/library/typing.html#typing.Generic) для получения дополнительной информации об обобщённых типах. Обобщённые функции работают следующим образом:930931```python932def repeat(x: T, n: int) -> Sequence[T]:933    """Возвращает список, содержащий n ссылок на x."""934    return [x]*n935936def print_capitalized(x: S) -> S:937    """Печатает x с заглавной буквы и возвращает x."""938    print(x.capitalize())939    return x940941def concatenate(x: A, y: A) -> A:942    """Складывает две строки или два объекта bytes."""943    return x + y944```945946Обратите внимание, что переменные типа могут быть *связаны*, *ограничены* или ни тем, ни другим, но не могут быть одновременно и связаны, *и* ограничены.947948Ограниченные переменные типов и связанные переменные типов имеют разную семантику в нескольких важных аспектах. Использование *ограниченной* переменной типа означает, что `TypeVar` может быть решена только как одна из заданных ограничений:949950```python951a = concatenate('one', 'two')  # Ок, переменная 'a' имеет тип 'str'952b = concatenate(StringSubclass('one'), StringSubclass('two'))  # Выведенный тип переменной 'b' – 'str',953                                                               # несмотря на передачу 'StringSubclass'954c = concatenate('one', b'two')  # ошибка: переменная типа 'A' может быть 'str' или 'bytes' при вызове функции, но не оба сразу955```956957Использование *связанной* переменной типа, однако, означает, что `TypeVar` будет решена с использованием наиболее конкретного типа:958959```python960print_capitalized('a string')  # Ок, результат имеет тип 'str'961962class StringSubclass(str):963    pass964965print_capitalized(StringSubclass('another string'))  # Ок, результат имеет тип 'StringSubclass'966print_capitalized(45)  # ошибка: int не является подтипом str967```968969Переменные типа могут быть связаны с конкретными типами, абстрактными типами (ABC или протоколами) и даже объединениями типов:970971```python972U = TypeVar('U', bound=str|bytes)  # Может быть любым подтипом объединения str|bytes973V = TypeVar('V', bound=SupportsAbs)  # Может быть чем угодно с методом __abs__974```975976Связанные переменные типов особенно полезны для аннотации [`classmethods`](https://python-all.ru/3.10/library/functions.html#classmethod), которые служат альтернативными конструкторами. В следующем примере (от [Рэймонда Хеттингера](https://python-all.ru/3.10/library/typing.html)) переменная типа `C` привязана к классу `Circle` через использование прямой ссылки. Использование этой переменной типа для аннотации метода класса `with_circumference`, а не жёсткого кодирования возвращаемого типа как `Circle`, означает, что средство проверки типов может правильно вывести возвращаемый тип, даже если метод вызывается на подклассе:977978```python979import math980981C = TypeVar('C', bound='Circle')982983class Circle:984    """Абстрактная окружность"""985986    def __init__(self, radius: float) -> None:987        self.radius = radius988989    # Используется переменная типа, чтобы показать, что возвращаемый тип990    # всегда будет экземпляром того, чем является ``cls``991    @classmethod992    def with_circumference(cls: type[C], circumference: float) -> C:993        """Создать окружность с указанной длиной окружности"""994        radius = circumference / (math.pi * 2)995        return cls(radius)996997class Tire(Circle):998    """Специализированная окружность (из резины)"""9991000    MATERIAL = 'rubber'10011002c = Circle.with_circumference(3)  # Ок, переменная 'c' имеет тип 'Circle'1003t = Tire.with_circumference(4)  # Ок, переменная 't' имеет тип 'Tire' (не 'Circle')1004```10051006Во время выполнения `isinstance(x, T)` вызовет [`TypeError`](https://python-all.ru/3.10/library/exceptions.html#TypeError). В общем, [`isinstance()`](https://python-all.ru/3.10/library/functions.html#isinstance) и [`issubclass()`](https://python-all.ru/3.10/library/functions.html#issubclass) не должны использоваться с типами.10071008Переменные типа могут быть помечены как ковариантные или контравариантные путём передачи `covariant=True` или `contravariant=True`. См. [**PEP 484**](https://python-all.ru/3.10/library/typing.html) для получения дополнительных сведений. По умолчанию переменные типа инвариантны.10091010#### `class typing.ParamSpec(name, *, bound=None, covariant=False, contravariant=False)`10111012Переменная спецификации параметров. Специализированная версия [`type variables`](https://python-all.ru/3.10/library/typing.html#typing.TypeVar).10131014Использование:10151016```python1017P = ParamSpec('P')1018```10191020Переменные спецификации параметров существуют в первую очередь для статических проверок типов. Они используются для передачи типов параметров одного вызываемого объекта другому вызываемому объекту – шаблон, часто встречающийся в функциях высшего порядка и декораторах. Они допустимы только при использовании в `Concatenate`, или как первый аргумент `Callable`, или как параметры пользовательских обобщённых типов (Generics). См. [`Generic`](https://python-all.ru/3.10/library/typing.html#typing.Generic) для получения дополнительной информации об обобщённых типах.10211022Например, чтобы добавить базовое логирование в функцию, можно создать декоратор `add_logging` для логирования вызовов функций. Переменная спецификации параметров сообщает проверяющему типы, что вызываемый объект, переданный в декоратор, и новый вызываемый объект, возвращаемый им, имеют взаимозависимые параметры типа:10231024```python1025from collections.abc import Callable1026from typing import TypeVar, ParamSpec1027import logging10281029T = TypeVar('T')1030P = ParamSpec('P')10311032def add_logging(f: Callable[P, T]) -> Callable[P, T]:1033    '''Типобезопасный декоратор для добавления логирования в функцию.'''1034    def inner(*args: P.args, **kwargs: P.kwargs) -> T:1035        logging.info(f'{f.__name__} was called')1036        return f(*args, **kwargs)1037    return inner10381039@add_logging1040def add_two(x: float, y: float) -> float:1041    '''Складывает два числа.'''1042    return x + y1043```10441045Без `ParamSpec` самый простой способ аннотировать это ранее заключался в использовании [`TypeVar`](https://python-all.ru/3.10/library/typing.html#typing.TypeVar) с границей `Callable[..., Any]`. Однако это вызывает две проблемы:104610471. Проверяющий типы не может проверить типы функции `inner`, потому что `*args` и `**kwargs` должны быть типизированы как [`Any`](https://python-all.ru/3.10/library/typing.html#typing.Any).10482. [`cast()`](https://python-all.ru/3.10/library/typing.html#typing.cast) может потребоваться в теле декоратора `add_logging` при возврате функции `inner`, или статической проверке типов нужно указать игнорировать `return inner`.10491050#### `args`10511052#### `kwargs`10531054Поскольку `ParamSpec` захватывает как позиционные, так и ключевые параметры, `P.args` и `P.kwargs` можно использовать для разделения `ParamSpec` на составляющие. `P.args` представляет кортеж позиционных параметров в заданном вызове и должен использоваться только для аннотации `*args`. `P.kwargs` представляет отображение ключевых параметров на их значения в заданном вызове и должен использоваться только для аннотации `**kwargs`. Оба атрибута требуют, чтобы аннотируемый параметр находился в области видимости. Во время выполнения `P.args` и `P.kwargs` являются экземплярами соответственно [`ParamSpecArgs`](https://python-all.ru/3.10/library/typing.html#typing.ParamSpecArgs) и [`ParamSpecKwargs`](https://python-all.ru/3.10/library/typing.html#typing.ParamSpecKwargs).10551056Переменные спецификации параметров, созданные с помощью `covariant=True` или `contravariant=True`, можно использовать для объявления ковариантных или контравариантных обобщённых типов. Аргумент `bound` также принимается, как и в [`TypeVar`](https://python-all.ru/3.10/library/typing.html#typing.TypeVar). Однако фактическая семантика этих ключевых слов ещё не определена.10571058Новое в версии 3.10.10591060> **Примечание**1061>1062> Только переменные спецификации параметров, определённые в глобальной области видимости, могут быть pickled.10631064> **См. также**1065>1066> - [**PEP 612**](https://python-all.ru/3.10/library/typing.html) – Переменные спецификации параметров (PEP, который ввёл `ParamSpec` и `Concatenate`).1067> - [`Callable`](https://python-all.ru/3.10/library/typing.html#typing.Callable) и [`Concatenate`](https://python-all.ru/3.10/library/typing.html#typing.Concatenate).10681069#### `typing.ParamSpecArgs`10701071#### `typing.ParamSpecKwargs`10721073Атрибуты аргументов и именованных аргументов (keyword arguments) объекта [`ParamSpec`](https://python-all.ru/3.10/library/typing.html#typing.ParamSpec). Атрибут `P.args` объекта `ParamSpec` является экземпляром `ParamSpecArgs`, а `P.kwargs` – экземпляром `ParamSpecKwargs`. Они предназначены для интроспекции во время выполнения и не имеют особого значения для статических проверяющих типы.10741075Вызов [`get_origin()`](https://python-all.ru/3.10/library/typing.html#typing.get_origin) для любого из этих объектов вернёт исходный `ParamSpec`:10761077```python1078P = ParamSpec("P")1079get_origin(P.args)  # возвращает P1080get_origin(P.kwargs)  # возвращает P1081```10821083Новое в версии 3.10.10841085#### `typing.AnyStr`10861087`AnyStr` – это [`constrained type variable`](https://python-all.ru/3.10/library/typing.html#typing.TypeVar), определённый как `AnyStr = TypeVar('AnyStr', str, bytes)`.10881089Предназначен для функций, которые могут принимать строки любого типа, не допуская смешивания разных типов строк. Например:10901091```python1092def concat(a: AnyStr, b: AnyStr) -> AnyStr:1093    return a + b10941095concat(u"foo", u"bar")  # Ок, результат имеет тип 'unicode'1096concat(b"foo", b"bar")  # Ок, результат имеет тип 'bytes'1097concat(u"foo", b"bar")  # Ошибка, нельзя смешивать unicode и bytes1098```10991100#### `class typing.Protocol(Generic)`11011102Базовый класс для классов протоколов. Классы протоколов определяются следующим образом:11031104```python1105class Proto(Protocol):1106    def meth(self) -> int:1107        ...1108```11091110Такие классы в основном используются со статическими проверяющими типов, которые распознают структурную подтипизацию (статическую утиную типизацию), например:11111112```python1113class C:1114    def meth(self) -> int:1115        return 011161117def func(x: Proto) -> int:1118    return x.meth()11191120func(C())  # Проходит статическую проверку типов1121```11221123См. [**PEP 544**](https://python-all.ru/3.10/library/typing.html) для получения дополнительных сведений. Классы-протоколы, декорированные [`runtime_checkable()`](https://python-all.ru/3.10/library/typing.html#typing.runtime_checkable) (описано далее), действуют как простые протоколы времени выполнения, которые проверяют только наличие заданных атрибутов, игнорируя их сигнатуры типов.11241125Протокольные классы могут быть обобщёнными, например:11261127```python1128class GenProto(Protocol[T]):1129    def meth(self) -> T:1130        ...1131```11321133Новое в версии 3.8.11341135#### `@typing.runtime_checkable`11361137Помечает протокольный класс как протокол времени выполнения.11381139Такой протокол может использоваться с [`isinstance()`](https://python-all.ru/3.10/library/functions.html#isinstance) и [`issubclass()`](https://python-all.ru/3.10/library/functions.html#issubclass). При применении к классу, не являющемуся протоколом, возникает [`TypeError`](https://python-all.ru/3.10/library/exceptions.html#TypeError). Это позволяет выполнять простую структурную проверку, очень похожую на “one trick ponies” в [`collections.abc`](https://python-all.ru/3.10/library/collections.abc.html#module-collections.abc), таких как [`Iterable`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.Iterable). Например:11401141```python1142@runtime_checkable1143class Closable(Protocol):1144    def close(self): ...11451146assert isinstance(open('/some/file'), Closable)11471148@runtime_checkable1149class Named(Protocol):1150    name: str11511152import threading1153assert isinstance(threading.Thread(name='Bob'), Named)1154```11551156> **Примечание**1157>1158> `runtime_checkable()` проверяет только наличие требуемых методов или атрибутов, а не их сигнатуры типов или сами типы. Например, [`ssl.SSLObject`](https://python-all.ru/3.10/library/ssl.html#ssl.SSLObject) является классом, поэтому он проходит проверку [`issubclass()`](https://python-all.ru/3.10/library/functions.html#issubclass) на соответствие [`Callable`](https://python-all.ru/3.10/library/typing.html#typing.Callable). Однако метод `ssl.SSLObject.__init__` существует только для того, чтобы вызвать [`TypeError`](https://python-all.ru/3.10/library/exceptions.html#TypeError) с более информативным сообщением, что делает невозможным вызов (создание экземпляра) [`ssl.SSLObject`](https://python-all.ru/3.10/library/ssl.html#ssl.SSLObject).11591160> **Примечание**1161>1162> Проверка [`isinstance()`](https://python-all.ru/3.10/library/functions.html#isinstance) на соответствие протоколу с проверкой во время выполнения может быть удивительно медленной по сравнению с проверкой `isinstance()` для непротокольного класса. Рекомендуется использовать альтернативные идиомы, такие как вызовы [`hasattr()`](https://python-all.ru/3.10/library/functions.html#hasattr) для структурных проверок в коде, чувствительном к производительности.11631164Новое в версии 3.8.11651166#### Другие специальные директивы11671168Они не используются в аннотациях. Это строительные блоки для объявления типов.11691170#### `class typing.NamedTuple`11711172Типизированная версия [`collections.namedtuple()`](https://python-all.ru/3.10/library/collections.html#collections.namedtuple).11731174Использование:11751176```python1177class Employee(NamedTuple):1178    name: str1179    id: int1180```11811182Это эквивалентно:11831184```python1185Employee = collections.namedtuple('Employee', ['name', 'id'])1186```11871188Чтобы задать полю значение по умолчанию, можно присвоить его в теле класса:11891190```python1191class Employee(NamedTuple):1192    name: str1193    id: int = 311941195employee = Employee('Guido')1196assert employee.id == 31197```11981199Поля со значением по умолчанию должны следовать после полей без значения по умолчанию.12001201Полученный класс имеет дополнительный атрибут `__annotations__`, который содержит словарь, отображающий имена полей на их типы. (Имена полей находятся в атрибуте `_fields`, а значения по умолчанию – в атрибуте `_field_defaults`; оба они являются частью API [`namedtuple()`](https://python-all.ru/3.10/library/collections.html#collections.namedtuple).)12021203Подклассы `NamedTuple` также могут иметь докстринги и методы:12041205```python1206class Employee(NamedTuple):1207    """Представляет сотрудника."""1208    name: str1209    id: int = 312101211    def __repr__(self) -> str:1212        return f'<Employee {self.name}, id={self.id}>'1213```12141215Обратно совместимое использование:12161217```python1218Employee = NamedTuple('Employee', [('name', str), ('id', int)])1219```12201221Изменено в версии 3.6: Добавлена поддержка синтаксиса аннотации переменных [**PEP 526**](https://python-all.ru/3.10/library/typing.html).12221223Изменено в версии 3.6.1: Добавлена поддержка значений по умолчанию, методов и строк документации.12241225Изменено в версии 3.8: Атрибуты `_field_types` и `__annotations__` теперь являются обычными словарями, а не экземплярами `OrderedDict`.12261227Изменено в версии 3.9: Атрибут `_field_types` удалён в пользу более стандартного атрибута `__annotations__`, который содержит ту же информацию.12281229#### `class typing.NewType(name, tp)`12301231Вспомогательный класс для указания отдельного типа для проверяющего типа, см. [NewType](https://python-all.ru/3.10/library/typing.html#distinct). Во время выполнения он возвращает объект, который возвращает свой аргумент при вызове. Использование:12321233```python1234UserId = NewType('UserId', int)1235first_user = UserId(1)1236```12371238Новое в версии 3.5.2.12391240Изменено в версии 3.10: `NewType` теперь является классом, а не функцией.12411242#### `class typing.TypedDict(dict)`12431244Специальная конструкция для добавления подсказок типов к словарю. Во время выполнения это обычный [`dict`](https://python-all.ru/3.10/library/stdtypes.html#dict).12451246`TypedDict` объявляет тип словаря, который ожидает, что все его экземпляры будут иметь определённый набор ключей, где каждый ключ связан со значением согласованного типа. Это ожидание не проверяется во время выполнения, а обеспечивается только средствами проверки типов. Использование:12471248```python1249class Point2D(TypedDict):1250    x: int1251    y: int1252    label: str12531254a: Point2D = {'x': 1, 'y': 2, 'label': 'good'}  # ОК1255b: Point2D = {'z': 3, 'label': 'bad'}           # Не проходит проверку типов12561257assert Point2D(x=1, y=2, label='first') == dict(x=1, y=2, label='first')1258```12591260Чтобы разрешить использование этой возможности в старых версиях Python, которые не поддерживают [**PEP 526**](https://python-all.ru/3.10/library/typing.html), `TypedDict` поддерживает две дополнительные эквивалентные синтаксические формы:12611262```python1263Point2D = TypedDict('Point2D', x=int, y=int, label=str)1264Point2D = TypedDict('Point2D', {'x': int, 'y': int, 'label': str})1265```12661267Функциональный синтаксис также следует использовать, когда какой-либо из ключей не является допустимым [идентификатором](https://python-all.ru/3.10/reference/lexical_analysis.html#identifiers), например, потому что они являются ключевыми словами или содержат дефисы. Пример:12681269```python1270# возбуждает SyntaxError1271class Point2D(TypedDict):1272    in: int  # 'in' – ключевое слово1273    x-y: int  # имя с дефисами12741275# ОК, функциональный синтаксис1276Point2D = TypedDict('Point2D', {'in': int, 'x-y': int})1277```12781279По умолчанию все ключи должны присутствовать в `TypedDict`. Это можно переопределить, указав totality. Использование:12801281```python1282class Point2D(TypedDict, total=False):1283    x: int1284    y: int1285```12861287Это означает, что `Point2D` `TypedDict` может не содержать любой из ключей. Средство проверки типов должно поддерживать только литерал `False` или `True` в качестве значения аргумента `total`. `True` – значение по умолчанию, и оно делает все элементы, определённые в теле класса, обязательными.12881289`TypedDict` может наследоваться от одного или нескольких других типов `TypedDict` с использованием синтаксиса на основе классов. Использование:12901291```python1292class Point3D(Point2D):1293    z: int1294```12951296`Point3D` содержит три элемента: `x`, `y` и `z`. Это эквивалентно следующему определению:12971298```python1299class Point3D(TypedDict):1300    x: int1301    y: int1302    z: int1303```13041305`TypedDict` не может наследоваться от не-`TypedDict` класса, включая [`Generic`](https://python-all.ru/3.10/library/typing.html#typing.Generic). Например:13061307```python1308class X(TypedDict):1309    x: int13101311class Y(TypedDict):1312    y: int13131314class Z(object): pass  # Класс, не являющийся TypedDict13151316class XY(X, Y): pass  # ОК13171318class XZ(X, Z): pass  # вызывает TypeError13191320T = TypeVar('T')1321class XT(X, Generic[T]): pass  # вызывает TypeError1322```13231324`TypedDict` может быть проанализирован с помощью словарей аннотаций (см. [Лучшие практики работы с аннотациями](https://python-all.ru/3.10/howto/annotations.html#annotations-howto) для получения дополнительной информации о лучших практиках работы с аннотациями), [`__total__`](https://python-all.ru/3.10/library/typing.html#typing.TypedDict.__total__), [`__required_keys__`](https://python-all.ru/3.10/library/typing.html#typing.TypedDict.__required_keys__) и [`__optional_keys__`](https://python-all.ru/3.10/library/typing.html#typing.TypedDict.__optional_keys__).13251326#### `__total__`13271328`Point2D.__total__` возвращает значение аргумента `total`. Пример:13291330```python1331>>> from typing import TypedDict1332>>> class Point2D(TypedDict): pass1333>>> Point2D.__total__1334True1335>>> class Point2D(TypedDict, total=False): pass1336>>> Point2D.__total__1337False1338>>> class Point3D(Point2D): pass1339>>> Point3D.__total__1340True1341```13421343#### `__required_keys__`13441345Новое в версии 3.9.13461347#### `__optional_keys__`13481349`Point2D.__required_keys__` и `Point2D.__optional_keys__` возвращают объекты [`frozenset`](https://python-all.ru/3.10/library/stdtypes.html#frozenset), содержащие обязательные и необязательные ключи соответственно. В настоящее время единственный способ объявить как обязательные, так и необязательные ключи в одном `TypedDict` – это смешанное наследование: объявить `TypedDict` с одним значением для аргумента `total`, а затем унаследовать его от другого `TypedDict` с другим значением для `total`. Использование:13501351```python1352>>> class Point2D(TypedDict, total=False):1353...     x: int1354...     y: int1355...1356>>> class Point3D(Point2D):1357...     z: int1358...1359>>> Point3D.__required_keys__ == frozenset({'z'})1360True1361>>> Point3D.__optional_keys__ == frozenset({'x', 'y'})1362True1363```13641365Новое в версии 3.9.13661367Смотрите [**PEP 589**](https://python-all.ru/3.10/library/typing.html) для дополнительных примеров и подробных правил использования `TypedDict`.13681369Новое в версии 3.8.13701371### Конкретные обобщённые коллекции13721373#### Соответствующие встроенным типам13741375#### `class typing.Dict(dict, MutableMapping[KT, VT])`13761377Обобщённая версия [`dict`](https://python-all.ru/3.10/library/stdtypes.html#dict). Полезна для аннотирования возвращаемых типов. Для аннотирования аргументов предпочтительнее использовать абстрактный тип коллекции, например [`Mapping`](https://python-all.ru/3.10/library/typing.html#typing.Mapping).13781379Этот тип можно использовать следующим образом:13801381```python1382def count_words(text: str) -> Dict[str, int]:1383    ...1384```13851386Deprecated since version 3.9: [`builtins.dict`](https://python-all.ru/3.10/library/stdtypes.html#dict) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.10/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.10/library/stdtypes.html#types-genericalias).13871388#### `class typing.List(list, MutableSequence[T])`13891390Обобщённая версия [`list`](https://python-all.ru/3.10/library/stdtypes.html#list). Полезна для аннотирования возвращаемых типов. Для аннотирования аргументов предпочтительнее использовать абстрактный тип коллекции, например [`Sequence`](https://python-all.ru/3.10/library/typing.html#typing.Sequence) или [`Iterable`](https://python-all.ru/3.10/library/typing.html#typing.Iterable).13911392Этот тип можно использовать следующим образом:13931394```python1395T = TypeVar('T', int, float)13961397def vec2(x: T, y: T) -> List[T]:1398    return [x, y]13991400def keep_positives(vector: Sequence[T]) -> List[T]:1401    return [item for item in vector if item > 0]1402```14031404Deprecated since version 3.9: [`builtins.list`](https://python-all.ru/3.10/library/stdtypes.html#list) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.10/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.10/library/stdtypes.html#types-genericalias).14051406#### `class typing.Set(set, MutableSet[T])`14071408Обобщённая версия [`builtins.set`](https://python-all.ru/3.10/library/stdtypes.html#set). Полезна для аннотирования возвращаемых типов. Для аннотирования аргументов предпочтительнее использовать абстрактный тип коллекции, например [`AbstractSet`](https://python-all.ru/3.10/library/typing.html#typing.AbstractSet).14091410Deprecated since version 3.9: [`builtins.set`](https://python-all.ru/3.10/library/stdtypes.html#set) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.10/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.10/library/stdtypes.html#types-genericalias).14111412#### `class typing.FrozenSet(frozenset, AbstractSet[T_co])`14131414Обобщённая версия [`builtins.frozenset`](https://python-all.ru/3.10/library/stdtypes.html#frozenset).14151416Deprecated since version 3.9: [`builtins.frozenset`](https://python-all.ru/3.10/library/stdtypes.html#frozenset) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.10/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.10/library/stdtypes.html#types-genericalias).14171418> **Примечание**1419>1420> [`Tuple`](https://python-all.ru/3.10/library/typing.html#typing.Tuple) – это специальная форма.14211422#### Соответствует типам в [`collections`](https://python-all.ru/3.10/library/collections.html#module-collections)14231424#### `class typing.DefaultDict(collections.defaultdict, MutableMapping[KT, VT])`14251426Обобщённая версия [`collections.defaultdict`](https://python-all.ru/3.10/library/collections.html#collections.defaultdict).14271428Новое в версии 3.5.2.14291430Deprecated since version 3.9: [`collections.defaultdict`](https://python-all.ru/3.10/library/collections.html#collections.defaultdict) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.10/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.10/library/stdtypes.html#types-genericalias).14311432#### `class typing.OrderedDict(collections.OrderedDict, MutableMapping[KT, VT])`14331434Обобщённая версия [`collections.OrderedDict`](https://python-all.ru/3.10/library/collections.html#collections.OrderedDict).14351436Добавлено в версии 3.7.2.14371438Deprecated since version 3.9: [`collections.OrderedDict`](https://python-all.ru/3.10/library/collections.html#collections.OrderedDict) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.10/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.10/library/stdtypes.html#types-genericalias).14391440#### `class typing.ChainMap(collections.ChainMap, MutableMapping[KT, VT])`14411442Обобщённая версия [`collections.ChainMap`](https://python-all.ru/3.10/library/collections.html#collections.ChainMap).14431444Новое в версии 3.5.4.14451446Новое в версии 3.6.1.14471448Deprecated since version 3.9: [`collections.ChainMap`](https://python-all.ru/3.10/library/collections.html#collections.ChainMap) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.10/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.10/library/stdtypes.html#types-genericalias).14491450#### `class typing.Counter(collections.Counter, Dict[T, int])`14511452Обобщённая версия [`collections.Counter`](https://python-all.ru/3.10/library/collections.html#collections.Counter).14531454Новое в версии 3.5.4.14551456Новое в версии 3.6.1.14571458Deprecated since version 3.9: [`collections.Counter`](https://python-all.ru/3.10/library/collections.html#collections.Counter) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.10/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.10/library/stdtypes.html#types-genericalias).14591460#### `class typing.Deque(deque, MutableSequence[T])`14611462Обобщённая версия [`collections.deque`](https://python-all.ru/3.10/library/collections.html#collections.deque).14631464Новое в версии 3.5.4.14651466Новое в версии 3.6.1.14671468Deprecated since version 3.9: [`collections.deque`](https://python-all.ru/3.10/library/collections.html#collections.deque) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.10/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.10/library/stdtypes.html#types-genericalias).14691470#### Другие конкретные типы14711472#### `class typing.IO`14731474#### `class typing.TextIO`14751476#### `class typing.BinaryIO`14771478Обобщённый тип `IO[AnyStr]` и его подклассы `TextIO(IO[str])` и `BinaryIO(IO[bytes])` представляют типы потоков ввода-вывода, такие как возвращаемые [`open()`](https://python-all.ru/3.10/library/functions.html#open).14791480Устарело с версии 3.8, будет удалено в версии 3.13: Пространство имён `typing.io` устарело и будет удалено. Эти типы следует импортировать напрямую из `typing`.14811482#### `class typing.Pattern`14831484#### `class typing.Match`14851486Эти псевдонимы типов соответствуют возвращаемым типам из [`re.compile()`](https://python-all.ru/3.10/library/re.html#re.compile) и [`re.match()`](https://python-all.ru/3.10/library/re.html#re.match). Эти типы (и соответствующие функции) являются обобщёнными по `AnyStr` и могут быть конкретизированы записью `Pattern[str]`, `Pattern[bytes]`, `Match[str]` или `Match[bytes]`.14871488Устарело с версии 3.8, будет удалено в версии 3.13: Пространство имён `typing.re` устарело и будет удалено. Эти типы следует импортировать напрямую из `typing`.14891490Устарело с версии 3.9: Классы `Pattern` и `Match` из [`re`](https://python-all.ru/3.10/library/re.html#module-re) теперь поддерживают `[]`. См. [**PEP 585**](https://python-all.ru/3.10/library/typing.html) и [Generic Alias Type](https://python-all.ru/3.10/library/stdtypes.html#types-genericalias).14911492#### `class typing.Text`14931494`Text` – это псевдоним для `str`. Он предоставляется для обеспечения совместимости с кодом Python 2: в Python 2 `Text` является псевдонимом для `unicode`.14951496Используйте `Text`, чтобы указать, что значение должно содержать строку Unicode, совместимую как с Python 2, так и с Python 3:14971498```python1499def add_unicode_checkmark(text: Text) -> Text:1500    return text + u' \u2713'1501```15021503Новое в версии 3.5.2.15041505### Абстрактные базовые классы15061507#### Соответствуют коллекциям из [`collections.abc`](https://python-all.ru/3.10/library/collections.abc.html#module-collections.abc)15081509#### `class typing.AbstractSet(Collection[T_co])`15101511Обобщённая версия [`collections.abc.Set`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.Set).15121513Deprecated since version 3.9: [`collections.abc.Set`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.Set) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.10/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.10/library/stdtypes.html#types-genericalias).15141515#### `class typing.ByteString(Sequence[int])`15161517Обобщённая версия [`collections.abc.ByteString`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.ByteString).15181519Этот тип представляет типы [`bytes`](https://python-all.ru/3.10/library/stdtypes.html#bytes), [`bytearray`](https://python-all.ru/3.10/library/stdtypes.html#bytearray) и [`memoryview`](https://python-all.ru/3.10/library/stdtypes.html#memoryview) последовательностей байтов.15201521В качестве сокращения для этого типа [`bytes`](https://python-all.ru/3.10/library/stdtypes.html#bytes) можно использовать для аннотации аргументов любого из упомянутых выше типов.15221523Deprecated since version 3.9: [`collections.abc.ByteString`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.ByteString) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.10/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.10/library/stdtypes.html#types-genericalias).15241525#### `class typing.Collection(Sized, Iterable[T_co], Container[T_co])`15261527Обобщённая версия [`collections.abc.Collection`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.Collection)15281529Новое в версии 3.6.0.15301531Deprecated since version 3.9: [`collections.abc.Collection`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.Collection) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.10/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.10/library/stdtypes.html#types-genericalias).15321533#### `class typing.Container(Generic[T_co])`15341535Обобщённая версия [`collections.abc.Container`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.Container).15361537Deprecated since version 3.9: [`collections.abc.Container`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.Container) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.10/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.10/library/stdtypes.html#types-genericalias).15381539#### `class typing.ItemsView(MappingView, AbstractSet[tuple[KT_co, VT_co]])`15401541Обобщённая версия [`collections.abc.ItemsView`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.ItemsView).15421543Deprecated since version 3.9: [`collections.abc.ItemsView`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.ItemsView) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.10/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.10/library/stdtypes.html#types-genericalias).15441545#### `class typing.KeysView(MappingView, AbstractSet[KT_co])`15461547Обобщённая версия [`collections.abc.KeysView`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.KeysView).15481549Deprecated since version 3.9: [`collections.abc.KeysView`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.KeysView) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.10/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.10/library/stdtypes.html#types-genericalias).15501551#### `class typing.Mapping(Collection[KT], Generic[KT, VT_co])`15521553Обобщённая версия [`collections.abc.Mapping`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.Mapping). Этот тип можно использовать следующим образом:15541555```python1556def get_position_in_index(word_list: Mapping[str, int], word: str) -> int:1557    return word_list[word]1558```15591560Deprecated since version 3.9: [`collections.abc.Mapping`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.Mapping) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.10/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.10/library/stdtypes.html#types-genericalias).15611562#### `class typing.MappingView(Sized)`15631564Обобщённая версия [`collections.abc.MappingView`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.MappingView).15651566Deprecated since version 3.9: [`collections.abc.MappingView`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.MappingView) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.10/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.10/library/stdtypes.html#types-genericalias).15671568#### `class typing.MutableMapping(Mapping[KT, VT])`15691570Обобщённая версия [`collections.abc.MutableMapping`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.MutableMapping).15711572Deprecated since version 3.9: [`collections.abc.MutableMapping`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.MutableMapping) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.10/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.10/library/stdtypes.html#types-genericalias).15731574#### `class typing.MutableSequence(Sequence[T])`15751576Обобщённая версия [`collections.abc.MutableSequence`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.MutableSequence).15771578Deprecated since version 3.9: [`collections.abc.MutableSequence`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.MutableSequence) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.10/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.10/library/stdtypes.html#types-genericalias).15791580#### `class typing.MutableSet(AbstractSet[T])`15811582Обобщённая версия [`collections.abc.MutableSet`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.MutableSet).15831584Deprecated since version 3.9: [`collections.abc.MutableSet`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.MutableSet) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.10/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.10/library/stdtypes.html#types-genericalias).15851586#### `class typing.Sequence(Reversible[T_co], Collection[T_co])`15871588Обобщённая версия [`collections.abc.Sequence`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.Sequence).15891590Deprecated since version 3.9: [`collections.abc.Sequence`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.Sequence) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.10/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.10/library/stdtypes.html#types-genericalias).15911592#### `class typing.ValuesView(MappingView, Collection[_VT_co])`15931594Обобщённая версия [`collections.abc.ValuesView`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.ValuesView).15951596Deprecated since version 3.9: [`collections.abc.ValuesView`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.ValuesView) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.10/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.10/library/stdtypes.html#types-genericalias).15971598#### Соответствует другим типам в [`collections.abc`](https://python-all.ru/3.10/library/collections.abc.html#module-collections.abc)15991600#### `class typing.Iterable(Generic[T_co])`16011602Обобщённая версия [`collections.abc.Iterable`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.Iterable).16031604Deprecated since version 3.9: [`collections.abc.Iterable`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.Iterable) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.10/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.10/library/stdtypes.html#types-genericalias).16051606#### `class typing.Iterator(Iterable[T_co])`16071608Обобщённая версия [`collections.abc.Iterator`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.Iterator).16091610Deprecated since version 3.9: [`collections.abc.Iterator`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.Iterator) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.10/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.10/library/stdtypes.html#types-genericalias).16111612#### `class typing.Generator(Iterator[T_co], Generic[T_co, T_contra, V_co])`16131614Генератор можно аннотировать обобщённым типом `Generator[YieldType, SendType, ReturnType]`. Например:16151616```python1617def echo_round() -> Generator[int, float, str]:1618    sent = yield 01619    while sent >= 0:1620        sent = yield round(sent)1621    return 'Done'1622```16231624Обратите внимание: в отличие от многих других обобщённых типов в модуле typing, `SendType` из [`Generator`](https://python-all.ru/3.10/library/typing.html#typing.Generator) ведёт себя контравариантно, а не ковариантно или инвариантно.16251626Если ваш генератор будет только выдавать значения, установите `SendType` и `ReturnType` в `None`:16271628```python1629def infinite_stream(start: int) -> Generator[int, None, None]:1630    while True:1631        yield start1632        start += 11633```16341635В качестве альтернативы аннотируйте генератор как имеющий тип возвращаемого значения либо `Iterable[YieldType]`, либо `Iterator[YieldType]`:16361637```python1638def infinite_stream(start: int) -> Iterator[int]:1639    while True:1640        yield start1641        start += 11642```16431644Deprecated since version 3.9: [`collections.abc.Generator`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.Generator) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.10/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.10/library/stdtypes.html#types-genericalias).16451646#### `class typing.Hashable`16471648Псевдоним для [`collections.abc.Hashable`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.Hashable).16491650#### `class typing.Reversible(Iterable[T_co])`16511652Обобщённая версия [`collections.abc.Reversible`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.Reversible).16531654Deprecated since version 3.9: [`collections.abc.Reversible`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.Reversible) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.10/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.10/library/stdtypes.html#types-genericalias).16551656#### `class typing.Sized`16571658Псевдоним для [`collections.abc.Sized`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.Sized).16591660#### Асинхронное программирование16611662#### `class typing.Coroutine(Awaitable[V_co], Generic[T_co, T_contra, V_co])`16631664Обобщённая версия [`collections.abc.Coroutine`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.Coroutine). Вариантность и порядок переменных типа соответствуют таковым у [`Generator`](https://python-all.ru/3.10/library/typing.html#typing.Generator), например:16651666```python1667from collections.abc import Coroutine1668c: Coroutine[list[str], str, int]  # Некоторая корутина, определённая в другом месте.1669x = c.send('hi')                   # Выведенный тип 'x' – list[str].1670async def bar() -> None:1671    y = await c                    # Выведенный тип 'y' – int.1672```16731674Новое в версии 3.5.3.16751676Deprecated since version 3.9: [`collections.abc.Coroutine`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.Coroutine) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.10/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.10/library/stdtypes.html#types-genericalias).16771678#### `class typing.AsyncGenerator(AsyncIterator[T_co], Generic[T_co, T_contra])`16791680Асинхронный генератор можно аннотировать обобщённым типом `AsyncGenerator[YieldType, SendType]`. Например:16811682```python1683async def echo_round() -> AsyncGenerator[int, float]:1684    sent = yield 01685    while sent >= 0.0:1686        rounded = await round(sent)1687        sent = yield rounded1688```16891690В отличие от обычных генераторов, асинхронные генераторы не могут возвращать значение, поэтому параметр типа `ReturnType` отсутствует. Как и в случае с [`Generator`](https://python-all.ru/3.10/library/typing.html#typing.Generator), `SendType` ведёт себя контравариантно.16911692Если генератор только выдаёт значения, установите `SendType` в `None`:16931694```python1695async def infinite_stream(start: int) -> AsyncGenerator[int, None]:1696    while True:1697        yield start1698        start = await increment(start)1699```17001701В качестве альтернативы аннотируйте генератор как имеющий тип возвращаемого значения либо `AsyncIterable[YieldType]`, либо `AsyncIterator[YieldType]`:17021703```python1704async def infinite_stream(start: int) -> AsyncIterator[int]:1705    while True:1706        yield start1707        start = await increment(start)1708```17091710Новое в версии 3.6.1.17111712Deprecated since version 3.9: [`collections.abc.AsyncGenerator`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.AsyncGenerator) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.10/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.10/library/stdtypes.html#types-genericalias).17131714#### `class typing.AsyncIterable(Generic[T_co])`17151716Обобщённая версия [`collections.abc.AsyncIterable`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.AsyncIterable).17171718Новое в версии 3.5.2.17191720Deprecated since version 3.9: [`collections.abc.AsyncIterable`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.AsyncIterable) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.10/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.10/library/stdtypes.html#types-genericalias).17211722#### `class typing.AsyncIterator(AsyncIterable[T_co])`17231724Обобщённая версия [`collections.abc.AsyncIterator`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.AsyncIterator).17251726Новое в версии 3.5.2.17271728Deprecated since version 3.9: [`collections.abc.AsyncIterator`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.AsyncIterator) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.10/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.10/library/stdtypes.html#types-genericalias).17291730#### `class typing.Awaitable(Generic[T_co])`17311732Обобщённая версия [`collections.abc.Awaitable`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.Awaitable).17331734Новое в версии 3.5.2.17351736Deprecated since version 3.9: [`collections.abc.Awaitable`](https://python-all.ru/3.10/library/collections.abc.html#collections.abc.Awaitable) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.10/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.10/library/stdtypes.html#types-genericalias).17371738#### Типы контекстных менеджеров17391740#### `class typing.ContextManager(Generic[T_co])`17411742Обобщённая версия [`contextlib.AbstractContextManager`](https://python-all.ru/3.10/library/contextlib.html#contextlib.AbstractContextManager).17431744Новое в версии 3.5.4.17451746Новое в версии 3.6.0.17471748Deprecated since version 3.9: [`contextlib.AbstractContextManager`](https://python-all.ru/3.10/library/contextlib.html#contextlib.AbstractContextManager) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.10/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.10/library/stdtypes.html#types-genericalias).17491750#### `class typing.AsyncContextManager(Generic[T_co])`17511752Обобщённая версия [`contextlib.AbstractAsyncContextManager`](https://python-all.ru/3.10/library/contextlib.html#contextlib.AbstractAsyncContextManager).17531754Новое в версии 3.5.4.17551756Новое в версии 3.6.2.17571758Deprecated since version 3.9: [`contextlib.AbstractAsyncContextManager`](https://python-all.ru/3.10/library/contextlib.html#contextlib.AbstractAsyncContextManager) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.10/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.10/library/stdtypes.html#types-genericalias).17591760### Протоколы17611762Эти протоколы декорированы [`runtime_checkable()`](https://python-all.ru/3.10/library/typing.html#typing.runtime_checkable).17631764#### `class typing.SupportsAbs`17651766ABC с одним абстрактным методом `__abs__`, ковариантным по типу возвращаемого значения.17671768#### `class typing.SupportsBytes`17691770ABC с одним абстрактным методом `__bytes__`.17711772#### `class typing.SupportsComplex`17731774ABC с одним абстрактным методом `__complex__`.17751776#### `class typing.SupportsFloat`17771778ABC с одним абстрактным методом `__float__`.17791780#### `class typing.SupportsIndex`17811782ABC с одним абстрактным методом `__index__`.17831784Новое в версии 3.8.17851786#### `class typing.SupportsInt`17871788ABC с одним абстрактным методом `__int__`.17891790#### `class typing.SupportsRound`17911792ABC с одним абстрактным методом `__round__` ковариантным по возвращаемому типу.17931794### Функции и декораторы17951796#### `typing.cast(typ, val)`17971798Приводит значение к типу.17991800Это возвращает значение без изменений. Для проверщика типов это сигнализирует, что возвращаемое значение имеет указанный тип, но во время выполнения мы намеренно ничего не проверяем (мы хотим, чтобы это было как можно быстрее).18011802#### `@typing.overload`18031804Декоратор `@overload` позволяет описывать функции и методы, поддерживающие несколько различных комбинаций типов аргументов. За серией определений, декорированных `@overload`, должно следовать ровно одно определение без `@overload` (для той же функции/метода). Определения с `@overload` предназначены только для проверки типов, так как они будут перезаписаны определением без `@overload`, которое используется во время выполнения, но должно игнорироваться проверщиком типов. Во время выполнения прямой вызов функции, декорированной `@overload`, вызовет [`NotImplementedError`](https://python-all.ru/3.10/library/exceptions.html#NotImplementedError). Пример перегрузки, дающей более точный тип, чем можно выразить с помощью объединения или переменной типа:18051806```python1807@overload1808def process(response: None) -> None:1809    ...1810@overload1811def process(response: int) -> tuple[int, str]:1812    ...1813@overload1814def process(response: bytes) -> str:1815    ...1816def process(response):1817    <actual implementation>1818```18191820Подробнее и сравнение с другими семантиками типизации см. [**PEP 484**](https://python-all.ru/3.10/library/typing.html).18211822#### `@typing.final`18231824Декоратор, указывающий проверщикам типов, что декорированный метод нельзя переопределить, а декорированный класс нельзя наследовать. Например:18251826```python1827class Base:1828    @final1829    def done(self) -> None:1830        ...1831class Sub(Base):1832    def done(self) -> None:  # Ошибка, выдаваемая проверщиком типов1833        ...18341835@final1836class Leaf:1837    ...1838class Other(Leaf):  # Ошибка, выдаваемая проверщиком типов1839    ...1840```18411842Проверка этих свойств во время выполнения не выполняется. Подробнее см. [**PEP 591**](https://python-all.ru/3.10/library/typing.html).18431844Новое в версии 3.8.18451846#### `@typing.no_type_check`18471848Декоратор, указывающий, что аннотации не являются подсказками типов.18491850Это работает как декоратор класса или функции [декоратор](https://python-all.ru/3.10/glossary.html#term-decorator). В случае класса он рекурсивно применяется ко всем методам, определённым в этом классе (но не к методам, определённым в его суперклассах или подклассах).18511852Это изменяет функцию(и) на месте.18531854#### `@typing.no_type_check_decorator`18551856Декоратор, придающий другому декоратору эффект [`no_type_check()`](https://python-all.ru/3.10/library/typing.html#typing.no_type_check).18571858Он оборачивает декоратор чем-то, что оборачивает декорированную функцию в [`no_type_check()`](https://python-all.ru/3.10/library/typing.html#typing.no_type_check).18591860#### `@typing.type_check_only`18611862Декоратор, помечающий класс или функцию как недоступные во время выполнения.18631864Сам этот декоратор недоступен во время выполнения. Он в основном предназначен для пометки классов, определённых в файлах заглушек типов (type stub), если реализация возвращает экземпляр закрытого класса:18651866```python1867@type_check_only1868class Response:  # приватный или недоступный во время выполнения1869    code: int1870    def get_header(self, name: str) -> str: ...18711872def fetch_response() -> Response: ...1873```18741875Обратите внимание, что возврат экземпляров закрытых классов не рекомендуется. Обычно предпочтительнее делать такие классы открытыми.18761877### Вспомогательные функции для интроспекции18781879#### `typing.get_type_hints(obj, globalns=None, localns=None, include_extras=False)`18801881Возвращает словарь, содержащий аннотации типов для функции, метода, модуля или объекта класса.18821883Это часто совпадает с `obj.__annotations__`. Кроме того, прямые ссылки, закодированные как строковые литералы, обрабатываются путём вычисления их в пространствах имён `globals` и `locals`. При необходимости `Optional[t]` добавляется для аннотаций функций и методов, если задано значение по умолчанию, равное `None`. Для класса `C` возвращается словарь, построенный объединением всех `__annotations__` по `C.__mro__` в обратном порядке.18841885Функция рекурсивно заменяет все `Annotated[T, ...]` на `T`, если только `include_extras` не установлено в `True` (см. [`Annotated`](https://python-all.ru/3.10/library/typing.html#typing.Annotated) для получения дополнительной информации). Например:18861887```python1888class Student(NamedTuple):1889    name: Annotated[str, 'some marker']18901891get_type_hints(Student) == {'name': str}1892get_type_hints(Student, include_extras=False) == {'name': str}1893get_type_hints(Student, include_extras=True) == {1894    'name': Annotated[str, 'some marker']1895}1896```18971898> **Примечание**1899>1900> [`get_type_hints()`](https://python-all.ru/3.10/library/typing.html#typing.get_type_hints) не работает с импортированными [псевдонимами типов](https://python-all.ru/3.10/library/typing.html#type-aliases), которые содержат прямые ссылки. Включение отложенного вычисления аннотаций ([**PEP 563**](https://python-all.ru/3.10/library/typing.html)) может устранить необходимость в большинстве прямых ссылок.19011902Изменено в версии 3.9: Добавлен параметр `include_extras` в рамках [**PEP 593**](https://python-all.ru/3.10/library/typing.html).19031904#### `typing.get_args(tp)`19051906#### `typing.get_origin(tp)`19071908Предоставляют базовую интроспекцию для обобщённых типов и специальных форм typing.19091910Для объекта typing вида `X[Y, Z, ...]` эти функции возвращают `X` и `(Y, Z, ...)`. Если `X` является обобщённым псевдонимом для встроенного класса или класса [`collections`](https://python-all.ru/3.10/library/collections.html#module-collections), он нормализуется до исходного класса. Если `X` является объединением или [`Literal`](https://python-all.ru/3.10/library/typing.html#typing.Literal), содержащимся в другом обобщённом типе, порядок `(Y, Z, ...)` может отличаться от порядка исходных аргументов `[Y, Z, ...]` из-за кэширования типов. Для неподдерживаемых объектов возвращают `None` и `()` соответственно. Примеры:19111912```python1913assert get_origin(Dict[str, int]) is dict1914assert get_args(Dict[int, str]) == (int, str)19151916assert get_origin(Union[int, str]) is Union1917assert get_args(Union[int, str]) == (int, str)1918```19191920Новое в версии 3.8.19211922#### `typing.is_typeddict(tp)`19231924Проверяет, является ли тип [`TypedDict`](https://python-all.ru/3.10/library/typing.html#typing.TypedDict).19251926Например:19271928```python1929class Film(TypedDict):1930    title: str1931    year: int19321933is_typeddict(Film)  # => True1934is_typeddict(list | str)  # => False1935```19361937Новое в версии 3.10.19381939#### `class typing.ForwardRef`19401941Класс, используемый для внутреннего представления типов строковых прямых ссылок. Например, `List["SomeClass"]` неявно преобразуется в `List[ForwardRef("SomeClass")]`. Этот класс не должен создаваться пользователем, но может использоваться инструментами интроспекции.19421943> **Примечание**1944>1945> обобщённые типы [**PEP 585**](https://python-all.ru/3.10/library/typing.html), такие как `list["SomeClass"]`, не будут неявно преобразовываться в `list[ForwardRef("SomeClass")]` и, следовательно, не будут автоматически разрешаться в `list[SomeClass]`.19461947Новое в версии 3.7.4.19481949### Константа19501951#### `typing.TYPE_CHECKING`19521953Специальная константа, которая считается `True` сторонними статическими проверщиками типов. Во время выполнения она равна `False`. Применение:19541955```python1956if TYPE_CHECKING:1957    import expensive_mod19581959def fun(arg: 'expensive_mod.SomeType') -> None:1960    local_var: expensive_mod.AnotherType = other_fun()1961```19621963Первую аннотацию типа необходимо заключать в кавычки, превращая её в «прямую ссылку» (forward reference), чтобы скрыть ссылку `expensive_mod` от интерпретатора во время выполнения. Аннотации типов для локальных переменных не вычисляются, поэтому вторую аннотацию не нужно заключать в кавычки.19641965> **Примечание**1966>1967> Если используется `from __future__ import annotations`, аннотации не вычисляются во время определения функции. Вместо этого они сохраняются как строки в `__annotations__`. Это избавляет от необходимости заключать аннотацию в кавычки (см. [**PEP 563**](https://python-all.ru/3.10/library/typing.html)).19681969Новое в версии 3.5.2.1970