typing.md
1> **Источник:** https://python-all.ru/3.15/library/typing.html2>3> «Документация Python на русском» – неофициальный перевод официальной документации Python: версии от 2.6 до 3.16, полнотекстовый поиск, английский оригинал рядом с переводом. Эта Markdown-версия страницы предназначена для работы с LLM: вставьте её в ChatGPT, Claude или Cursor.45---67# `typing` – Поддержка аннотаций типов89Добавлено в версии 3.5.1011**Исходный код:** [Lib/typing.py](https://python-all.ru/src/3.15/Lib/typing.py)1213> **Примечание**14>15> Среда выполнения Python не проверяет аннотации типов функций и переменных. Они могут использоваться сторонними инструментами, такими как [проверщики типов](https://python-all.ru/3.15/glossary.html#term-static-type-checker), IDE, линтеры и т. д.1617---1819Этот модуль обеспечивает поддержку аннотаций типов во время выполнения.2021Рассмотрим следующую функцию:2223```python24def surface_area_of_cube(edge_length: float) -> str:25 return f"The surface area of the cube is {6 * edge_length ** 2}."26```2728Функция `surface_area_of_cube` принимает аргумент, который должен быть экземпляром [`float`](https://python-all.ru/3.15/library/functions.html#float), на что указывает [аннотация типа](https://python-all.ru/3.15/glossary.html#term-type-hint) `edge_length: float`. Функция должна возвращать экземпляр [`str`](https://python-all.ru/3.15/library/stdtypes.html#str), на что указывает аннотация `-> str`.2930Хотя аннотации типов могут быть простыми классами, такими как [`float`](https://python-all.ru/3.15/library/functions.html#float) или [`str`](https://python-all.ru/3.15/library/stdtypes.html#str), они также могут быть более сложными. Модуль [`typing`](https://python-all.ru/3.15/library/typing.html#module-typing) предоставляет набор более продвинутых аннотаций типов.3132Новые функции часто добавляются в модуль `typing`. Пакет [typing\_extensions](https://python-all.ru/3.15/library/typing.html) предоставляет бэкпорты этих новых функций для старых версий Python.3334> **См. также**35>36> **[Шпаргалка по typing](https://python-all.ru/3.15/library/typing.html)**37>38> Краткий обзор аннотаций типов (размещён в документации mypy)39>40> **Раздел справочника по системе типов из [документации mypy](https://python-all.ru/3.15/library/typing.html)**41>42> Система типов Python стандартизирована через PEP, поэтому данное руководство должно в целом подходить для большинства проверщиков типов Python. (Некоторые части могут по-прежнему относиться только к mypy.)43>44> **[Статическая типизация в Python](https://python-all.ru/3.15/library/typing.html)**45>46> Независимая от проверщика типов документация, написанная сообществом, с подробным описанием возможностей системы типов, полезных инструментов, связанных с типизацией, и лучших практик типизации.4748## Спецификация системы типов Python4950Каноническая, актуальная спецификация системы типов Python находится по адресу [Specification for the Python type system](https://python-all.ru/3.15/library/typing.html).5152## Псевдонимы типов5354Псевдоним типа определяется с помощью оператора [`type`](https://python-all.ru/3.15/reference/simple_stmts.html#type), который создаёт экземпляр [`TypeAliasType`](https://python-all.ru/3.15/library/typing.html#typing.TypeAliasType). В этом примере `Vector` и `list[float]` будут рассматриваться статическими проверщиками типов как эквивалентные:5556```python57type Vector = list[float]5859def scale(scalar: float, vector: Vector) -> Vector:60 return [scalar * num for num in vector]6162# проходит проверку типов; список чисел с плавающей точкой считается Vector.63new_vector = scale(2.0, [1.0, -4.2, 5.4])64```6566Псевдонимы типов полезны для упрощения сложных сигнатур типов. Например:6768```python69from collections.abc import Sequence7071type ConnectionOptions = dict[str, str]72type Address = tuple[str, int]73type Server = tuple[Address, ConnectionOptions]7475def broadcast_message(message: str, servers: Sequence[Server]) -> None:76 ...7778# Статическая проверка типов будет считать предыдущую сигнатуру типа как79# полностью эквивалентную этой.80def broadcast_message(81 message: str,82 servers: Sequence[tuple[tuple[str, int], dict[str, str]]]83) -> None:84 ...85```8687Оператор [`type`](https://python-all.ru/3.15/reference/simple_stmts.html#type) появился в Python 3.12. Для обратной совместимости псевдонимы типов также можно создавать с помощью простого присваивания:8889```python90Vector = list[float]91```9293Или помечены [`TypeAlias`](https://python-all.ru/3.15/library/typing.html#typing.TypeAlias), чтобы было явно указано, что это псевдоним типа, а не обычное присваивание переменной:9495```python96from typing import TypeAlias9798Vector: TypeAlias = list[float]99```100101## NewType102103Используйте вспомогательную функцию [`NewType`](https://python-all.ru/3.15/library/typing.html#typing.NewType) для создания отдельных типов:104105```python106from typing import NewType107108UserId = NewType('UserId', int)109some_id = UserId(524313)110```111112Статический проверщик типов будет рассматривать новый тип как подкласс исходного типа. Это полезно для выявления логических ошибок:113114```python115def get_user_name(user_id: UserId) -> str:116 ...117118# проходит проверку типов119user_a = get_user_name(UserId(42351))120121# не проходит проверку типов; int не является UserId122user_b = get_user_name(-1)123```124125Можно по-прежнему выполнять все операции `int` над переменной типа `UserId`, но результат всегда будет типа `int`. Это позволяет передавать `UserId` везде, где может ожидаться `int`, но предотвращает случайное создание `UserId` недопустимым способом:126127```python128# 'output' имеет тип 'int', а не 'UserId'129output = UserId(23413) + UserId(54341)130```131132Обратите внимание, что эти проверки выполняются только статическим проверщиком типов. Во время выполнения оператор `Derived = NewType('Derived', Base)` сделает `Derived` вызываемым объектом, который немедленно возвращает любой переданный ему параметр. Это означает, что выражение `Derived(some_value)` не создаёт новый класс и не вносит значительных накладных расходов по сравнению с обычным вызовом функции.133134Точнее, выражение `some_value is Derived(some_value)` во время выполнения всегда истинно.135136Недопустимо создание подтипа `Derived`:137138```python139from typing import NewType140141UserId = NewType('UserId', int)142143# Завершается ошибкой во время выполнения и не проходит проверку типов144class AdminUserId(UserId): pass145```146147Однако можно создать [`NewType`](https://python-all.ru/3.15/library/typing.html#typing.NewType) на основе «производного» `NewType`:148149```python150from typing import NewType151152UserId = NewType('UserId', int)153154ProUserId = NewType('ProUserId', UserId)155```156157и проверка типов для `ProUserId` будет работать как ожидается.158159Подробнее см. [**PEP 484**](https://python-all.ru/3.15/library/typing.html).160161> **Примечание**162>163> Напомним, что использование псевдонима типа объявляет два типа *эквивалентными* друг другу. Использование `type Alias = Original` заставит статический анализатор типов считать `Alias` *точно эквивалентным* `Original` во всех случаях. Это полезно, когда требуется упростить сложные сигнатуры типов.164>165> В отличие от этого, `NewType` объявляет один тип *подтипом* другого. Использование `Derived = NewType('Derived', Original)` заставит статический анализатор типов считать `Derived` *подклассом* `Original`, что означает, что значение типа `Original` не может использоваться там, где ожидается значение типа `Derived`. Это полезно для предотвращения логических ошибок с минимальными затратами времени выполнения.166167Добавлено в версии 3.5.2.168169Изменено в версии 3.10: `NewType` теперь является классом, а не функцией. В результате имеются некоторые дополнительные расходы во время выполнения при вызове `NewType` по сравнению с обычной функцией.170171Изменено в версии 3.11: Производительность вызова `NewType` восстановлена до уровня Python 3.9.172173## Аннотация вызываемых объектов174175Функции – или другие [вызываемые](https://python-all.ru/3.15/glossary.html#term-callable) объекты – могут быть аннотированы с помощью [`collections.abc.Callable`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Callable) или устаревшего [`typing.Callable`](https://python-all.ru/3.15/library/typing.html#typing.Callable). `Callable[[int], str]` обозначает функцию, которая принимает один параметр типа [`int`](https://python-all.ru/3.15/library/functions.html#int) и возвращает [`str`](https://python-all.ru/3.15/library/stdtypes.html#str).176177Например:178179```python180from collections.abc import Callable, Awaitable181182def feeder(get_next_item: Callable[[], str]) -> None:183 ... # Тело184185def async_query(on_success: Callable[[int], None],186 on_error: Callable[[int, Exception], None]) -> None:187 ... # Тело188189async def on_update(value: str) -> None:190 ... # Тело191192callback: Callable[[str], Awaitable[None]] = on_update193```194195Синтаксис подписки всегда должен использоваться ровно с двумя значениями: списком аргументов и типом возврата. Список аргументов должен быть списком типов, [`ParamSpec`](https://python-all.ru/3.15/library/typing.html#typing.ParamSpec), [`Concatenate`](https://python-all.ru/3.15/library/typing.html#typing.Concatenate) или многоточием (`...`). Тип возврата должен быть одним типом.196197Если в качестве списка аргументов указано литеральное многоточие `...`, это означает, что принимается вызываемый объект с произвольным списком параметров:198199```python200def concat(x: str, y: str) -> str:201 return x + y202203x: Callable[..., str]204x = str # ОК205x = concat # Тоже ОК206```207208`Callable` не может выражать сложные сигнатуры, такие как функции, принимающие переменное количество аргументов, [перегруженные функции](https://python-all.ru/3.15/library/typing.html#overload) или функции, имеющие только ключевые параметры. Однако эти сигнатуры можно выразить, определив класс [`Protocol`](https://python-all.ru/3.15/library/typing.html#typing.Protocol) с методом [`__call__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__call__):209210```python211from collections.abc import Iterable212from typing import Protocol213214class Combiner(Protocol):215 def __call__(self, *vals: bytes, maxlen: int | None = None) -> list[bytes]: ...216217def batch_proc(data: Iterable[bytes], cb_results: Combiner) -> bytes:218 for item in data:219 ...220221def good_cb(*vals: bytes, maxlen: int | None = None) -> list[bytes]:222 ...223def bad_cb(*vals: bytes, maxitems: int | None) -> list[bytes]:224 ...225226batch_proc([], good_cb) # ОК227batch_proc([], bad_cb) # Ошибка! Аргумент 2 имеет несовместимый тип из-за228 # другого имени и вида в колбэке229```230231Объекты, принимающие другие вызываемые объекты в качестве аргументов, могут указать, что их типы параметров зависят друг от друга, с помощью [`ParamSpec`](https://python-all.ru/3.15/library/typing.html#typing.ParamSpec). Кроме того, если такой вызываемый объект добавляет или удаляет аргументы из других вызываемых объектов, может использоваться оператор [`Concatenate`](https://python-all.ru/3.15/library/typing.html#typing.Concatenate). Они имеют соответственно форму `Callable[ParamSpecVariable, ReturnType]` и `Callable[Concatenate[Arg1Type, Arg2Type, ..., ParamSpecVariable], ReturnType]`.232233Changed in version 3.10: `Callable` now supports [`ParamSpec`](https://python-all.ru/3.15/library/typing.html#typing.ParamSpec) and [`Concatenate`](https://python-all.ru/3.15/library/typing.html#typing.Concatenate). See [**PEP 612**](https://python-all.ru/3.15/library/typing.html) for more details.234235> **См. также**236>237> В документации к [`ParamSpec`](https://python-all.ru/3.15/library/typing.html#typing.ParamSpec) и [`Concatenate`](https://python-all.ru/3.15/library/typing.html#typing.Concatenate) приведены примеры использования в `Callable`.238239## Обобщённые типы240241Поскольку информацию о типах объектов, хранящихся в контейнерах, невозможно статически вывести обобщённым способом, многие классы контейнеров в стандартной библиотеке поддерживают индексацию для указания ожидаемых типов элементов контейнера.242243```python244from collections.abc import Mapping, Sequence245246class Employee: ...247248# Sequence[Employee] означает, что все элементы последовательности249# должны быть экземплярами "Employee".250# Mapping[str, str] означает, что все ключи и все значения в отображении251# должны быть строками.252def notify_by_email(employees: Sequence[Employee],253 overrides: Mapping[str, str]) -> None: ...254```255256Обобщённые функции и классы могут быть параметризованы с помощью [синтаксиса параметров типа](https://python-all.ru/3.15/reference/compound_stmts.html#type-params):257258```python259from collections.abc import Sequence260261def first[T](l: Sequence[T]) -> T: # Функция универсальна (обобщена) по TypeVar "T"262 return l[0]263```264265Или с помощью непосредственного использования фабрики [`TypeVar`](https://python-all.ru/3.15/library/typing.html#typing.TypeVar):266267```python268from collections.abc import Sequence269from typing import TypeVar270271U = TypeVar('U') # Объявить переменную типа "U"272273def second(l: Sequence[U]) -> U: # Функция универсальна (обобщена) по TypeVar "U"274 return l[1]275```276277Изменено в версии 3.12: Синтаксическая поддержка обобщённых типов новая в Python 3.12.278279## Аннотация кортежей280281Для большинства контейнеров в Python система типов предполагает, что все элементы в контейнере будут одного типа. Например:282283```python284from collections.abc import Mapping285286# Проверка типов выведет, что все элементы в ``x`` должны иметь тип int.287x: list[int] = []288289# Ошибка проверки типов: ``list`` принимает только один аргумент типа:290y: list[int, str] = [1, 'foo']291292# Проверка типов выведет, что все ключи в ``z`` должны быть строками,293# а все значения в ``z`` должны быть строками или int.294z: Mapping[str, str | int] = {}295```296297[`list`](https://python-all.ru/3.15/library/stdtypes.html#list) принимает только один аргумент типа, поэтому анализатор типов выдал бы ошибку на присваивании `y` выше. Аналогично, [`Mapping`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Mapping) принимает только два аргумента типа: первый указывает тип ключей, а второй – тип значений.298299Однако, в отличие от большинства других контейнеров Python, в идиоматическом коде Python часто встречаются кортежи, элементы которых не все одного типа. По этой причине кортежи обрабатываются особым образом в системе типов Python. [`tuple`](https://python-all.ru/3.15/library/stdtypes.html#tuple) принимает *любое количество* аргументов типа:300301```python302# OK: ``x`` присваивается кортежу длины 1, единственный элемент которого – int.303x: tuple[int] = (5,)304305# OK: ``y`` присваивается кортежу длины 2;306# элемент 1 – int, элемент 2 – str.307y: tuple[int, str] = (5, "foo")308309# Ошибка: аннотация типа указывает на кортеж длины 1,310# но ``z`` был присвоен кортеж длины 3.311z: tuple[int] = (1, 2, 3)312```313314Чтобы обозначить кортеж, который может быть *любой* длины, и в котором все элементы имеют один тип `T`, используйте литеральное многоточие `...`: `tuple[T, ...]`. Чтобы обозначить пустой кортеж, используйте `tuple[()]`. Использование простого `tuple` в качестве аннотации эквивалентно использованию `tuple[Any, ...]`:315316```python317x: tuple[int, ...] = (1, 2)318# Эти переприсваивания OK: ``tuple[int, ...]`` указывает, что x может быть любой длины.319x = (1, 2, 3)320x = ()321# Это переприсваивание – ошибка: все элементы в ``x`` должны быть int.322x = ("foo", "bar")323324# ``y`` может быть присвоен только пустому кортежу.325y: tuple[()] = ()326327z: tuple = ("foo", "bar")328# Эти переприсваивания OK: простой ``tuple`` эквивалентен ``tuple[Any, ...]``.329z = (1, 2, 3)330z = ()331```332333## Тип объектов классов334335Переменная, аннотированная `C`, может принимать значение типа `C`. В отличие от этого, переменная, аннотированная `type[C]` (или устаревшим [`typing.Type[C]`](https://python-all.ru/3.15/library/typing.html#typing.Type)), может принимать значения, которые сами являются классами – точнее, она будет принимать *объект класса* `C`. Например:336337```python338a = 3 # Имеет тип ``int``.339b = int # Имеет тип ``type[int]``.340c = type(a) # Также имеет тип ``type[int]``.341```342343Обратите внимание, что `type[C]` ковариантен:344345```python346class User: ...347class ProUser(User): ...348class TeamUser(User): ...349350def make_new_user(user_class: type[User]) -> User:351 # ...352 return user_class()353354make_new_user(User) # ОК355make_new_user(ProUser) # Также OK: ``type[ProUser]`` – подтип ``type[User]``.356make_new_user(TeamUser) # По-прежнему допустимо.357make_new_user(User()) # Ошибка: ожидался ``type[User]``, но получен ``User``.358make_new_user(int) # Ошибка: ``type[int]`` не является подтипом ``type[User]``.359```360361Единственными допустимыми параметрами для [`type`](https://python-all.ru/3.15/library/functions.html#type) являются классы, [`Any`](https://python-all.ru/3.15/library/typing.html#typing.Any), [переменные типа](https://python-all.ru/3.15/library/typing.html#generics) и объединения любых из этих типов. Например:362363```python364def new_non_team_user(user_class: type[BasicUser | ProUser]): ...365366new_non_team_user(BasicUser) # ОК367new_non_team_user(ProUser) # ОК368new_non_team_user(TeamUser) # Ошибка: ``type[TeamUser]`` не является подтипом369 # ``type[BasicUser | ProUser]``.370new_non_team_user(User) # Тоже ошибка.371```372373`type[Any]` эквивалентно [`type`](https://python-all.ru/3.15/library/functions.html#type), который является корнем [иерархии метаклассов](https://python-all.ru/3.15/reference/datamodel.html#metaclasses) Python.374375## Аннотация генераторов и корутин376377Генератор можно аннотировать с помощью обобщённого типа [`Generator[YieldType, SendType, ReturnType]`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Generator). Например:378379```python380def echo_round() -> Generator[int, float, str]:381 sent = yield 0382 while sent >= 0:383 sent = yield round(sent)384 return 'Done'385```386387Обратите внимание, что, в отличие от многих других обобщённых классов в стандартной библиотеке, `SendType` [`Generator`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Generator) ведёт себя контравариантно, а не ковариантно или инвариантно.388389Параметры `SendType` и `ReturnType` по умолчанию равны `None`:390391```python392def infinite_stream(start: int) -> Generator[int]:393 while True:394 yield start395 start += 1396```397398Также можно задать эти типы явно:399400```python401def infinite_stream(start: int) -> Generator[int, None, None]:402 while True:403 yield start404 start += 1405```406407Простые генераторы, которые только возвращают значения, также могут быть аннотированы с типом возврата [`Iterable[YieldType]`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Iterable) или [`Iterator[YieldType]`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Iterator):408409```python410def infinite_stream(start: int) -> Iterator[int]:411 while True:412 yield start413 start += 1414```415416Асинхронные генераторы обрабатываются аналогично, но не ожидают аргумента типа `ReturnType` ([`AsyncGenerator[YieldType, SendType]`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.AsyncGenerator)). Аргумент `SendType` по умолчанию равен `None`, поэтому следующие определения эквивалентны:417418```python419async def infinite_stream(start: int) -> AsyncGenerator[int]:420 while True:421 yield start422 start = await increment(start)423424async def infinite_stream(start: int) -> AsyncGenerator[int, None]:425 while True:426 yield start427 start = await increment(start)428```429430Как и в синхронном случае, [`AsyncIterable[YieldType]`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.AsyncIterable) и [`AsyncIterator[YieldType]`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.AsyncIterator) также доступны:431432```python433async def infinite_stream(start: int) -> AsyncIterator[int]:434 while True:435 yield start436 start = await increment(start)437```438439Корутины можно аннотировать с помощью [`Coroutine[YieldType, SendType, ReturnType]`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Coroutine). Обобщённые аргументы соответствуют аргументам [`Generator`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Generator), например:440441```python442from collections.abc import Coroutine443c: Coroutine[list[str], str, int] # Некоторая корутина, определённая в другом месте.444x = c.send('hi') # Выведенный тип 'x' – list[str].445async def bar() -> None:446 y = await c # Выведенный тип 'y' – int.447```448449## Пользовательские обобщённые типы450451Пользовательский класс можно определить как обобщённый класс.452453```python454from logging import Logger455456class LoggedVar[T]:457 def __init__(self, value: T, name: str, logger: Logger) -> None:458 self.name = name459 self.logger = logger460 self.value = value461462 def set(self, new: T) -> None:463 self.log('Set ' + repr(self.value))464 self.value = new465466 def get(self) -> T:467 self.log('Get ' + repr(self.value))468 return self.value469470 def log(self, message: str) -> None:471 self.logger.info('%s: %s', self.name, message)472```473474Этот синтаксис означает, что класс `LoggedVar` параметризован одной [переменной типа](https://python-all.ru/3.15/library/typing.html#typevar) `T`. Это также делает `T` допустимым типом в теле класса.475476Обобщённые классы неявно наследуются от [`Generic`](https://python-all.ru/3.15/library/typing.html#typing.Generic). Для совместимости с Python 3.11 и ниже можно также явно наследоваться от `Generic`, чтобы указать обобщённый класс:477478```python479from typing import TypeVar, Generic480481T = TypeVar('T')482483class LoggedVar(Generic[T]):484 ...485```486487Обобщённые классы имеют методы [`__class_getitem__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__class_getitem__), что означает возможность параметризации во время выполнения (например, `LoggedVar[int]` ниже):488489```python490from collections.abc import Iterable491492def zero_all_vars(vars: Iterable[LoggedVar[int]]) -> None:493 for var in vars:494 var.set(0)495```496497Обобщённый тип может иметь любое количество переменных типа. Все разновидности [`TypeVar`](https://python-all.ru/3.15/library/typing.html#typing.TypeVar) допустимы в качестве параметров обобщённого типа:498499```python500from typing import TypeVar, Generic, Sequence501502class WeirdTrio[T, B: Sequence[bytes], S: (int, str)]:503 ...504505OldT = TypeVar('OldT', contravariant=True)506OldB = TypeVar('OldB', bound=Sequence[bytes], covariant=True)507OldS = TypeVar('OldS', int, str)508509class OldWeirdTrio(Generic[OldT, OldB, OldS]):510 ...511```512513Каждый аргумент-переменная типа для [`Generic`](https://python-all.ru/3.15/library/typing.html#typing.Generic) должен быть уникальным. Поэтому такой код некорректен:514515```python516from typing import TypeVar, Generic517...518519class Pair[M, M]: # SyntaxError520 ...521522T = TypeVar('T')523524class Pair(Generic[T, T]): # INVALID525 ...526```527528Обобщённые классы также могут наследоваться от других классов:529530```python531from collections.abc import Sized532533class LinkedList[T](Sized):534 ...535```536537При наследовании от обобщённых классов некоторые параметры типа могут быть фиксированными:538539```python540from collections.abc import Mapping541542class MyDict[T](Mapping[str, T]):543 ...544```545546В этом случае `MyDict` имеет один параметр – `T`.547548Использование обобщённого класса без указания параметров типа подразумевает [`Any`](https://python-all.ru/3.15/library/typing.html#typing.Any) для каждой позиции. В следующем примере `MyIterable` не является обобщённым, но неявно наследуется от `Iterable[Any]`:549550```python551from collections.abc import Iterable552553class MyIterable(Iterable): # То же, что и Iterable[Any].554 ...555```556557Также поддерживаются пользовательские псевдонимы обобщённых типов. Примеры:558559```python560from collections.abc import Iterable561562type Response[S] = Iterable[S] | int563564# Тип возвращаемого значения здесь такой же, как Iterable[str] | int565def response(query: str) -> Response[str]:566 ...567568type Vec[T] = Iterable[tuple[T, T]]569570def inproduct[T: (int, float, complex)](v: Vec[T]) -> T: # То же, что и Iterable[tuple[T, T]]571 return sum(x*y for x, y in v)572```573574Для обратной совместимости псевдонимы обобщённых типов можно также создать простым присваиванием:575576```python577from collections.abc import Iterable578from typing import TypeVar579580S = TypeVar("S")581Response = Iterable[S] | int582```583584Изменено в версии 3.7: [`Generic`](https://python-all.ru/3.15/library/typing.html#typing.Generic) больше не имеет собственного метакласса.585586Изменено в версии 3.12: Синтаксическая поддержка обобщений и псевдонимов типов появилась в версии 3.12. Ранее обобщённые классы должны были явно наследоваться от [`Generic`](https://python-all.ru/3.15/library/typing.html#typing.Generic) или содержать переменную типа в одной из своих баз.587588Пользовательские обобщения для выражений параметров также поддерживаются через переменные спецификации параметров вида `[**P]`. Поведение согласуется с описанным выше для переменных типа, поскольку модуль `typing` обрабатывает переменные спецификации параметров как специализированную переменную типа. Единственное исключение – список типов можно использовать для подстановки [`ParamSpec`](https://python-all.ru/3.15/library/typing.html#typing.ParamSpec):589590```python591>>> class Z[T, **P]: ... # T – это TypeVar; P – это ParamSpec592...593>>> Z[int, [dict, float]]594__main__.Z[int, [dict, float]]595```596597Классы, обобщённые по [`ParamSpec`](https://python-all.ru/3.15/library/typing.html#typing.ParamSpec), также можно создать с помощью явного наследования от [`Generic`](https://python-all.ru/3.15/library/typing.html#typing.Generic). В этом случае `**` не используется:598599```python600from typing import ParamSpec, Generic601602P = ParamSpec('P')603604class Z(Generic[P]):605 ...606```607608Ещё одно различие между [`TypeVar`](https://python-all.ru/3.15/library/typing.html#typing.TypeVar) и [`ParamSpec`](https://python-all.ru/3.15/library/typing.html#typing.ParamSpec) заключается в том, что обобщение только с одной переменной спецификации параметров принимает списки параметров в виде `X[[Type1, Type2, ...]]`, а также `X[Type1, Type2, ...]` из эстетических соображений. Внутренне последняя форма преобразуется в первую, поэтому следующие варианты эквивалентны:609610```python611>>> class X[**P]: ...612...613>>> X[int, str]614__main__.X[[int, str]]615>>> X[[int, str]]616__main__.X[[int, str]]617```618619Обратите внимание: обобщения с [`ParamSpec`](https://python-all.ru/3.15/library/typing.html#typing.ParamSpec) могут не иметь корректного `__parameters__` после подстановки в некоторых случаях, поскольку они предназначены в первую очередь для статической проверки типов.620621Изменено в версии 3.10: [`Generic`](https://python-all.ru/3.15/library/typing.html#typing.Generic) теперь можно параметризовать по выражениям параметров. Подробнее см. [`ParamSpec`](https://python-all.ru/3.15/library/typing.html#typing.ParamSpec) и [**PEP 612**](https://python-all.ru/3.15/library/typing.html).622623Пользовательский обобщённый класс может иметь ABC в качестве базовых классов без конфликта метаклассов. Обобщённые метаклассы не поддерживаются. Результат параметризации обобщений кэшируется, и большинство типов в модуле `typing` являются [хешируемыми](https://python-all.ru/3.15/glossary.html#term-hashable) и сравнимыми на равенство.624625## Тип [`Any`](https://python-all.ru/3.15/library/typing.html#typing.Any)626627Особым видом типа является [`Any`](https://python-all.ru/3.15/library/typing.html#typing.Any). Статический анализатор типов будет считать любой тип присваиваемым `Any`, а `Any` – присваиваемым любому типу.628629Это означает, что над значением типа [`Any`](https://python-all.ru/3.15/library/typing.html#typing.Any) можно выполнять любые операции или вызовы методов и присваивать его любой переменной:630631```python632from typing import Any633634a: Any = None635a = [] # ОК636a = 2 # ОК637638s: str = ''639s = a # ОК640641def foo(item: Any) -> int:642 # Проходит проверку типов; 'item' может быть любого типа,643 # и этот тип может иметь метод 'bar'644 item.bar()645 ...646```647648Обратите внимание: при присваивании значения типа [`Any`](https://python-all.ru/3.15/library/typing.html#typing.Any) более точному типу проверка типов не выполняется. Например, статический анализатор типов не сообщил об ошибке при присваивании `a` переменной `s`, хотя `s` была объявлена как тип [`str`](https://python-all.ru/3.15/library/stdtypes.html#str) и во время выполнения получает значение [`int`](https://python-all.ru/3.15/library/functions.html#int)!649650Кроме того, все функции без указания типа возврата или типов параметров по умолчанию неявно используют [`Any`](https://python-all.ru/3.15/library/typing.html#typing.Any):651652```python653def legacy_parser(text):654 ...655 return data656657# Статический проверщик типов будет рассматривать вышеприведенное658# как имеющее ту же сигнатуру, что и:659def legacy_parser(text: Any) -> Any:660 ...661 return data662```663664Такое поведение позволяет использовать [`Any`](https://python-all.ru/3.15/library/typing.html#typing.Any) в качестве *запасного выхода*, когда нужно смешивать динамически и статически типизированный код.665666Сравните поведение [`Any`](https://python-all.ru/3.15/library/typing.html#typing.Any) с поведением [`object`](https://python-all.ru/3.15/library/functions.html#object). Как и `Any`, каждый тип является подтипом `object`. Однако, в отличие от `Any`, обратное неверно: `object` *не* является подтипом любого другого типа.667668Это означает, что когда тип значения – [`object`](https://python-all.ru/3.15/library/functions.html#object), проверяющий типы будет отклонять почти все операции над ним, а присваивание его переменной (или использование в качестве возвращаемого значения) более специализированного типа является ошибкой типа. Например:669670```python671def hash_a(item: object) -> int:672 # Не проходит проверку типов; у объекта нет метода 'magic'.673 item.magic()674 ...675676def hash_b(item: Any) -> int:677 # Проходит проверку типов678 item.magic()679 ...680681# Проходит проверку типов, так как int и str являются подклассами object682hash_a(42)683hash_a("foo")684685# Проходит проверку типов, так как Any может быть присвоен любому типу686hash_b(42)687hash_b("foo")688```689690Используйте [`object`](https://python-all.ru/3.15/library/functions.html#object), чтобы указать, что значение может быть любого типа в типобезопасной манере. Используйте [`Any`](https://python-all.ru/3.15/library/typing.html#typing.Any), чтобы указать, что значение динамически типизировано.691692## Номинальная и структурная типизация693694Изначально [**PEP 484**](https://python-all.ru/3.15/library/typing.html) определял систему статической типизации Python как использующую *номинальное подтипирование*. Это означает, что класс `A` разрешён там, где ожидается класс `B`, если и только если `A` является подклассом `B`.695696Ранее это требование также применялось к абстрактным базовым классам, таким как [`Iterable`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Iterable). Проблема такого подхода в том, что класс должен быть явно помечен для их поддержки, что непитонично и не похоже на то, что обычно делается в идиоматическом динамически типизированном коде Python. Например, следующее соответствует [**PEP 484**](https://python-all.ru/3.15/library/typing.html):697698```python699from collections.abc import Sized, Iterable, Iterator700701class Bucket(Sized, Iterable[int]):702 ...703 def __len__(self) -> int: ...704 def __iter__(self) -> Iterator[int]: ...705```706707[**PEP 544**](https://python-all.ru/3.15/library/typing.html) решает эту проблему, позволяя пользователям писать приведённый выше код без явных базовых классов в определении класса, что позволяет `Bucket` неявно считаться подтипом как `Sized`, так и `Iterable[int]` статическими проверяющими типы. Это известно как *структурное подтипирование* (или статическая утиная типизация):708709```python710from collections.abc import Iterator, Iterable711712class Bucket: # Примечание: базовые классы отсутствуют713 ...714 def __len__(self) -> int: ...715 def __iter__(self) -> Iterator[int]: ...716717def collect(items: Iterable[int]) -> int: ...718result = collect(Bucket()) # Проходит проверку типов719```720721Более того, наследуя специальный класс [`Protocol`](https://python-all.ru/3.15/library/typing.html#typing.Protocol), пользователь может определять новые пользовательские протоколы, чтобы в полной мере использовать структурное подтипирование (см. примеры ниже).722723## Содержимое модуля724725Модуль `typing` определяет следующие классы, функции и декораторы.726727### Специальные примитивы типизации728729#### Специальные типы730731Их можно использовать в качестве типов в аннотациях. Они не поддерживают подписку с помощью `[]`.732733#### `typing.Any`734735Специальный тип, указывающий на неограниченный тип.736737- Каждый тип может быть присвоен `Any`.738- `Any` может быть присвоен любому типу.739740Изменено в версии 3.11: `Any` теперь можно использовать в качестве базового класса. Это может быть полезно для предотвращения ошибок проверки типов в классах, которые могут использовать утиную типизацию где угодно или являются сильно динамичными.741742#### `typing.AnyStr`743744[Ограниченная переменная типа](https://python-all.ru/3.15/library/typing.html#typing-constrained-typevar).745746Определение:747748```python749AnyStr = TypeVar('AnyStr', str, bytes)750```751752`AnyStr` предназначен для функций, которые могут принимать аргументы типа [`str`](https://python-all.ru/3.15/library/stdtypes.html#str) или [`bytes`](https://python-all.ru/3.15/library/stdtypes.html#bytes), но не допускают их смешивания.753754Например:755756```python757def concat(a: AnyStr, b: AnyStr) -> AnyStr:758 return a + b759760concat("foo", "bar") # OK, результат имеет тип 'str'761concat(b"foo", b"bar") # OK, результат имеет тип 'bytes'762concat("foo", b"bar") # Ошибка, нельзя смешивать str и bytes763```764765Обратите внимание, что, несмотря на название, `AnyStr` не имеет никакого отношения к типу [`Any`](https://python-all.ru/3.15/library/typing.html#typing.Any) и не означает «любая строка». В частности, `AnyStr` и `str | bytes` отличаются друг от друга и имеют разные сценарии использования:766767```python768# Неверное использование AnyStr:769# Переменная типа используется только один раз в сигнатуре функции,770# поэтому не может быть «решена» проверщиком типов771def greet_bad(cond: bool) -> AnyStr:772 return "hi there!" if cond else b"greetings!"773774# Лучший способ аннотировать эту функцию:775def greet_proper(cond: bool) -> str | bytes:776 return "hi there!" if cond else b"greetings!"777```778779Устарело с версии 3.13, будет удалено в версии 3.18: Устарело в пользу нового [синтаксиса параметров типа](https://python-all.ru/3.15/reference/compound_stmts.html#type-params). Используйте `class A[T: (str, bytes)]: ...` вместо импорта `AnyStr`. Подробнее см. [**PEP 695**](https://python-all.ru/3.15/library/typing.html).780781В Python 3.16 `AnyStr` будет удалён из `typing.__all__`, и будет выдаваться предупреждение об устаревании во время выполнения при обращении к нему или импорте из `typing`. `AnyStr` будет удалён из `typing` в Python 3.18.782783#### `typing.LiteralString`784785Специальный тип, включающий только строковые литералы.786787Любой строковый литерал совместим с `LiteralString`, как и другой `LiteralString`. Однако объект, типизированный просто как `str`, – нет. Строка, созданная композицией объектов типа `LiteralString`, также приемлема как `LiteralString`.788789Пример:790791```python792def run_query(sql: LiteralString) -> None:793 ...794795def caller(arbitrary_string: str, literal_string: LiteralString) -> None:796 run_query("SELECT * FROM students") # ОК797 run_query(literal_string) # ОК798 run_query("SELECT * FROM " + literal_string) # ОК799 run_query(arbitrary_string) # ошибка проверки типов800 run_query( # ошибка проверки типов801 f"SELECT * FROM students WHERE name = {arbitrary_string}"802 )803```804805`LiteralString` полезен для чувствительных API, где произвольные пользовательские строки могут создавать проблемы. Например, два приведённых выше случая, которые вызывают ошибки проверки типов, могут быть уязвимы для SQL-инъекций.806807Подробнее см. [**PEP 675**](https://python-all.ru/3.15/library/typing.html).808809Добавлено в версии 3.12.810811#### `typing.Never`812813#### `typing.NoReturn`814815`Never` и `NoReturn` представляют [нижний тип](https://python-all.ru/3.15/library/typing.html), тип, не имеющий элементов.816817Их можно использовать для обозначения того, что функция никогда не возвращает значение, например [`sys.exit()`](https://python-all.ru/3.15/library/sys.html#sys.exit):818819```python820from typing import Never # или NoReturn821822def stop() -> Never:823 raise RuntimeError('no way')824```825826Или для определения функции, которая никогда не должна вызываться, поскольку нет допустимых аргументов, например [`assert_never()`](https://python-all.ru/3.15/library/typing.html#typing.assert_never):827828```python829from typing import Never # или NoReturn830831def never_call_me(arg: Never) -> None:832 pass833834def int_or_str(arg: int | str) -> None:835 never_call_me(arg) # ошибка проверки типов836 match arg:837 case int():838 print("It's an int")839 case str():840 print("It's a str")841 case _:842 never_call_me(arg) # OK, аргумент имеет тип Never (или NoReturn)843```844845`Never` и `NoReturn` имеют одинаковое значение в системе типов, и статические анализаторы типов обрабатывают их одинаково.846847Добавлено в версии 3.6.2: Добавлен `NoReturn`.848849Добавлено в версии 3.11: Добавлен `Never`.850851#### `typing.Self`852853Специальный тип для представления текущего вложенного класса.854855Например:856857```python858from typing import Self, reveal_type859860class Foo:861 def return_self(self) -> Self:862 ...863 return self864865class SubclassOfFoo(Foo): pass866867reveal_type(Foo().return_self()) # Раскрытый тип – "Foo"868reveal_type(SubclassOfFoo().return_self()) # Раскрытый тип – "SubclassOfFoo"869```870871Эта аннотация семантически эквивалентна следующему, хотя и в более краткой форме:872873```python874from typing import TypeVar875876Self = TypeVar("Self", bound="Foo")877878class Foo:879 def return_self(self: Self) -> Self:880 ...881 return self882```883884В общем случае, если что-то возвращает `self`, как в примерах выше, следует использовать `Self` в качестве аннотации возвращаемого типа. Если `Foo.return_self` был аннотирован как возвращающий `"Foo"`, то анализатор типов выведет, что объект, возвращённый из `SubclassOfFoo.return_self`, имеет тип `Foo` , а не `SubclassOfFoo`.885886Другие распространённые случаи использования включают:887888- [`classmethod`](https://python-all.ru/3.15/library/functions.html#classmethod), которые используются как альтернативные конструкторы и возвращают экземпляры параметра `cls`.889- Аннотирование метода [`__enter__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__enter__), который возвращает self.890891Не следует использовать `Self` в качестве аннотации возвращаемого типа, если метод не гарантирует возврат экземпляра подкласса при наследовании класса:892893```python894class Eggs:895 # Self здесь была бы некорректной аннотацией возврата,896 # так как возвращаемый объект всегда является экземпляром Eggs,897 # даже в подклассах.898 def returns_eggs(self) -> "Eggs":899 return Eggs()900```901902См. [**PEP 673**](https://python-all.ru/3.15/library/typing.html) для получения дополнительных сведений.903904Добавлено в версии 3.12.905906#### `typing.TypeAlias`907908Специальная аннотация для явного объявления [псевдонима типа](https://python-all.ru/3.15/library/typing.html#type-aliases).909910Например:911912```python913from typing import TypeAlias914915Factors: TypeAlias = list[int]916```917918`TypeAlias` особенно полезен в старых версиях Python для аннотирования псевдонимов, которые используют опережающие ссылки, поскольку анализаторам типов может быть трудно отличить их от обычных присваиваний переменных:919920```python921from typing import Generic, TypeAlias, TypeVar922923T = TypeVar("T")924925# "Box" ещё не существует,926# поэтому для прямой ссылки на Python <3.12 приходится использовать кавычки.927# Использование ``TypeAlias`` сообщает тайпчекеру, что это объявление псевдонима типа,928# а не присваивание переменной строкового значения.929BoxOfStrings: TypeAlias = "Box[str]"930931class Box(Generic[T]):932 @classmethod933 def make_box_of_strings(cls) -> BoxOfStrings: ...934```935936См. [**PEP 613**](https://python-all.ru/3.15/library/typing.html) для получения дополнительных сведений.937938Добавлено в версии 3.10.939940Устарело с версии 3.12: `TypeAlias` устарел в пользу инструкции [`type`](https://python-all.ru/3.15/reference/simple_stmts.html#type), которая создаёт экземпляры [`TypeAliasType`](https://python-all.ru/3.15/library/typing.html#typing.TypeAliasType) и поддерживает опережающие ссылки изначально. Обратите внимание, что, хотя `TypeAlias` и `TypeAliasType` служат похожим целям и имеют похожие названия, они различаются, и последний не является типом первого. Удаление `TypeAlias` в настоящее время не планируется, но пользователям рекомендуется переходить на инструкции `type`.941942#### Специальные формы943944Их можно использовать в качестве типов в аннотациях. Они все поддерживают индексацию с помощью `[]`, но каждый из них имеет уникальный синтаксис.945946#### `class typing.Union`947948Тип объединения; `Union[X, Y]` эквивалентно `X | Y` и означает X или Y.949950Для определения объединения используйте, например, `Union[int, str]` или сокращённую запись `int | str`. Рекомендуется использовать сокращённую запись. Подробности:951952- Аргументы должны быть типами, и их должно быть как минимум один.953- Объединения объединений разворачиваются, например:954955 ```python956 Union[Union[int, str], float] == Union[int, str, float]957 ```958959 Однако это не относится к объединениям, на которые ссылаются через псевдоним типа, чтобы избежать принудительного вычисления нижележащего [`TypeAliasType`](https://python-all.ru/3.15/library/typing.html#typing.TypeAliasType):960961 ```python962 type A = Union[int, str]963 Union[A, float] != Union[int, str, float]964 ```965- Объединения из одного аргумента исчезают, например:966967 ```python968 Union[int] == int # Конструктор на самом деле возвращает int969 ```970- Повторяющиеся аргументы пропускаются, например:971972 ```python973 Union[int, str, int] == Union[int, str] == int | str974 ```975- При сравнении объединений порядок аргументов игнорируется, например:976977 ```python978 Union[int, str] == Union[str, int]979 ```980- Нельзя наследовать или создавать экземпляр `Union`.981- Нельзя записать `Union[X][Y]`.982983Изменено в версии 3.7: Явные подклассы не удаляются из объединений во время выполнения.984985Изменено в версии 3.10: Объединения теперь можно записывать как `X | Y`. См. [выражения типов объединений](https://python-all.ru/3.15/library/stdtypes.html#types-union).986987Изменено в версии 3.14: [`types.UnionType`](https://python-all.ru/3.15/library/types.html#types.UnionType) теперь является псевдонимом для `Union`, и оба `Union[int, str]` и `int | str` создают экземпляры одного и того же класса. Чтобы проверить, является ли объект `Union` во время выполнения, используйте `isinstance(obj, Union)`. Для совместимости с более ранними версиями Python используйте `get_origin(obj) is typing.Union or get_origin(obj) is types.UnionType`.988989#### `typing.Optional`990991`Optional[X]` эквивалентен `X | None` (или `Union[X, None]`).992993Обратите внимание, что это не то же самое, что необязательный аргумент, который имеет значение по умолчанию. Необязательный аргумент с значением по умолчанию не требует квалификатора `Optional` в своей аннотации типа только потому, что он необязателен. Например:994995```python996def foo(arg: int = 0) -> None:997 ...998```9991000С другой стороны, если явное значение `None` допускается, то использование `Optional` уместно, независимо от того, является ли аргумент необязательным или нет. Например:10011002```python1003def foo(arg: Optional[int] = None) -> None:1004 ...1005```10061007Изменено в версии 3.10: Optional теперь можно записывать как `X | None`. См. [выражения типов объединений](https://python-all.ru/3.15/library/stdtypes.html#types-union).10081009#### `typing.Concatenate`10101011Специальная форма для аннотирования функций высшего порядка.10121013`Concatenate` можно использовать вместе с [Callable](https://python-all.ru/3.15/library/typing.html#annotating-callables) и [`ParamSpec`](https://python-all.ru/3.15/library/typing.html#typing.ParamSpec) для аннотирования вызываемого объекта высшего порядка, который добавляет, удаляет или преобразует параметры другого вызываемого объекта. Использование имеет форму `Concatenate[Arg1Type, Arg2Type, ..., ParamSpecVariable]`. `Concatenate` действителен при использовании в подсказках типа [Callable](https://python-all.ru/3.15/library/typing.html#annotating-callables) и при создании экземпляров пользовательских обобщённых классов с параметрами `ParamSpec`. Последний параметр `Concatenate` должен быть `ParamSpec` или многоточие (`...`).10141015Например, чтобы аннотировать декоратор `with_lock`, который предоставляет [`threading.Lock`](https://python-all.ru/3.15/library/threading.html#threading.Lock) декорируемой функции, можно использовать `Concatenate`, чтобы указать, что `with_lock` ожидает вызываемый объект, который принимает `Lock` в качестве первого аргумента, и возвращает вызываемый объект с другой сигнатурой типа. В этом случае [`ParamSpec`](https://python-all.ru/3.15/library/typing.html#typing.ParamSpec) указывает на то, что типы параметров возвращаемого вызываемого объекта зависят от типов параметров передаваемого вызываемого объекта:10161017```python1018from collections.abc import Callable1019from threading import Lock1020from typing import Concatenate10211022# Используйте эту блокировку, чтобы гарантировать, что только один поток выполняет функцию1023# в любой момент времени.1024my_lock = Lock()10251026def with_lock[**P, R](f: Callable[Concatenate[Lock, P], R]) -> Callable[P, R]:1027 '''Типобезопасный декоратор, предоставляющий блокировку.'''1028 def inner(*args: P.args, **kwargs: P.kwargs) -> R:1029 # Передайте блокировку в качестве первого аргумента.1030 return f(my_lock, *args, **kwargs)1031 return inner10321033@with_lock1034def sum_threadsafe(lock: Lock, numbers: list[float]) -> float:1035 '''Складывайте список чисел потокобезопасным способом.'''1036 with lock:1037 return sum(numbers)10381039# Нам не нужно передавать блокировку вручную благодаря декоратору.1040sum_threadsafe([1.1, 2.2, 3.3])1041```10421043Добавлено в версии 3.10.10441045> **См. также**1046>1047> - [**PEP 612**](https://python-all.ru/3.15/library/typing.html) – Переменные спецификации параметров (PEP, в котором были введены `ParamSpec` и `Concatenate`)1048> - [`ParamSpec`](https://python-all.ru/3.15/library/typing.html#typing.ParamSpec)1049> - [Аннотация вызываемых объектов](https://python-all.ru/3.15/library/typing.html#annotating-callables)10501051#### `typing.Literal`10521053Специальная форма типизации для определения «литеральных типов».10541055`Literal` можно использовать, чтобы указать проверяющим типа, что аннотированный объект имеет значение, эквивалентное одному из предоставленных литералов.10561057Например:10581059```python1060def validate_simple(data: Any) -> Literal[True]: # всегда возвращает True1061 ...10621063type Mode = Literal['r', 'rb', 'w', 'wb']1064def open_helper(file: str, mode: Mode) -> str:1065 ...10661067open_helper('/some/path', 'r') # Проходит проверку типов1068open_helper('/other/path', 'typo') # Ошибка в тайпчекере1069```10701071`Literal[...]` нельзя наследовать. Во время выполнения произвольное значение допускается в качестве аргумента типа для `Literal[...]`, но проверяющие типа могут накладывать ограничения. См. [**PEP 586**](https://python-all.ru/3.15/library/typing.html) для получения дополнительных сведений о литеральных типах.10721073Дополнительные сведения:10741075- Аргументы должны быть литеральными значениями, и их должно быть хотя бы одно.1076- Вложенные типы `Literal` уплощаются, например:10771078 ```python1079 assert Literal[Literal[1, 2], 3] == Literal[1, 2, 3]1080 ```10811082 Однако это не относится к типам `Literal`, на которые ссылаются через псевдоним типа, чтобы избежать принудительного вычисления базового [`TypeAliasType`](https://python-all.ru/3.15/library/typing.html#typing.TypeAliasType):10831084 ```python1085 type A = Literal[1, 2]1086 assert Literal[A, 3] != Literal[1, 2, 3]1087 ```1088- Повторяющиеся аргументы пропускаются, например:10891090 ```python1091 assert Literal[1, 2, 1] == Literal[1, 2]1092 ```1093- При сравнении литералов порядок аргументов игнорируется, например:10941095 ```python1096 assert Literal[1, 2] == Literal[2, 1]1097 ```1098- Нельзя наследовать или создавать экземпляр `Literal`.1099- Нельзя записать `Literal[X][Y]`.11001101Добавлено в версии 3.8.11021103Изменено в версии 3.9.1: `Literal` теперь дедуплицирует параметры. Сравнения на равенство объектов `Literal` больше не зависят от порядка. Объекты `Literal` теперь будут вызывать исключение [`TypeError`](https://python-all.ru/3.15/library/exceptions.html#TypeError) при сравнении на равенство, если один из их параметров не является [хешируемым](https://python-all.ru/3.15/glossary.html#term-hashable).11041105#### `typing.ClassVar`11061107Специальная конструкция типа для пометки переменных класса.11081109Как представлено в [**PEP 526**](https://python-all.ru/3.15/library/typing.html), аннотация переменной, обёрнутая в ClassVar, указывает, что данный атрибут предназначен для использования в качестве переменной класса и не должен устанавливаться на экземплярах этого класса. Использование:11101111```python1112class Starship:1113 stats: ClassVar[dict[str, int]] = {} # переменная класса1114 damage: int = 10 # переменная экземпляра1115```11161117`ClassVar` принимает только типы и не может быть дополнительно индексирован.11181119`ClassVar` не является классом и не может использоваться с [`isinstance()`](https://python-all.ru/3.15/library/functions.html#isinstance) или [`issubclass()`](https://python-all.ru/3.15/library/functions.html#issubclass). `ClassVar` не изменяет поведение Python во время выполнения, но может использоваться статическими проверяющими типов. Например, проверяющий тип может отметить следующий код как ошибочный:11201121```python1122enterprise_d = Starship(3000)1123enterprise_d.stats = {} # Ошибка: установка переменной класса на экземпляре1124Starship.stats = {} # Это корректно.1125```11261127Добавлено в версии 3.5.3.11281129Изменено в версии 3.13: `ClassVar` теперь можно вкладывать в [`Final`](https://python-all.ru/3.15/library/typing.html#typing.Final) и наоборот.11301131#### `typing.Final`11321133Специальная конструкция типизации для указания проверяющим типам, что имена являются финальными.11341135Финальные имена нельзя переназначать ни в какой области видимости. Финальные имена, объявленные в области класса, нельзя переопределять в подклассах.11361137Например:11381139```python1140MAX_SIZE: Final = 90001141MAX_SIZE += 1 # Ошибка, выдаваемая проверщиком типов11421143class Connection:1144 TIMEOUT: Final[int] = 1011451146class FastConnector(Connection):1147 TIMEOUT = 1 # Ошибка, выдаваемая проверщиком типов1148```11491150Проверка этих свойств во время выполнения не выполняется. Подробнее см. [**PEP 591**](https://python-all.ru/3.15/library/typing.html).11511152Добавлено в версии 3.8.11531154Изменено в версии 3.13: `Final` теперь можно вкладывать в [`ClassVar`](https://python-all.ru/3.15/library/typing.html#typing.ClassVar) и наоборот.11551156#### `typing.Required`11571158Специальная конструкция типизации для пометки ключа [`TypedDict`](https://python-all.ru/3.15/library/typing.html#typing.TypedDict) как обязательного.11591160В основном это полезно для `total=False` TypedDict. Подробнее см. [`TypedDict`](https://python-all.ru/3.15/library/typing.html#typing.TypedDict) и [**PEP 655**](https://python-all.ru/3.15/library/typing.html).11611162Добавлено в версии 3.12.11631164#### `typing.NotRequired`11651166Специальная конструкция типизации для пометки ключа [`TypedDict`](https://python-all.ru/3.15/library/typing.html#typing.TypedDict) как потенциально отсутствующего.11671168Подробнее см. [`TypedDict`](https://python-all.ru/3.15/library/typing.html#typing.TypedDict) и [**PEP 655**](https://python-all.ru/3.15/library/typing.html).11691170Добавлено в версии 3.12.11711172#### `typing.ReadOnly`11731174Специальная конструкция типизации для пометки элемента [`TypedDict`](https://python-all.ru/3.15/library/typing.html#typing.TypedDict) как доступного только для чтения.11751176Например:11771178```python1179class Movie(TypedDict):1180 title: ReadOnly[str]1181 year: int11821183def mutate_movie(m: Movie) -> None:1184 m["year"] = 1999 # разрешено1185 m["title"] = "The Matrix" # ошибка проверки типов1186```11871188Нет проверки этого свойства во время выполнения.11891190Подробнее см. [`TypedDict`](https://python-all.ru/3.15/library/typing.html#typing.TypedDict) и [**PEP 705**](https://python-all.ru/3.15/library/typing.html).11911192Добавлено в версии 3.13.11931194#### `typing.Annotated`11951196Специальная форма типизации для добавления контекстно-зависимых метаданных к аннотации.11971198Добавляет метаданные `x` к заданному типу `T` с помощью аннотации `Annotated[T, x]`. Метаданные, добавленные с помощью `Annotated`, могут использоваться инструментами статического анализа или во время выполнения. Во время выполнения метаданные хранятся в атрибуте `__metadata__`.11991200Если библиотека или инструмент встречает аннотацию `Annotated[T, x]` и не имеет специальной логики для метаданных, он должен игнорировать метаданные и просто рассматривать аннотацию как `T`. Таким образом, `Annotated` может быть полезна для кода, который хочет использовать аннотации для целей, выходящих за рамки системы статической типизации Python.12011202Использование `Annotated[T, x]` в качестве аннотации по-прежнему допускает статическую проверку типов для `T`, поскольку проверяющие типы просто игнорируют метаданные `x`. Таким образом, `Annotated` отличается от декоратора [`@no_type_check`](https://python-all.ru/3.15/library/typing.html#typing.no_type_check), который также можно использовать для добавления аннотаций за пределами системы типизации, но полностью отключает проверку типов для функции или класса.12031204Ответственность за интерпретацию метаданных лежит на инструменте или библиотеке, встречающей аннотацию `Annotated`. Инструмент или библиотека, встречающие тип `Annotated`, могут просмотреть элементы метаданных, чтобы определить, представляют ли они интерес (например, с помощью [`isinstance()`](https://python-all.ru/3.15/library/functions.html#isinstance)).12051206#### `Annotated[<type>, <metadata>]`12071208Вот пример того, как можно использовать `Annotated` для добавления метаданных к аннотациям типов при выполнении анализа диапазонов:12091210```python1211@dataclass1212class ValueRange:1213 lo: int1214 hi: int12151216T1 = Annotated[int, ValueRange(-10, 5)]1217T2 = Annotated[T1, ValueRange(-20, 3)]1218```12191220Первый аргумент `Annotated` должен быть допустимым типом. Можно указать несколько элементов метаданных, так как `Annotated` поддерживает вариативные аргументы. Порядок элементов метаданных сохраняется и важен для проверок на равенство:12211222```python1223@dataclass1224class ctype:1225 kind: str12261227a1 = Annotated[int, ValueRange(3, 10), ctype("char")]1228a2 = Annotated[int, ctype("char"), ValueRange(3, 10)]12291230assert a1 != a2 # Порядок важен1231```12321233Инструмент, потребляющий аннотации, сам решает, разрешено ли клиенту добавлять несколько элементов метаданных к одной аннотации и как объединять эти аннотации.12341235Вложенные типы `Annotated` уплощаются. Порядок элементов метаданных начинается с самой внутренней аннотации:12361237```python1238assert Annotated[Annotated[int, ValueRange(3, 10)], ctype("char")] == Annotated[1239 int, ValueRange(3, 10), ctype("char")1240]1241```12421243Однако это не относится к типам `Annotated`, на которые ссылаются через псевдоним типа, чтобы избежать принудительного вычисления базового [`TypeAliasType`](https://python-all.ru/3.15/library/typing.html#typing.TypeAliasType):12441245```python1246type From3To10[T] = Annotated[T, ValueRange(3, 10)]1247assert Annotated[From3To10[int], ctype("char")] != Annotated[1248 int, ValueRange(3, 10), ctype("char")1249]1250```12511252Дублирующиеся элементы метаданных не удаляются:12531254```python1255assert Annotated[int, ValueRange(3, 10)] != Annotated[1256 int, ValueRange(3, 10), ValueRange(3, 10)1257]1258```12591260`Annotated` можно использовать с вложенными и обобщёнными псевдонимами:12611262> ```python1263> @dataclass1264> class MaxLen:1265> value: int1266>1267> type Vec[T] = Annotated[list[tuple[T, T]], MaxLen(10)]1268>1269> # При использовании в аннотации типа тайпчекер будет обрабатывать "V" так же, как1270> # ``Annotated[list[tuple[int, int]], MaxLen(10)]``:1271> type V = Vec[int]1272> ```12731274`Annotated` нельзя использовать с распакованным [`TypeVarTuple`](https://python-all.ru/3.15/library/typing.html#typing.TypeVarTuple):12751276```python1277type Variadic[*Ts] = Annotated[*Ts, Ann1] = Annotated[T1, T2, T3, ..., Ann1] # НЕДОПУСТИМО1278```12791280где `T1`, `T2`, … – это [`TypeVars`](https://python-all.ru/3.15/library/typing.html#typing.TypeVar). Это недопустимо, поскольку в Annotated должен передаваться только один тип.12811282По умолчанию [`get_type_hints()`](https://python-all.ru/3.15/library/typing.html#typing.get_type_hints) удаляет метаданные из аннотаций. Передайте `include_extras=True`, чтобы сохранить метаданные:12831284> ```pycon1285> >>> from typing import Annotated, get_type_hints1286> >>> def func(x: Annotated[int, "metadata"]) -> None: pass1287> ...1288> >>> get_type_hints(func)1289> {'x': <class 'int'>, 'return': <class 'NoneType'>}1290> >>> get_type_hints(func, include_extras=True)1291> {'x': typing.Annotated[int, 'metadata'], 'return': <class 'NoneType'>}1292> ```12931294Во время выполнения метаданные, связанные с типом `Annotated`, можно получить через атрибут `__metadata__`:12951296> ```pycon1297> >>> from typing import Annotated1298> >>> X = Annotated[int, "very", "important", "metadata"]1299> >>> X1300> typing.Annotated[int, 'very', 'important', 'metadata']1301> >>> X.__metadata__1302> ('very', 'important', 'metadata')1303> ```13041305Чтобы получить исходный тип, обёрнутый `Annotated`, используйте атрибут `__origin__`:13061307> ```pycon1308> >>> from typing import Annotated, get_origin1309> >>> Password = Annotated[str, "secret"]1310> >>> Password.__origin__1311> <class 'str'>1312> ```13131314Обратите внимание, что использование [`get_origin()`](https://python-all.ru/3.15/library/typing.html#typing.get_origin) вернёт сам `Annotated`:13151316> ```pycon1317> >>> get_origin(Password)1318> typing.Annotated1319> ```13201321> **См. также**1322>1323> **[**PEP 593**](https://python-all.ru/3.15/library/typing.html) – Гибкие аннотации функций и переменных**1324>1325> PEP, вводящий `Annotated` в стандартную библиотеку.13261327Добавлено в версии 3.9.13281329#### `typing.TypeForm`13301331Специальная форма, представляющая значение, которое получается в результате вычисления выражения типа.13321333Это значение кодирует информацию, переданную в выражении типа, и представляет тип, описываемый этим выражением типа.13341335При использовании в выражении типа `TypeForm` описывает множество объектов формы типа. Он принимает единственный аргумент типа, который должен быть корректным выражением типа. `TypeForm[T]` описывает множество всех объектов формы типа, которые представляют тип `T` или типы, присваиваемые `T`.13361337`TypeForm(obj)` просто возвращает `obj` без изменений. Это полезно для явной пометки значения как формы типа для статических анализаторов типов.13381339Пример:13401341```python1342from typing import Any, TypeForm13431344def cast[T](typ: TypeForm[T], value: Any) -> T: ...13451346reveal_type(cast(int, "x")) # Обнаруженный тип – "int"1347```13481349Подробнее см. [**PEP 747**](https://python-all.ru/3.15/library/typing.html).13501351Добавлено в версии 3.15.13521353#### `typing.TypeIs`13541355Специальная конструкция typing для пометки пользовательских функций-предикатов типа.13561357`TypeIs` можно использовать для аннотации возвращаемого типа пользовательской функции-предиката типа. `TypeIs` принимает только один аргумент типа. Во время выполнения функции, помеченные таким образом, должны возвращать boolean и принимать как минимум один позиционный аргумент.13581359`TypeIs` направлен на улучшение *сужения типов* – техники, используемой статическими анализаторами типов для определения более точного типа выражения в потоке кода программы. Обычно сужение типов выполняется путём анализа условного потока кода и применения сужения к блоку кода. Условное выражение здесь иногда называют «предикатом типа»:13601361```python1362def is_str(val: str | float):1363 # Предикат типа "isinstance"1364 if isinstance(val, str):1365 # Тип ``val`` сужается до ``str``1366 ...1367 else:1368 # Иначе тип ``val`` сужается до ``float``.1369 ...1370```13711372Иногда удобно использовать пользовательскую булеву функцию в качестве предиката типа. Такая функция должна использовать `TypeIs[...]` или [`TypeGuard`](https://python-all.ru/3.15/library/typing.html#typing.TypeGuard) в качестве возвращаемого типа, чтобы уведомить статические анализаторы типов о намерении. `TypeIs` обычно ведёт себя более интуитивно, чем `TypeGuard`, но его нельзя использовать, когда входной и выходной типы несовместимы (например, `list[object]` в `list[int]`) или когда функция не возвращает `True` для всех экземпляров сужаемого типа.13731374Использование `-> TypeIs[NarrowedType]` сообщает статическому анализатору типов, что для данной функции:137513761. Возвращаемое значение – boolean.13772. Если возвращаемое значение – `True`, то тип аргумента является пересечением исходного типа аргумента и `NarrowedType`.13783. Если возвращаемое значение – `False`, то тип аргумента сужается до исключения `NarrowedType`.13791380Например:13811382```python1383from typing import assert_type, final, TypeIs13841385class Parent: pass1386class Child(Parent): pass1387@final1388class Unrelated: pass13891390def is_parent(val: object) -> TypeIs[Parent]:1391 return isinstance(val, Parent)13921393def run(arg: Child | Unrelated):1394 if is_parent(arg):1395 # Тип ``arg`` сужается до пересечения1396 # ``Parent`` и ``Child``, что эквивалентно1397 # ``Child``.1398 assert_type(arg, Child)1399 else:1400 # Тип ``arg`` сужается, исключая ``Parent``,1401 # так что остаётся только ``Unrelated``.1402 assert_type(arg, Unrelated)1403```14041405Тип внутри `TypeIs` должен быть совместим с типом аргумента функции; в противном случае статические анализаторы типов выдадут ошибку. Неправильно написанная функция `TypeIs` может привести к некорректному поведению в системе типов; ответственность за написание таких функций типобезопасным образом лежит на пользователе.14061407Если функция `TypeIs` является методом класса или экземпляра, то тип в `TypeIs` соответствует типу второго параметра (после `cls` или `self`).14081409Короче говоря, форма `def foo(arg: TypeA) -> TypeIs[TypeB]: ...` означает, что если `foo(arg)` возвращает `True`, то `arg` является экземпляром `TypeB`, а если возвращает `False`, то не является экземпляром `TypeB`.14101411`TypeIs` также работает с переменными типа. Дополнительную информацию см. в [**PEP 742**](https://python-all.ru/3.15/library/typing.html) (Сужение типов с помощью `TypeIs`).14121413Добавлено в версии 3.13.14141415#### `typing.TypeGuard`14161417Специальная конструкция typing для пометки пользовательских функций-предикатов типа.14181419Функции-предикаты типа – это пользовательские функции, которые возвращают, является ли их аргумент экземпляром определённого типа. `TypeGuard` работает аналогично [`TypeIs`](https://python-all.ru/3.15/library/typing.html#typing.TypeIs), но имеет тонкие различия в поведении при проверке типов (см. ниже).14201421Использование `-> TypeGuard` сообщает статическому анализатору типов, что для данной функции:142214231. Возвращаемое значение – boolean.14242. Если возвращаемое значение – `True`, то тип аргумента – это тип внутри `TypeGuard`.14251426`TypeGuard` также работает с переменными типа. См. [**PEP 647**](https://python-all.ru/3.15/library/typing.html) для подробностей.14271428Например:14291430```python1431def is_str_list(val: list[object]) -> TypeGuard[list[str]]:1432 '''Определяет, все ли объекты в списке являются строками'''1433 return all(isinstance(x, str) for x in val)14341435def func1(val: list[object]):1436 if is_str_list(val):1437 # Тип ``val`` сужается до ``list[str]``.1438 print(" ".join(val))1439 else:1440 # Тип ``val`` остаётся как ``list[object]``.1441 print("Not a list of strings!")1442```14431444`TypeIs` и `TypeGuard` различаются следующим образом:14451446- `TypeIs` требует, чтобы сужаемый тип был подтипом входного типа, тогда как `TypeGuard` – нет. Основная причина – допускать такие случаи, как сужение `list[object]` до `list[str]`, даже если последний не является подтипом первого, поскольку `list` инвариантен.1447- Когда функция `TypeGuard` возвращает `True`, анализаторы типов сужают тип переменной ровно до типа `TypeGuard`. Когда функция `TypeIs` возвращает `True`, анализаторы типов могут вывести более точный тип, объединяя ранее известный тип переменной с типом `TypeIs`. (Технически это называется пересечением типов.)1448- Когда функция `TypeGuard` возвращает `False`, анализаторы типов не могут сузить тип переменной вообще. Когда функция `TypeIs` возвращает `False`, анализаторы типов могут сузить тип переменной, исключив тип `TypeIs`.14491450Добавлено в версии 3.10.14511452#### `typing.Unpack`14531454Оператор typing для концептуальной пометки объекта как распакованного.14551456Например, использование оператора распаковки `*` для [кортежа переменных типа](https://python-all.ru/3.15/library/typing.html#typevartuple) эквивалентно использованию `Unpack`, чтобы пометить кортеж переменных типа как распакованный:14571458```python1459Ts = TypeVarTuple('Ts')1460tup: tuple[*Ts]1461# Фактически делает:1462tup: tuple[Unpack[Ts]]1463```14641465На самом деле, `Unpack` и `*` можно использовать взаимозаменяемо в контексте типов [`typing.TypeVarTuple`](https://python-all.ru/3.15/library/typing.html#typing.TypeVarTuple) и [`builtins.tuple`](https://python-all.ru/3.15/library/stdtypes.html#tuple). В старых версиях Python можно встретить явное использование `Unpack`, когда `*` нельзя было применять в определённых местах:14661467```python1468# В старых версиях Python TypeVarTuple и Unpack1469# находятся в пакете обратной совместимости `typing_extensions`.1470from typing_extensions import TypeVarTuple, Unpack14711472Ts = TypeVarTuple('Ts')1473tup: tuple[*Ts] # Синтаксическая ошибка на Python <= 3.10!1474tup: tuple[Unpack[Ts]] # Семантически эквивалентно и обратно совместимо1475```14761477`Unpack` также можно использовать вместе с [`typing.TypedDict`](https://python-all.ru/3.15/library/typing.html#typing.TypedDict) для типизации `**kwargs` в сигнатуре функции:14781479```python1480from typing import TypedDict, Unpack14811482class Movie(TypedDict):1483 name: str1484 year: int14851486# Эта функция ожидает два именованных аргумента: `name` типа `str`1487# и `year` типа `int`.1488def foo(**kwargs: Unpack[Movie]): ...1489```14901491Подробнее об использовании `Unpack` для типизации `**kwargs` см. в [**PEP 692**](https://python-all.ru/3.15/library/typing.html).14921493Добавлено в версии 3.12.14941495#### Построение обобщённых типов и псевдонимов типов14961497Следующие классы не следует использовать непосредственно в качестве аннотаций. Их предназначение – быть строительными блоками для создания обобщённых типов и псевдонимов типов.14981499Эти объекты можно создавать с помощью специального синтаксиса ([списки параметров типов](https://python-all.ru/3.15/reference/compound_stmts.html#type-params) и оператора [`type`](https://python-all.ru/3.15/reference/simple_stmts.html#type)). Для совместимости с Python 3.11 и более ранними версиями их также можно создавать без специального синтаксиса, как описано ниже.15001501#### `class typing.Generic`15021503Абстрактный базовый класс для обобщённых типов.15041505Обобщённый тип обычно объявляется добавлением списка параметров типа после имени класса:15061507```python1508class Mapping[KT, VT]:1509 def __getitem__(self, key: KT) -> VT:1510 ...1511 # И т.д.1512```15131514Такой класс неявно наследуется от `Generic`. Семантика этого синтаксиса во время выполнения обсуждается в [Справочнике по языку](https://python-all.ru/3.15/reference/compound_stmts.html#generic-classes).15151516Затем этот класс можно использовать следующим образом:15171518```python1519def lookup_name[X, Y](mapping: Mapping[X, Y], key: X, default: Y) -> Y:1520 try:1521 return mapping[key]1522 except KeyError:1523 return default1524```15251526Здесь квадратные скобки после имени функции указывают на [обобщённую функцию](https://python-all.ru/3.15/reference/compound_stmts.html#generic-functions).15271528Для обратной совместимости обобщённые классы также можно объявлять явным наследованием от `Generic`. В этом случае параметры типа должны быть объявлены отдельно:15291530```python1531KT = TypeVar('KT')1532VT = TypeVar('VT')15331534class Mapping(Generic[KT, VT]):1535 def __getitem__(self, key: KT) -> VT:1536 ...1537 # И т.д.1538```15391540#### `class typing.TypeVar(name, *constraints, bound=None, covariant=False, contravariant=False, infer_variance=False, default=typing.NoDefault)`15411542Переменная типа.15431544Предпочтительный способ создания переменной типа – специальный синтаксис для [обобщённых функций](https://python-all.ru/3.15/reference/compound_stmts.html#generic-functions), [обобщённых классов](https://python-all.ru/3.15/reference/compound_stmts.html#generic-classes) и [обобщённых псевдонимов типов](https://python-all.ru/3.15/reference/compound_stmts.html#generic-type-aliases):15451546```python1547class Sequence[T]: # T – это TypeVar1548 ...1549```15501551Этот синтаксис также можно использовать для создания переменных типа с границей и ограничениями:15521553```python1554class StrSequence[S: str]: # S – это TypeVar с верхней границей `str`;1555 ... # можно сказать, что S "ограничен `str`"15561557class StrOrBytesSequence[A: (str, bytes)]: # A – это TypeVar, ограниченный str или bytes1558 ...1559```15601561Однако при желании переиспользуемые переменные типа можно создавать и вручную, например так:15621563```python1564T = TypeVar('T') # Может быть чем угодно1565S = TypeVar('S', bound=str) # Может быть любым подтипом str1566A = TypeVar('A', str, bytes) # Должно быть ровно str или bytes1567```15681569Переменные типа существуют в первую очередь для статических проверок типов. Они служат параметрами для обобщённых типов, а также для определений обобщённых функций и псевдонимов типов. Дополнительную информацию об обобщённых типах см. в [`Generic`](https://python-all.ru/3.15/library/typing.html#typing.Generic). Обобщённые функции работают следующим образом:15701571```python1572def repeat[T](x: T, n: int) -> Sequence[T]:1573 """Возвращает список, содержащий n ссылок на x."""1574 return [x]*n15751576def print_capitalized[S: str](x: S) -> S:1577 """Печатает x с заглавной буквы и возвращает x."""1578 print(x.capitalize())1579 return x15801581def concatenate[A: (str, bytes)](x: A, y: A) -> A:1582 """Складывает две строки или два объекта bytes."""1583 return x + y1584```15851586Обратите внимание, что переменные типа могут быть с *границей*, с *ограничениями* или ни с тем, ни с другим, но не могут быть одновременно и с границей, *и* с ограничениями.15871588Вариантность переменных типа выводится проверщиками типов, когда они создаются через [синтаксис параметров типа](https://python-all.ru/3.15/reference/compound_stmts.html#type-params) или когда передаётся `infer_variance=True`. Вручную созданные переменные типа могут быть явно помечены как ковариантные или контравариантные передачей `covariant=True` или `contravariant=True`. По умолчанию вручную созданные переменные типа инвариантны. Подробнее см. в [**PEP 484**](https://python-all.ru/3.15/library/typing.html) и [**PEP 695**](https://python-all.ru/3.15/library/typing.html).15891590Переменные типа с границей и с ограничениями имеют разную семантику в нескольких важных аспектах. Использование переменной типа с *границей* означает, что `TypeVar` будет выведен как наиболее конкретный возможный тип:15911592```python1593x = print_capitalized('a string')1594reveal_type(x) # выявленный тип – str15951596class StringSubclass(str):1597 pass15981599y = print_capitalized(StringSubclass('another string'))1600reveal_type(y) # раскрытый тип – StringSubclass16011602z = print_capitalized(45) # ошибка: int не является подтипом str1603```16041605Верхней границей переменной типа может быть конкретный тип, абстрактный тип (ABC или протокол) или даже объединение типов:16061607```python1608# Может быть чем угодно с методом __abs__1609def print_abs[T: SupportsAbs](arg: T) -> None:1610 print("Absolute value:", abs(arg))16111612U = TypeVar('U', bound=str|bytes) # Может быть любым подтипом объединения str|bytes1613V = TypeVar('V', bound=SupportsAbs) # Может быть чем угодно с методом __abs__1614```16151616Однако использование переменной типа с *ограничениями* означает, что `TypeVar` может быть выведен только как один из заданных ограничений:16171618```python1619a = concatenate('one', 'two')1620reveal_type(a) # выявленный тип – str16211622b = concatenate(StringSubclass('one'), StringSubclass('two'))1623reveal_type(b) # выявленный тип – str, несмотря на то что передан StringSubclass16241625c = concatenate('one', b'two') # ошибка: типовая переменная 'A' может быть либо str, либо bytes в вызове функции, но не обоими одновременно1626```16271628Во время выполнения `isinstance(x, T)` вызовет [`TypeError`](https://python-all.ru/3.15/library/exceptions.html#TypeError).16291630#### `__name__`16311632Имя переменной типа.16331634#### `__covariant__`16351636Является ли переменная типа явно помеченной как ковариантная.16371638#### `__contravariant__`16391640Является ли переменная типа явно помеченной как контравариантная.16411642#### `__infer_variance__`16431644Должна ли вариативность переменной типа выводиться средствами проверки типов.16451646Добавлено в версии 3.12.16471648#### `__bound__`16491650Верхняя граница переменной типа, если она задана.16511652Изменено в версии 3.12: Для переменных типа, созданных с помощью [синтаксиса параметров типа](https://python-all.ru/3.15/reference/compound_stmts.html#type-params), граница вычисляется только при обращении к атрибуту, а не при создании переменной типа (см. [Ленивое вычисление](https://python-all.ru/3.15/reference/executionmodel.html#lazy-evaluation)).16531654#### `evaluate_bound()`16551656[Функция evaluate](https://python-all.ru/3.15/glossary.html#term-evaluate-function), соответствующая атрибуту [`__bound__`](https://python-all.ru/3.15/library/typing.html#typing.TypeVar.__bound__). При прямом вызове этот метод поддерживает только формат [`VALUE`](https://python-all.ru/3.15/library/annotationlib.html#annotationlib.Format.VALUE), что эквивалентно прямому обращению к атрибуту `__bound__`, но объект метода можно передать в [`annotationlib.call_evaluate_function()`](https://python-all.ru/3.15/library/annotationlib.html#annotationlib.call_evaluate_function) для вычисления значения в другом формате.16571658Добавлено в версии 3.14.16591660#### `__constraints__`16611662Кортеж, содержащий ограничения переменной типа, если они есть.16631664Изменено в версии 3.12: Для переменных типа, созданных с помощью [синтаксиса параметров типа](https://python-all.ru/3.15/reference/compound_stmts.html#type-params), ограничения вычисляются только при обращении к атрибуту, а не при создании переменной типа (см. [Ленивое вычисление](https://python-all.ru/3.15/reference/executionmodel.html#lazy-evaluation)).16651666#### `evaluate_constraints()`16671668[Функция evaluate](https://python-all.ru/3.15/glossary.html#term-evaluate-function), соответствующая атрибуту [`__constraints__`](https://python-all.ru/3.15/library/typing.html#typing.TypeVar.__constraints__). При прямом вызове этот метод поддерживает только формат [`VALUE`](https://python-all.ru/3.15/library/annotationlib.html#annotationlib.Format.VALUE), что эквивалентно прямому обращению к атрибуту `__constraints__`, но объект метода можно передать в [`annotationlib.call_evaluate_function()`](https://python-all.ru/3.15/library/annotationlib.html#annotationlib.call_evaluate_function) для вычисления значения в другом формате.16691670Добавлено в версии 3.14.16711672#### `__default__`16731674Значение по умолчанию переменной типа или [`typing.NoDefault`](https://python-all.ru/3.15/library/typing.html#typing.NoDefault), если оно не задано.16751676Добавлено в версии 3.13.16771678#### `evaluate_default()`16791680[Функция evaluate](https://python-all.ru/3.15/glossary.html#term-evaluate-function), соответствующая атрибуту [`__default__`](https://python-all.ru/3.15/library/typing.html#typing.TypeVar.__default__). При прямом вызове этот метод поддерживает только формат [`VALUE`](https://python-all.ru/3.15/library/annotationlib.html#annotationlib.Format.VALUE), что эквивалентно прямому обращению к атрибуту `__default__`, но объект метода можно передать в [`annotationlib.call_evaluate_function()`](https://python-all.ru/3.15/library/annotationlib.html#annotationlib.call_evaluate_function) для вычисления значения в другом формате.16811682Добавлено в версии 3.14.16831684#### `has_default()`16851686Возвращает, есть ли у переменной типа значение по умолчанию. Это равносильно проверке, что [`__default__`](https://python-all.ru/3.15/library/typing.html#typing.TypeVar.__default__) не является синглтоном [`typing.NoDefault`](https://python-all.ru/3.15/library/typing.html#typing.NoDefault), но без принудительного вычисления [лениво вычисляемого](https://python-all.ru/3.15/reference/executionmodel.html#lazy-evaluation) значения по умолчанию.16871688Добавлено в версии 3.13.16891690Изменено в версии 3.12: Переменные типа теперь можно объявлять с помощью синтаксиса [параметров типа](https://python-all.ru/3.15/reference/compound_stmts.html#type-params), введённого в [**PEP 695**](https://python-all.ru/3.15/library/typing.html). Был добавлен параметр `infer_variance`.16911692Изменено в версии 3.13: Добавлена поддержка значений по умолчанию.16931694#### `class typing.TypeVarTuple(name, *, bound=None, covariant=False, contravariant=False, infer_variance=False, default=typing.NoDefault)`16951696Кортежная переменная типа. Специализированная форма [переменной типа](https://python-all.ru/3.15/library/typing.html#typevar), которая позволяет использовать *вариативные* обобщения.16971698Кортежные переменные типа можно объявлять в [списках параметров типа](https://python-all.ru/3.15/reference/compound_stmts.html#type-params) с помощью одной звёздочки (`*`) перед именем:16991700```python1701def move_first_element_to_last[T, *Ts](tup: tuple[T, *Ts]) -> tuple[*Ts, T]:1702 return (*tup[1:], tup[0])1703```17041705Или явным вызовом конструктора `TypeVarTuple`:17061707```python1708T = TypeVar("T")1709Ts = TypeVarTuple("Ts")17101711def move_first_element_to_last(tup: tuple[T, *Ts]) -> tuple[*Ts, T]:1712 return (*tup[1:], tup[0])1713```17141715Обычная переменная типа позволяет параметризацию одним типом. Кортежная переменная типа, напротив, позволяет параметризацию *произвольным* количеством типов, действуя как *произвольное* количество переменных типа, упакованных в кортеж. Например:17161717```python1718# T привязан к int, Ts привязан к ()1719# Возвращаемое значение – (1,), тип которого tuple[int]1720move_first_element_to_last(tup=(1,))17211722# T привязан к int, Ts привязан к (str,)1723# Возвращаемое значение – ('spam', 1), тип которого tuple[str, int]1724move_first_element_to_last(tup=(1, 'spam'))17251726# T привязан к int, Ts привязан к (str, float)1727# Возвращаемое значение – ('spam', 3.0, 1), тип которого tuple[str, float, int]1728move_first_element_to_last(tup=(1, 'spam', 3.0))17291730# Это не проходит проверку типов (и завершается ошибкой во время выполнения)1731# потому что tuple[()] несовместим с tuple[T, *Ts]1732# (требуется хотя бы один элемент)1733move_first_element_to_last(tup=())1734```17351736Обратите внимание на использование оператора распаковки `*` в `tuple[T, *Ts]`. Концептуально можно представить `Ts` как кортеж переменных типа `(T1, T2, ...)`. Тогда `tuple[T, *Ts]` станет `tuple[T, *(T1, T2, ...)]`, что эквивалентно `tuple[T, T1, T2, ...]`. (Обратите внимание, что в более старых версиях Python это могло быть записано с использованием [`Unpack`](https://python-all.ru/3.15/library/typing.html#typing.Unpack), например, `Unpack[Ts]`.)17371738Кортежные переменные типа *всегда* должны быть распакованы. Это помогает отличать кортежные переменные типа от обычных:17391740```python1741x: Ts # Недействительно1742x: tuple[Ts] # Недействительно1743x: tuple[*Ts] # Правильный способ сделать это1744```17451746Кортежные переменные типа можно использовать в тех же контекстах, что и обычные переменные типа. Например, в определениях классов, аргументах и возвращаемых типах:17471748```python1749class Array[*Shape]:1750 def __getitem__(self, key: tuple[*Shape]) -> float: ...1751 def __abs__(self) -> "Array[*Shape]": ...1752 def get_shape(self) -> tuple[*Shape]: ...1753```17541755Кортежные переменные типа можно без проблем комбинировать с обычными переменными типа:17561757```python1758class Array[DType, *Shape]: # Это нормально1759 pass17601761class Array2[*Shape, DType]: # Это тоже нормально1762 pass17631764class Height: ...1765class Width: ...17661767float_array_1d: Array[float, Height] = Array() # Совершенно нормально1768int_array_2d: Array[int, Height, Width] = Array() # Да, тоже нормально1769```17701771Однако обратите внимание, что в одном списке аргументов типа или параметров типа может присутствовать не более одной кортежной переменной типа:17721773```python1774x: tuple[*Ts, *Ts] # Недействительно1775class Array[*Shape, *Shape]: # Недействительно1776 pass1777```17781779Наконец, распакованная кортежная переменная типа может использоваться в качестве аннотации типа для `*args`:17801781```python1782def call_soon[*Ts](1783 callback: Callable[[*Ts], None],1784 *args: *Ts1785) -> None:1786 ...1787 callback(*args)1788```17891790В отличие от нераспакованных аннотаций `*args`, например `*args: int`, которые указывают, что *все* аргументы имеют тип `int`, `*args: *Ts` позволяет ссылаться на типы *отдельных* аргументов в `*args`. Здесь это позволяет нам убедиться, что типы `*args`, передаваемых в `call_soon`, соответствуют типам (позиционных) аргументов `callback`.17911792Подробнее о кортежах переменных типа см. в [**PEP 646**](https://python-all.ru/3.15/library/typing.html).17931794#### `__name__`17951796Имя кортежа переменных типа.17971798#### `__covariant__`17991800Указывает, помечена ли кортежная переменная типа как ковариантная.18011802Добавлено в версии 3.15.18031804#### `__contravariant__`18051806Указывает, помечена ли кортежная переменная типа как контравариантная.18071808Добавлено в версии 3.15.18091810#### `__infer_variance__`18111812Указывает, должна ли вариантность кортежной переменной типа выводиться инструментами проверки типов.18131814Добавлено в версии 3.15.18151816#### `__default__`18171818Значение по умолчанию кортежа переменных типа или [`typing.NoDefault`](https://python-all.ru/3.15/library/typing.html#typing.NoDefault), если значение по умолчанию отсутствует.18191820Добавлено в версии 3.13.18211822#### `evaluate_default()`18231824[Функция evaluate](https://python-all.ru/3.15/glossary.html#term-evaluate-function), соответствующая атрибуту [`__default__`](https://python-all.ru/3.15/library/typing.html#typing.TypeVarTuple.__default__). При прямом вызове этот метод поддерживает только формат [`VALUE`](https://python-all.ru/3.15/library/annotationlib.html#annotationlib.Format.VALUE), что эквивалентно прямому обращению к атрибуту `__default__`, но объект метода можно передать в [`annotationlib.call_evaluate_function()`](https://python-all.ru/3.15/library/annotationlib.html#annotationlib.call_evaluate_function) для вычисления значения в другом формате.18251826Добавлено в версии 3.14.18271828#### `has_default()`18291830Возвращает, имеет ли кортеж переменных типа значение по умолчанию. Это эквивалентно проверке того, что [`__default__`](https://python-all.ru/3.15/library/typing.html#typing.TypeVarTuple.__default__) не является синглтоном [`typing.NoDefault`](https://python-all.ru/3.15/library/typing.html#typing.NoDefault), за исключением того, что не вызывает вычисление [лениво вычисляемого](https://python-all.ru/3.15/reference/executionmodel.html#lazy-evaluation) значения по умолчанию.18311832Добавлено в версии 3.13.18331834Кортежи переменных типа, созданные с помощью `covariant=True` или `contravariant=True`, можно использовать для объявления ковариантных или контравариантных обобщённых типов. Параметр `bound` также принимается, аналогично [`TypeVar`](https://python-all.ru/3.15/library/typing.html#typing.TypeVar), но его фактическая семантика ещё не определена.18351836Добавлено в версии 3.12.18371838Changed in version 3.12: Type variable tuples can now be declared using the [type parameter](https://python-all.ru/3.15/reference/compound_stmts.html#type-params) syntax introduced by [**PEP 695**](https://python-all.ru/3.15/library/typing.html).18391840Изменено в версии 3.13: Добавлена поддержка значений по умолчанию.18411842Изменено в версии 3.15: Добавлена поддержка параметров `bound`, `covariant`, `contravariant` и `infer_variance`.18431844#### `class typing.ParamSpec(name, *, bound=None, covariant=False, contravariant=False, infer_variance=False, default=typing.NoDefault)`18451846Переменная спецификации параметров. Специализированная версия [переменных типа](https://python-all.ru/3.15/library/typing.html#typevar).18471848В [списках параметров типа](https://python-all.ru/3.15/reference/compound_stmts.html#type-params) спецификации параметров можно объявлять с двумя звёздочками (`**`):18491850```python1851type IntFunc[**P] = Callable[P, int]1852```18531854Для совместимости с Python 3.11 и более ранними версиями объекты `ParamSpec` можно также создавать следующим образом:18551856```python1857P = ParamSpec('P')1858```18591860Переменные спецификации параметров существуют в первую очередь для статических проверок типов. Они используются для передачи типов параметров одного вызываемого объекта другому вызываемому объекту – шаблон, часто встречающийся в функциях высшего порядка и декораторах. Они допустимы только при использовании в `Concatenate`, или как первый аргумент `Callable`, или как параметры пользовательских обобщённых типов (Generics). См. [`Generic`](https://python-all.ru/3.15/library/typing.html#typing.Generic) для получения дополнительной информации об обобщённых типах.18611862Например, чтобы добавить базовое логирование в функцию, можно создать декоратор `add_logging` для логирования вызовов функций. Переменная спецификации параметров сообщает проверяющему типы, что вызываемый объект, переданный в декоратор, и новый вызываемый объект, возвращаемый им, имеют взаимозависимые параметры типа:18631864```python1865from collections.abc import Callable1866import logging18671868def add_logging[T, **P](f: Callable[P, T]) -> Callable[P, T]:1869 '''Типобезопасный декоратор для добавления логирования в функцию.'''1870 def inner(*args: P.args, **kwargs: P.kwargs) -> T:1871 logging.info(f'{f.__name__} was called')1872 return f(*args, **kwargs)1873 return inner18741875@add_logging1876def add_two(x: float, y: float) -> float:1877 '''Складывает два числа.'''1878 return x + y1879```18801881Без `ParamSpec` ранее самый простой способ аннотировать это заключался в использовании [`TypeVar`](https://python-all.ru/3.15/library/typing.html#typing.TypeVar) с верхней границей `Callable[..., Any]`. Однако это вызывает две проблемы:188218831. Проверяющий типы не может проверить типы функции `inner`, потому что `*args` и `**kwargs` должны быть типизированы как [`Any`](https://python-all.ru/3.15/library/typing.html#typing.Any).18842. [`cast()`](https://python-all.ru/3.15/library/typing.html#typing.cast) может потребоваться в теле декоратора `add_logging` при возврате функции `inner`, или статической проверке типов нужно указать игнорировать `return inner`.18851886#### `args`18871888#### `kwargs`18891890Поскольку `ParamSpec` захватывает как позиционные, так и ключевые параметры, `P.args` и `P.kwargs` можно использовать для разделения `ParamSpec` на составляющие. `P.args` представляет кортеж позиционных параметров в заданном вызове и должен использоваться только для аннотации `*args`. `P.kwargs` представляет отображение ключевых параметров на их значения в заданном вызове и должен использоваться только для аннотации `**kwargs`. Оба атрибута требуют, чтобы аннотируемый параметр находился в области видимости. Во время выполнения `P.args` и `P.kwargs` являются экземплярами соответственно [`ParamSpecArgs`](https://python-all.ru/3.15/library/typing.html#typing.ParamSpecArgs) и [`ParamSpecKwargs`](https://python-all.ru/3.15/library/typing.html#typing.ParamSpecKwargs).18911892#### `__name__`18931894Имя спецификации параметров.18951896#### `__covariant__`18971898Указывает, помечена ли спецификация параметра как ковариантная.18991900#### `__contravariant__`19011902Указывает, помечена ли спецификация параметра как контравариантная.19031904#### `__infer_variance__`19051906Должна ли вариативность спецификации параметров выводиться проверяющими типы.19071908Добавлено в версии 3.12.19091910#### `__default__`19111912Значение по умолчанию спецификации параметров или [`typing.NoDefault`](https://python-all.ru/3.15/library/typing.html#typing.NoDefault), если у неё нет значения по умолчанию.19131914Добавлено в версии 3.13.19151916#### `evaluate_default()`19171918[Функция evaluate](https://python-all.ru/3.15/glossary.html#term-evaluate-function), соответствующая атрибуту [`__default__`](https://python-all.ru/3.15/library/typing.html#typing.ParamSpec.__default__). При прямом вызове этот метод поддерживает только формат [`VALUE`](https://python-all.ru/3.15/library/annotationlib.html#annotationlib.Format.VALUE), что эквивалентно прямому обращению к атрибуту `__default__`, но объект метода можно передать в [`annotationlib.call_evaluate_function()`](https://python-all.ru/3.15/library/annotationlib.html#annotationlib.call_evaluate_function) для вычисления значения в другом формате.19191920Добавлено в версии 3.14.19211922#### `has_default()`19231924Возвращает, имеет ли спецификация параметров значение по умолчанию. Это эквивалентно проверке того, что [`__default__`](https://python-all.ru/3.15/library/typing.html#typing.ParamSpec.__default__) не является синглтоном [`typing.NoDefault`](https://python-all.ru/3.15/library/typing.html#typing.NoDefault), за исключением того, что не вызывает вычисление [лениво вычисляемого](https://python-all.ru/3.15/reference/executionmodel.html#lazy-evaluation) значения по умолчанию.19251926Добавлено в версии 3.13.19271928Переменные спецификации параметров, созданные с помощью `covariant=True` или `contravariant=True`, можно использовать для объявления ковариантных или контравариантных обобщённых типов. Аргумент `bound` также принимается, как и в [`TypeVar`](https://python-all.ru/3.15/library/typing.html#typing.TypeVar). Однако фактическая семантика этих ключевых слов ещё не определена.19291930Добавлено в версии 3.10.19311932Изменено в версии 3.12: Спецификации параметров теперь можно объявлять с помощью синтаксиса [type parameter](https://python-all.ru/3.15/reference/compound_stmts.html#type-params), введённого в [**PEP 695**](https://python-all.ru/3.15/library/typing.html).19331934Изменено в версии 3.13: Добавлена поддержка значений по умолчанию.19351936> **Примечание**1937>1938> Только переменные спецификации параметров, определённые в глобальной области видимости, могут быть pickled.19391940> **См. также**1941>1942> - [**PEP 612**](https://python-all.ru/3.15/library/typing.html) – Переменные спецификации параметров (PEP, в котором были введены `ParamSpec` и `Concatenate`)1943> - [`Concatenate`](https://python-all.ru/3.15/library/typing.html#typing.Concatenate)1944> - [Аннотация вызываемых объектов](https://python-all.ru/3.15/library/typing.html#annotating-callables)19451946#### `class typing.ParamSpecArgs`19471948#### `class typing.ParamSpecKwargs`19491950Атрибуты аргументов и именованных аргументов (keyword arguments) объекта [`ParamSpec`](https://python-all.ru/3.15/library/typing.html#typing.ParamSpec). Атрибут `P.args` объекта `ParamSpec` является экземпляром `ParamSpecArgs`, а `P.kwargs` – экземпляром `ParamSpecKwargs`. Они предназначены для интроспекции во время выполнения и не имеют особого значения для статических проверяющих типы.19511952Вызов [`get_origin()`](https://python-all.ru/3.15/library/typing.html#typing.get_origin) для любого из этих объектов вернёт исходный `ParamSpec`:19531954```pycon1955>>> from typing import ParamSpec, get_origin1956>>> P = ParamSpec("P")1957>>> get_origin(P.args) is P1958True1959>>> get_origin(P.kwargs) is P1960True1961```19621963Добавлено в версии 3.10.19641965#### `class typing.TypeAliasType(name, value, *, type_params=(), qualname=None)`19661967Тип псевдонимов типов, созданных с помощью оператора [`type`](https://python-all.ru/3.15/reference/simple_stmts.html#type).19681969Пример:19701971```pycon1972>>> type Alias = int1973>>> type(Alias)1974<class 'typing.TypeAliasType'>1975```19761977Добавлено в версии 3.12.19781979#### `__name__`19801981Имя псевдонима типа:19821983```pycon1984>>> type Alias = int1985>>> Alias.__name__1986'Alias'1987```19881989#### `__qualname__`19901991[Квалифицированное имя](https://python-all.ru/3.15/glossary.html#term-qualified-name) псевдонима типа:19921993```pycon1994>>> class Class:1995... type Alias = int1996...1997>>> Class.Alias.__qualname__1998'Class.Alias'1999```20002001Добавлено в версии 3.15.20022003#### `__module__`20042005Имя модуля, в котором был определён псевдоним типа:20062007```python2008>>> type Alias = int2009>>> Alias.__module__2010'__main__'2011```20122013Этот атрибут доступен для записи.20142015Изменено в версии 3.15: Теперь этот атрибут доступен для записи.20162017#### `__type_params__`20182019Параметры типа псевдонима типа или пустой кортеж, если псевдоним не является обобщённым (generic):20202021```pycon2022>>> type ListOrSet[T] = list[T] | set[T]2023>>> ListOrSet.__type_params__2024(T,)2025>>> type NotGeneric = int2026>>> NotGeneric.__type_params__2027()2028```20292030#### `__value__`20312032Значение псевдонима типа. Оно [вычисляется лениво](https://python-all.ru/3.15/reference/executionmodel.html#lazy-evaluation), поэтому имена, используемые в определении псевдонима, не разрешаются до тех пор, пока не будет получен доступ к атрибуту `__value__`:20332034```pycon2035>>> type Mutually = Recursive2036>>> type Recursive = Mutually2037>>> Mutually2038Mutually2039>>> Recursive2040Recursive2041>>> Mutually.__value__2042Recursive2043>>> Recursive.__value__2044Mutually2045```20462047#### `evaluate_value()`20482049Функция [evaluate](https://python-all.ru/3.15/glossary.html#term-evaluate-function), соответствующая атрибуту [`__value__`](https://python-all.ru/3.15/library/typing.html#typing.TypeAliasType.__value__). При прямом вызове этот метод поддерживает только формат [`VALUE`](https://python-all.ru/3.15/library/annotationlib.html#annotationlib.Format.VALUE), что эквивалентно прямому доступу к атрибуту `__value__`, но объект метода можно передать в [`annotationlib.call_evaluate_function()`](https://python-all.ru/3.15/library/annotationlib.html#annotationlib.call_evaluate_function) для вычисления значения в другом формате:20502051```pycon2052>>> type Alias = undefined2053>>> Alias.__value__2054Traceback (most recent call last):2055...2056NameError: name 'undefined' is not defined2057>>> from annotationlib import Format, call_evaluate_function2058>>> Alias.evaluate_value(Format.VALUE)2059Traceback (most recent call last):2060...2061NameError: name 'undefined' is not defined2062>>> call_evaluate_function(Alias.evaluate_value, Format.FORWARDREF)2063ForwardRef('undefined')2064```20652066Добавлено в версии 3.14.20672068распаковка20692070Псевдонимы типов поддерживают распаковку со звёздочкой (star unpacking) с помощью синтаксиса `*Alias`. Это эквивалентно прямому использованию `Unpack[Alias]`:20712072```pycon2073>>> type Alias = tuple[int, str]2074>>> type Unpacked = tuple[bool, *Alias]2075>>> Unpacked.__value__2076tuple[bool, typing.Unpack[Alias]]2077```20782079Добавлено в версии 3.14.20802081#### Другие специальные директивы20822083Эти функции и классы не следует использовать напрямую в качестве аннотаций. Их предназначение – быть строительными блоками для создания и объявления типов.20842085#### `class typing.NamedTuple`20862087Типизированная версия [`collections.namedtuple()`](https://python-all.ru/3.15/library/collections.html#collections.namedtuple).20882089Использование:20902091```python2092class Employee(NamedTuple):2093 name: str2094 id: int2095```20962097Это эквивалентно:20982099```python2100Employee = collections.namedtuple('Employee', ['name', 'id'])2101```21022103Чтобы задать полю значение по умолчанию, можно присвоить его в теле класса:21042105```python2106class Employee(NamedTuple):2107 name: str2108 id: int = 321092110employee = Employee('Guido')2111assert employee.id == 32112```21132114Поля со значением по умолчанию должны следовать после полей без значения по умолчанию.21152116Типы для каждого имени поля можно получить, вызвав [`annotationlib.get_annotations()`](https://python-all.ru/3.15/library/annotationlib.html#annotationlib.get_annotations) для результирующего класса. (Имена полей находятся в атрибуте `_fields`, а значения по умолчанию – в атрибуте `_field_defaults`; оба атрибута являются частью API [`namedtuple()`](https://python-all.ru/3.15/library/collections.html#collections.namedtuple).)21172118Подклассы `NamedTuple` также могут иметь докстринги и методы:21192120```python2121class Employee(NamedTuple):2122 """Представляет сотрудника."""2123 name: str2124 id: int = 321252126 def __repr__(self) -> str:2127 return f'<Employee {self.name}, id={self.id}>'2128```21292130Подклассы `NamedTuple` могут быть обобщёнными (generic):21312132```python2133class Group[T](NamedTuple):2134 key: T2135 group: list[T]2136```21372138Обратно совместимое использование:21392140```python2141# Для создания обобщённого NamedTuple в Python 3.112142T = TypeVar("T")21432144class Group(NamedTuple, Generic[T]):2145 key: T2146 group: list[T]21472148# Также поддерживается функциональный синтаксис2149Employee = NamedTuple('Employee', [('name', str), ('id', int)])2150```21512152Изменено в версии 3.6: Добавлена поддержка синтаксиса аннотации переменных [**PEP 526**](https://python-all.ru/3.15/library/typing.html).21532154Изменено в версии 3.6.1: Добавлена поддержка значений по умолчанию, методов и строк документации.21552156Изменено в версии 3.8: Атрибуты `_field_types` и `__annotations__` теперь являются обычными словарями, а не экземплярами `OrderedDict`.21572158Изменено в версии 3.9: Атрибут `_field_types` удалён в пользу более стандартного атрибута `__annotations__`, который содержит ту же информацию.21592160Изменено в версии 3.9: `NamedTuple` теперь функция, а не класс. По-прежнему может использоваться как базовый класс, как описано выше.21612162Изменено в версии 3.11: Добавлена поддержка обобщённых именованных кортежей (generic namedtuples).21632164Изменено в версии 3.14: Использование [`super()`](https://python-all.ru/3.15/library/functions.html#super) (и `__class__` [замыкающей переменной](https://python-all.ru/3.15/glossary.html#term-closure-variable)) в методах подклассов `NamedTuple` не поддерживается и вызывает [`TypeError`](https://python-all.ru/3.15/library/exceptions.html#TypeError).21652166#### `class typing.NewType(name, tp)`21672168Вспомогательный класс для создания [отдельных типов с низкими накладными расходами](https://python-all.ru/3.15/library/typing.html#distinct).21692170`NewType` считается отдельным типом для проверяющего типа. Однако во время выполнения вызов `NewType` возвращает свой аргумент без изменений.21712172Использование:21732174```python2175UserId = NewType('UserId', int) # Объявить NewType "UserId"2176first_user = UserId(1) # "UserId" возвращает аргумент без изменений во время выполнения2177```21782179#### `__module__`21802181Имя модуля, в котором определён новый тип.21822183#### `__name__`21842185Имя нового типа.21862187#### `__supertype__`21882189Тип, на котором основан новый тип.21902191Добавлено в версии 3.5.2.21922193Изменено в версии 3.10: `NewType` теперь является классом, а не функцией.21942195#### `class typing.Protocol(Generic)`21962197Базовый класс для протокольных классов.21982199Протокольные классы определяются следующим образом:22002201```python2202class Proto(Protocol):2203 def meth(self) -> int:2204 ...2205```22062207Такие классы в основном используются со статическими проверяющими типов, которые распознают структурную подтипизацию (статическую утиную типизацию), например:22082209```python2210class C:2211 def meth(self) -> int:2212 return 022132214def func(x: Proto) -> int:2215 return x.meth()22162217func(C()) # Проходит статическую проверку типов2218```22192220См. [**PEP 544**](https://python-all.ru/3.15/library/typing.html) для более подробной информации. Протокольные классы, декорированные [`runtime_checkable()`](https://python-all.ru/3.15/library/typing.html#typing.runtime_checkable) (описано далее), действуют как простые протоколы времени выполнения, которые проверяют только наличие заданных атрибутов, игнорируя их сигнатуры типов. Протокольные классы без этого декоратора не могут использоваться в качестве второго аргумента [`isinstance()`](https://python-all.ru/3.15/library/functions.html#isinstance) или [`issubclass()`](https://python-all.ru/3.15/library/functions.html#issubclass).22212222Протокольные классы могут быть обобщёнными, например:22232224```python2225class GenProto[T](Protocol):2226 def meth(self) -> T:2227 ...2228```22292230В коде, который должен быть совместим с Python 3.11 или более старыми версиями, обобщённые протоколы можно записать следующим образом:22312232```python2233T = TypeVar("T")22342235class GenProto(Protocol[T]):2236 def meth(self) -> T:2237 ...2238```22392240Добавлено в версии 3.8.22412242Устарело с версии 3.15, будет удалено в версии 3.20: Вызов проверок [`isinstance()`](https://python-all.ru/3.15/library/functions.html#isinstance) и [`issubclass()`](https://python-all.ru/3.15/library/functions.html#issubclass) для классов протоколов, которые не были явно декорированы с помощью `runtime_checkable()`, но наследуют от класса протокола с проверкой во время выполнения, является устаревшим. Это приведет к выбрасыванию [`TypeError`](https://python-all.ru/3.15/library/exceptions.html#TypeError) в Python 3.20.22432244#### `@typing.runtime_checkable`22452246Помечает протокольный класс как протокол времени выполнения.22472248Такой протокол можно использовать с [`isinstance()`](https://python-all.ru/3.15/library/functions.html#isinstance) и [`issubclass()`](https://python-all.ru/3.15/library/functions.html#issubclass). Это позволяет выполнять простую структурную проверку, очень похожую на «однофокусные» (one-trick ponies) в [`collections.abc`](https://python-all.ru/3.15/library/collections.abc.html#module-collections.abc), такие как [`Iterable`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Iterable). Например:22492250```python2251@runtime_checkable2252class Closable(Protocol):2253 def close(self): ...22542255assert isinstance(open('/some/file'), Closable)22562257@runtime_checkable2258class Named(Protocol):2259 name: str22602261import threading2262assert isinstance(threading.Thread(name='Bob'), Named)2263```22642265Возможность проверки во время выполнения для протоколов не наследуется. Подкласс протокола с проверкой во время выполнения является проверяемым во время выполнения, только если он явно помечен как таковой, независимо от иерархии классов:22662267```python2268@runtime_checkable2269class Iterable(Protocol):2270 def __iter__(self): ...22712272# Без @runtime_checkable класс Reversible больше не будет проверяемым во время выполнения.2273@runtime_checkable2274class Reversible(Iterable, Protocol):2275 def __reversed__(self): ...2276```22772278Этот декоратор вызывает исключение [`TypeError`](https://python-all.ru/3.15/library/exceptions.html#TypeError) при применении к классу, не являющемуся протоколом.22792280> **Примечание**2281>2282> `runtime_checkable()` будет проверять только наличие требуемых методов или атрибутов, но не их сигнатуры типов или сами типы. Например, [`ssl.SSLObject`](https://python-all.ru/3.15/library/ssl.html#ssl.SSLObject) является классом, поэтому он проходит проверку [`issubclass()`](https://python-all.ru/3.15/library/functions.html#issubclass) на соответствие [Callable](https://python-all.ru/3.15/library/typing.html#annotating-callables). Однако метод `ssl.SSLObject.__init__` существует только для того, чтобы вызвать [`TypeError`](https://python-all.ru/3.15/library/exceptions.html#TypeError) с более информативным сообщением, что делает невозможным вызов (создание экземпляра) `ssl.SSLObject`.22832284> **Примечание**2285>2286> Проверка [`isinstance()`](https://python-all.ru/3.15/library/functions.html#isinstance) на соответствие протоколу с проверкой во время выполнения может быть удивительно медленной по сравнению с проверкой `isinstance()` для непротокольного класса. Рекомендуется использовать альтернативные идиомы, такие как вызовы [`hasattr()`](https://python-all.ru/3.15/library/functions.html#hasattr) для структурных проверок в коде, чувствительном к производительности.22872288Добавлено в версии 3.8.22892290Изменено в версии 3.12: Внутренняя реализация проверок [`isinstance()`](https://python-all.ru/3.15/library/functions.html#isinstance) на соответствие протоколам, проверяемым во время выполнения, теперь использует [`inspect.getattr_static()`](https://python-all.ru/3.15/library/inspect.html#inspect.getattr_static) для поиска атрибутов (ранее использовался [`hasattr()`](https://python-all.ru/3.15/library/functions.html#hasattr)). В результате некоторые объекты, которые ранее считались экземплярами проверяемого протокола, могут перестать считаться экземплярами этого протокола на Python 3.12+, и наоборот. Большинство пользователей вряд ли затронет это изменение.22912292Изменено в версии 3.12: Члены протокола, проверяемого во время выполнения, теперь считаются «замороженными» во время выполнения сразу после создания класса. Динамическое добавление атрибутов (monkey-patching) в такой протокол всё ещё будет работать, но не повлияет на проверки [`isinstance()`](https://python-all.ru/3.15/library/functions.html#isinstance), сравнивающие объекты с протоколом. См. [Что нового в Python 3.12](https://python-all.ru/3.15/whatsnew/3.12.html#whatsnew-typing-py312) для подробностей.22932294Устарело с версии 3.15, будет удалено в версии 3.20: Вызов проверок [`isinstance()`](https://python-all.ru/3.15/library/functions.html#isinstance) и [`issubclass()`](https://python-all.ru/3.15/library/functions.html#issubclass) для классов протоколов, которые не были явно декорированы с помощью `runtime_checkable()`, но наследуют от класса протокола с проверкой во время выполнения, является устаревшим. Это приведет к выбрасыванию [`TypeError`](https://python-all.ru/3.15/library/exceptions.html#TypeError) в Python 3.20.22952296#### `class typing.TypedDict(dict)`22972298Специальная конструкция для добавления подсказок типов к словарю. Во время выполнения «экземпляры `TypedDict`» – это просто [`dicts`](https://python-all.ru/3.15/library/stdtypes.html#dict).22992300`TypedDict` объявляет тип словаря, который ожидает, что все его экземпляры будут иметь определённый набор ключей, где каждый ключ связан со значением согласованного типа. Это ожидание не проверяется во время выполнения, а обеспечивается только средствами проверки типов. Использование:23012302```python2303class Point2D(TypedDict):2304 x: int2305 y: int2306 label: str23072308a: Point2D = {'x': 1, 'y': 2, 'label': 'good'} # ОК2309b: Point2D = {'z': 3, 'label': 'bad'} # Не проходит проверку типов23102311assert Point2D(x=1, y=2, label='first') == dict(x=1, y=2, label='first')2312```23132314Альтернативный способ создания `TypedDict` – использование синтаксиса вызова функции. Второй аргумент должен быть литералом [`dict`](https://python-all.ru/3.15/library/stdtypes.html#dict):23152316```python2317Point2D = TypedDict('Point2D', {'x': int, 'y': int, 'label': str})2318```23192320Этот функциональный синтаксис позволяет определять ключи, которые не являются допустимыми [идентификаторами](https://python-all.ru/3.15/reference/lexical_analysis.html#identifiers), например, потому что они являются ключевыми словами или содержат дефисы, или когда имена ключей не должны быть [искажены](https://python-all.ru/3.15/reference/expressions.html#private-name-mangling), как обычные закрытые имена:23212322```python2323# возбуждает SyntaxError2324class Point2D(TypedDict):2325 in: int # 'in' – ключевое слово2326 x-y: int # имя с дефисами23272328class Definition(TypedDict):2329 __schema: str # искажено до `_Definition__schema`23302331# ОК, функциональный синтаксис2332Point2D = TypedDict('Point2D', {'in': int, 'x-y': int})2333Definition = TypedDict('Definition', {'__schema': str}) # не искажается2334```23352336По умолчанию все ключи должны присутствовать в `TypedDict`. Можно пометить отдельные ключи как необязательные с помощью [`NotRequired`](https://python-all.ru/3.15/library/typing.html#typing.NotRequired):23372338```python2339class Point2D(TypedDict):2340 x: int2341 y: int2342 label: NotRequired[str]23432344# Альтернативный синтаксис2345Point2D = TypedDict('Point2D', {'x': int, 'y': int, 'label': NotRequired[str]})2346```23472348Это означает, что `Point2D` `TypedDict` может не содержать ключ `label`.23492350Также можно по умолчанию пометить все ключи как необязательные, указав totality `False`:23512352```python2353class Point2D(TypedDict, total=False):2354 x: int2355 y: int23562357# Альтернативный синтаксис2358Point2D = TypedDict('Point2D', {'x': int, 'y': int}, total=False)2359```23602361Это означает, что `Point2D` `TypedDict` может не содержать любой из ключей. Средство проверки типов должно поддерживать только литерал `False` или `True` в качестве значения аргумента `total`. `True` – значение по умолчанию, и оно делает все элементы, определённые в теле класса, обязательными.23622363Отдельные ключи `total=False` `TypedDict` можно пометить как обязательные с помощью [`Required`](https://python-all.ru/3.15/library/typing.html#typing.Required):23642365```python2366class Point2D(TypedDict, total=False):2367 x: Required[int]2368 y: Required[int]2369 label: str23702371# Альтернативный синтаксис2372Point2D = TypedDict('Point2D', {2373 'x': Required[int],2374 'y': Required[int],2375 'label': str2376}, total=False)2377```23782379`TypedDict` может наследоваться от одного или нескольких других типов `TypedDict` с использованием синтаксиса на основе классов. Использование:23802381```python2382class Point3D(Point2D):2383 z: int2384```23852386`Point3D` содержит три элемента: `x`, `y` и `z`. Это эквивалентно следующему определению:23872388```python2389class Point3D(TypedDict):2390 x: int2391 y: int2392 z: int2393```23942395По умолчанию `TypedDict` является открытым, то есть он может содержать дополнительные ключи во время выполнения, помимо тех, что определены в теле класса. Аргумент класса *closed* можно использовать для управления этим; если `closed=True`, то `TypedDict` не может содержать дополнительные ключи.23962397```python2398class ClosedPoint(TypedDict, closed=True):2399 x: int2400 y: int24012402class ClosedPoint3D(ClosedPoint): # Ошибка проверки типов: невозможно добавить ключи в закрытый TypedDict.2403 z: int2404```24052406Явная установка `closed=False` запрашивает поведение по умолчанию (открытое). Если аргумент не передан, это состояние наследуется от родительского класса.24072408В дополнение к открытому или закрытому состоянию, `TypedDict` можно настроить на наличие дополнительных элементов. Если аргумент класса *extra\_items* установлен в тип, то `TypedDict` может содержать произвольные дополнительные ключи, но значения этих ключей должны быть указанного типа.24092410```python2411class ExtraItemsPoint(TypedDict, extra_items=int):2412 x: int2413 y: int24142415point: ExtraItemsPoint = {'x': 1, 'y': 2, 'anything': 3} # ОК2416```24172418Аргумент *extra\_items* также наследуется через подклассы. По умолчанию он не установлен, и его нельзя использовать вместе с аргументом *closed*.24192420`TypedDict` не может наследоваться от класса, не являющегося `TypedDict`, за исключением [`Generic`](https://python-all.ru/3.15/library/typing.html#typing.Generic). Например:24212422```python2423class X(TypedDict):2424 x: int24252426class Y(TypedDict):2427 y: int24282429class Z(object): pass # Класс, не являющийся TypedDict24302431class XY(X, Y): pass # ОК24322433class XZ(X, Z): pass # вызывает TypeError2434```24352436`TypedDict` может быть обобщённым:24372438```python2439class Group[T](TypedDict):2440 key: T2441 group: list[T]2442```24432444Чтобы создать обобщённый `TypedDict`, совместимый с Python 3.11 и ниже, явно унаследуйтесь от [`Generic`](https://python-all.ru/3.15/library/typing.html#typing.Generic):24452446```python2447T = TypeVar("T")24482449class Group(TypedDict, Generic[T]):2450 key: T2451 group: list[T]2452```24532454`TypedDict` можно анализировать с помощью [`annotationlib.get_annotations()`](https://python-all.ru/3.15/library/annotationlib.html#annotationlib.get_annotations) (см. [Рекомендации по аннотациям](https://python-all.ru/3.15/howto/annotations.html#annotations-howto) для получения дополнительной информации о лучших практиках аннотаций) и следующих атрибутов:24552456#### `__total__`24572458`Point2D.__total__` возвращает значение аргумента `total`. Пример:24592460```pycon2461>>> from typing import TypedDict2462>>> class Point2D(TypedDict): pass2463>>> Point2D.__total__2464True2465>>> class Point2D(TypedDict, total=False): pass2466>>> Point2D.__total__2467False2468>>> class Point3D(Point2D): pass2469>>> Point3D.__total__2470True2471```24722473Этот атрибут отражает *только* значение аргумента `total` текущего класса `TypedDict`, а не то, является ли класс семантически полным. Например, `TypedDict` с `__total__`, равным `True`, может иметь ключи, помеченные [`NotRequired`](https://python-all.ru/3.15/library/typing.html#typing.NotRequired), или наследоваться от другого `TypedDict` с `total=False`. Поэтому для анализа обычно лучше использовать [`__required_keys__`](https://python-all.ru/3.15/library/typing.html#typing.TypedDict.__required_keys__) и [`__optional_keys__`](https://python-all.ru/3.15/library/typing.html#typing.TypedDict.__optional_keys__).24742475#### `__required_keys__`24762477Добавлено в версии 3.9.24782479#### `__optional_keys__`24802481`Point2D.__required_keys__` и `Point2D.__optional_keys__` возвращают объекты [`frozenset`](https://python-all.ru/3.15/library/stdtypes.html#frozenset), содержащие обязательные и необязательные ключи соответственно.24822483Ключи, помеченные [`Required`](https://python-all.ru/3.15/library/typing.html#typing.Required), всегда будут появляться в `__required_keys__`, а ключи, помеченные [`NotRequired`](https://python-all.ru/3.15/library/typing.html#typing.NotRequired), всегда будут появляться в `__optional_keys__`.24842485Для обратной совместимости с Python 3.10 и ниже также можно использовать наследование для объявления как обязательных, так и необязательных ключей в одном `TypedDict`. Это делается путём объявления `TypedDict` с одним значением аргумента `total`, а затем наследования от него в другом `TypedDict` с другим значением `total`:24862487```pycon2488>>> class Point2D(TypedDict, total=False):2489... x: int2490... y: int2491...2492>>> class Point3D(Point2D):2493... z: int2494...2495>>> Point3D.__required_keys__ == frozenset({'z'})2496True2497>>> Point3D.__optional_keys__ == frozenset({'x', 'y'})2498True2499```25002501Добавлено в версии 3.9.25022503> **Примечание**2504>2505> Если используется `from __future__ import annotations` или аннотации заданы в виде строк, аннотации не вычисляются при определении `TypedDict`. Поэтому анализ во время выполнения, на который полагаются `__required_keys__` и `__optional_keys__`, может работать неправильно, и значения атрибутов могут быть неверными.25062507#### `__readonly_keys__`25082509[`frozenset`](https://python-all.ru/3.15/library/stdtypes.html#frozenset), содержащий имена всех ключей только для чтения. Ключи доступны только для чтения, если они имеют квалификатор [`ReadOnly`](https://python-all.ru/3.15/library/typing.html#typing.ReadOnly).25102511Добавлено в версии 3.13.25122513#### `__mutable_keys__`25142515[`frozenset`](https://python-all.ru/3.15/library/stdtypes.html#frozenset), содержащий имена всех изменяемых ключей. Ключи являются изменяемыми, если они не имеют квалификатора [`ReadOnly`](https://python-all.ru/3.15/library/typing.html#typing.ReadOnly).25162517Добавлено в версии 3.13.25182519#### `__closed__`25202521Значение аргумента класса *closed*. Может быть `True`, `False` или [`None`](https://python-all.ru/3.15/library/constants.html#None).25222523#### `__extra_items__`25242525Значение аргумента класса *extra\_items*. Может быть валидным типом или [`NoExtraItems`](https://python-all.ru/3.15/library/typing.html#typing.NoExtraItems).25262527Дополнительные примеры и подробные правила приведены в разделе [TypedDict](https://python-all.ru/3.15/library/typing.html) документации typing.25282529Добавлено в версии 3.8.25302531Изменено в версии 3.9: `TypedDict` теперь функция, а не класс. По-прежнему может использоваться как базовый класс, как описано выше.25322533Изменено в версии 3.11: Добавлена поддержка пометки отдельных ключей как [`Required`](https://python-all.ru/3.15/library/typing.html#typing.Required) или [`NotRequired`](https://python-all.ru/3.15/library/typing.html#typing.NotRequired). См. [**PEP 655**](https://python-all.ru/3.15/library/typing.html).25342535Изменено в версии 3.11: Добавлена поддержка обобщённых `TypedDict`.25362537Изменено в версии 3.13: Удалена поддержка создания `TypedDict` через именованные аргументы.25382539Изменено в версии 3.13: Добавлена поддержка квалификатора [`ReadOnly`](https://python-all.ru/3.15/library/typing.html#typing.ReadOnly). См. [**PEP 705**](https://python-all.ru/3.15/library/typing.html).25402541Изменено в версии 3.15: Добавлена поддержка аргументов класса *closed* и *extra\_items*. См. [**PEP 728**](https://python-all.ru/3.15/library/typing.html).25422543### Протоколы25442545Следующие протоколы определены в модуле `typing`. Все они декорированы [`@runtime_checkable`](https://python-all.ru/3.15/library/typing.html#typing.runtime_checkable).25462547#### `class typing.SupportsAbs`25482549Протокол с одним абстрактным методом `__abs__`, ковариантным по возвращаемому типу.25502551#### `class typing.SupportsBytes`25522553Протокол с одним абстрактным методом `__bytes__`.25542555#### `class typing.SupportsComplex`25562557Протокол с одним абстрактным методом `__complex__`.25582559#### `class typing.SupportsFloat`25602561Протокол с одним абстрактным методом `__float__`.25622563#### `class typing.SupportsIndex`25642565Протокол с одним абстрактным методом `__index__`.25662567Добавлено в версии 3.8.25682569#### `class typing.SupportsInt`25702571Протокол с одним абстрактным методом `__int__`.25722573#### `class typing.SupportsRound`25742575Протокол с одним абстрактным методом `__round__`, ковариантным по возвращаемому типу.25762577### Абстрактные базовые классы и протоколы для работы с вводом-выводом25782579#### `class typing.IO[AnyStr]`25802581#### `class typing.TextIO`25822583#### `class typing.BinaryIO`25842585Обобщённый класс `IO[AnyStr]` и его подклассы `TextIO(IO[str])` и `BinaryIO(IO[bytes])` представляют типы потоков ввода-вывода (I/O), например возвращаемые [`open()`](https://python-all.ru/3.15/library/functions.html#open). Обратите внимание: эти классы не являются протоколами, и их интерфейс довольно обширен.25862587Протоколы [`io.Reader`](https://python-all.ru/3.15/library/io.html#io.Reader) и [`io.Writer`](https://python-all.ru/3.15/library/io.html#io.Writer) предоставляют более простую альтернативу для типов аргументов, когда доступны только методы `read()` или `write()` соответственно:25882589```python2590def read_and_write(reader: Reader[str], writer: Writer[bytes]):2591 data = reader.read()2592 writer.write(data.encode())2593```25942595Также рассмотрите использование [`collections.abc.Iterable`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Iterable) для итерации по строкам входного потока:25962597```python2598def read_config(stream: Iterable[str]):2599 for line in stream:2600 ...2601```26022603### Функции и декораторы26042605#### `typing.cast(typ, val)`26062607Приводит значение к типу.26082609Это возвращает значение без изменений. Для проверщика типов это сигнализирует, что возвращаемое значение имеет указанный тип, но во время выполнения мы намеренно ничего не проверяем (мы хотим, чтобы это было как можно быстрее).26102611#### `typing.assert_type(val, typ, /)`26122613Запросить у статического проверщика типов подтверждение, что *val* имеет выведенный тип *typ*.26142615Во время выполнения эта функция ничего не делает: она возвращает первый аргумент без изменений, без проверок или побочных эффектов, независимо от фактического типа аргумента.26162617Когда статический проверщик типов встречает вызов `assert_type()`, он выдает ошибку, если значение не относится к указанному типу:26182619```python2620def greet(name: str) -> None:2621 assert_type(name, str) # ОК, выведенный тип `name` – `str`2622 assert_type(name, int) # ошибка проверки типов2623```26242625Эта функция полезна для проверки того, что понимание скрипта проверщиком типов соответствует намерениям разработчика:26262627```python2628def complex_function(arg: object):2629 # Выполнить сложную логику сужения типа,2630 # после чего ожидается, что выведенный тип станет `int`2631 ...2632 # Проверить, правильно ли проверщик типов понимает нашу функцию2633 assert_type(arg, int)2634```26352636Добавлено в версии 3.12.26372638#### `typing.assert_never(arg, /)`26392640Попросить статический проверщик типов подтвердить, что строка кода недостижима.26412642Пример:26432644```python2645def int_or_str(arg: int | str) -> None:2646 match arg:2647 case int():2648 print("It's an int")2649 case str():2650 print("It's a str")2651 case _ as unreachable:2652 assert_never(unreachable)2653```26542655Здесь аннотации позволяют проверщику типов вывести, что последний случай никогда не выполнится, поскольку `arg` является либо [`int`](https://python-all.ru/3.15/library/functions.html#int), либо [`str`](https://python-all.ru/3.15/library/stdtypes.html#str), и оба варианта уже покрыты предыдущими случаями.26562657Если проверщик типов обнаружит, что вызов `assert_never()` достижим, он выдаст ошибку. Например, если бы аннотация типа для `arg` вместо этого была `int | str | float`, проверщик типов выдал бы ошибку, указывающую, что `unreachable` имеет тип [`float`](https://python-all.ru/3.15/library/functions.html#float). Для того чтобы вызов `assert_never` прошел проверку типов, выведенный тип переданного аргумента должен быть нижним типом [`Never`](https://python-all.ru/3.15/library/typing.html#typing.Never) и ничем иным.26582659Во время выполнения эта функция выбрасывает исключение при вызове.26602661> **См. также**2662>2663> В разделе [Unreachable Code and Exhaustiveness Checking](https://python-all.ru/3.15/library/typing.html) содержится дополнительная информация о проверке полноты с помощью статической типизации.26642665Добавлено в версии 3.12.26662667#### `typing.reveal_type(obj, /)`26682669Попросить статический проверщик типов показать выведенный тип выражения.26702671Когда статический проверщик типов встречает вызов этой функции, он выдает диагностическое сообщение с выведенным типом аргумента. Например:26722673```python2674x: int = 12675reveal_type(x) # Раскрытый тип – "builtins.int"2676```26772678Это может быть полезно для отладки того, как проверщик типов обрабатывает конкретный фрагмент кода.26792680Во время выполнения эта функция выводит тип аргумента во время выполнения в [`sys.stderr`](https://python-all.ru/3.15/library/sys.html#sys.stderr) и возвращает аргумент без изменений (что позволяет использовать вызов внутри выражения):26812682```python2683x = reveal_type(1) # выводит «Runtime type is int»2684print(x) # выводит "1"2685```26862687Обратите внимание, что тип во время выполнения может отличаться от статически выведенного типа (быть более или менее конкретным).26882689Большинство проверщиков типов поддерживают `reveal_type()` в любом месте, даже если имя не импортировано из `typing`. Однако импорт имени из `typing` позволяет коду выполняться без ошибок времени выполнения и более четко выражает намерения.26902691Добавлено в версии 3.12.26922693#### `@typing.dataclass_transform(*, eq_default=True, order_default=False, kw_only_default=False, frozen_default=False, field_specifiers=(), **kwargs)`26942695Декоратор для пометки объекта как предоставляющего поведение, подобное [`dataclass`](https://python-all.ru/3.15/library/dataclasses.html#dataclasses.dataclass).26962697`dataclass_transform` может использоваться для декорирования класса, метакласса или функции, которая сама является декоратором. Наличие `@dataclass_transform()` сообщает статическому проверщику типов, что декорированный объект выполняет во время выполнения «магию», преобразующую класс аналогично [`@dataclasses.dataclass`](https://python-all.ru/3.15/library/dataclasses.html#dataclasses.dataclass).26982699Пример использования с функцией-декоратором:27002701```python2702@dataclass_transform()2703def create_model[T](cls: type[T]) -> type[T]:2704 ...2705 return cls27062707@create_model2708class CustomerModel:2709 id: int2710 name: str2711```27122713На базовом классе:27142715```python2716@dataclass_transform()2717class ModelBase: ...27182719class CustomerModel(ModelBase):2720 id: int2721 name: str2722```27232724На метаклассе:27252726```python2727@dataclass_transform()2728class ModelMeta(type): ...27292730class ModelBase(metaclass=ModelMeta): ...27312732class CustomerModel(ModelBase):2733 id: int2734 name: str2735```27362737Классы `CustomerModel`, определенные выше, будут обрабатываться проверщиками типов аналогично классам, созданным с помощью [`@dataclasses.dataclass`](https://python-all.ru/3.15/library/dataclasses.html#dataclasses.dataclass). Например, проверщики типов будут предполагать, что эти классы имеют методы `__init__`, которые принимают `id` и `name`.27382739Декорированный класс, метакласс или функция могут принимать следующие булевы аргументы, которые, как будет считать проверщик типов, имеют тот же эффект, что и для декоратора [`@dataclasses.dataclass`](https://python-all.ru/3.15/library/dataclasses.html#dataclasses.dataclass): `init`, `eq`, `order`, `unsafe_hash`, `frozen`, `match_args`, `kw_only` и `slots`. Значения этих аргументов (`True` или `False`) должны быть статически вычислимыми.27402741Аргументы декоратора `dataclass_transform` могут использоваться для настройки поведения по умолчанию декорированного класса, метакласса или функции:27422743**Параметры:**27442745- **eq\_default** ([*bool*](https://python-all.ru/3.15/library/functions.html#bool)) – Указывает, предполагается ли параметр `eq` равным `True` или `False`, если он опущен вызывающей стороной. По умолчанию `True`.2746- **order\_default** ([*bool*](https://python-all.ru/3.15/library/functions.html#bool)) – Указывает, предполагается ли параметр `order` равным `True` или `False`, если он опущен вызывающей стороной. По умолчанию `False`.2747- **kw\_only\_default** ([*bool*](https://python-all.ru/3.15/library/functions.html#bool)) – Указывает, предполагается ли параметр `kw_only` равным `True` или `False`, если он опущен вызывающей стороной. По умолчанию `False`.2748- **frozen\_default** ([*bool*](https://python-all.ru/3.15/library/functions.html#bool)) –27492750 Указывает, считается ли параметр `frozen` равным `True` или `False`, если он опущен вызывающей стороной. По умолчанию `False`.27512752 Добавлено в версии 3.12.2753- **field\_specifiers** ([*tuple*](https://python-all.ru/3.15/library/stdtypes.html#tuple)*\[*[*Callable*](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Callable)*\[**...**,* *Any**\]**,* *...**\]*) – Задаёт статический список поддерживаемых классов или функций, описывающих поля, аналогично [`dataclasses.field()`](https://python-all.ru/3.15/library/dataclasses.html#dataclasses.field). По умолчанию `()`.2754- **\*\*kwargs** (*Any*) – Допускаются произвольные другие именованные аргументы, чтобы обеспечить возможность будущих расширений.27552756Проверщики типов распознают следующие необязательные параметры в спецификаторах полей:27572758| Имя параметра | Описание |2759| --- | --- |2760| `init` | Указывает, должно ли поле быть включено в синтезируемый метод `__init__`. Если не указано, `init` по умолчанию равно `True`. |2761| `default` | Предоставляет значение по умолчанию для поля. |2762| `default_factory` | Предоставляет колбэк времени выполнения, возвращающий значение по умолчанию для поля. Если не указаны ни `default`, ни `default_factory`, считается, что поле не имеет значения по умолчанию, и при создании экземпляра класса для него должно быть предоставлено значение. |2763| `factory` | Псевдоним для параметра `default_factory` в спецификаторах полей. |2764| `kw_only` | Указывает, должно ли поле быть помечено как keyword-only. Если `True`, поле будет keyword-only. Если `False`, оно не будет keyword-only. Если не указано, будет использовано значение параметра `kw_only` объекта, декорированного с помощью `dataclass_transform`, или, если оно не указано, значение `kw_only_default` на `dataclass_transform`. |2765| `alias` | Предоставляет альтернативное имя для поля. Это альтернативное имя используется в синтезируемом методе `__init__`. |27662767Во время выполнения этот декоратор записывает свои аргументы в атрибут `__dataclass_transform__` декорированного объекта. Других эффектов во время выполнения нет.27682769Подробнее см. [**PEP 681**](https://python-all.ru/3.15/library/typing.html).27702771Добавлено в версии 3.12.27722773#### `@typing.overload`27742775Декоратор для создания перегруженных функций и методов.27762777Декоратор `@overload` позволяет описывать функции и методы, поддерживающие несколько различных комбинаций типов аргументов. За серией определений, декорированных `@overload`, должно следовать ровно одно определение, не декорированное `@overload` (для той же функции/метода).27782779Определения, декорированные `@overload`, предназначены только для проверщика типов, поскольку они будут перезаписаны определением, не декорированным `@overload`. Определение, не декорированное `@overload`, в свою очередь, будет использоваться во время выполнения, но должно игнорироваться проверщиком типов. Во время выполнения прямой вызов функции, декорированной `@overload`, вызовет [`NotImplementedError`](https://python-all.ru/3.15/library/exceptions.html#NotImplementedError).27802781Пример перегрузки, которая даёт более точный тип, чем можно выразить с помощью объединения или переменной типа:27822783```python2784@overload2785def process(response: None) -> None:2786 ...2787@overload2788def process(response: int) -> tuple[int, str]:2789 ...2790@overload2791def process(response: bytes) -> str:2792 ...2793def process(response):2794 ... # здесь находится фактическая реализация2795```27962797Подробнее и сравнение с другими семантиками типизации см. [**PEP 484**](https://python-all.ru/3.15/library/typing.html).27982799Изменено в версии 3.11: Перегруженные функции теперь можно интроспектировать во время выполнения с помощью [`get_overloads()`](https://python-all.ru/3.15/library/typing.html#typing.get_overloads).28002801#### `typing.get_overloads(func)`28022803Возвращает последовательность определений, декорированных [`@overload`](https://python-all.ru/3.15/library/typing.html#typing.overload), для *func*.28042805*func* – это объект функции для реализации перегруженной функции. Например, если дано определение `process` в документации для [`@overload`](https://python-all.ru/3.15/library/typing.html#typing.overload), `get_overloads(process)` вернёт последовательность из трёх объектов функций для трёх определённых перегрузок. Если вызвана для функции без перегрузок, `get_overloads()` возвращает пустую последовательность.28062807`get_overloads()` можно использовать для интроспекции перегруженной функции во время выполнения.28082809Добавлено в версии 3.12.28102811#### `typing.clear_overloads()`28122813Очищает все зарегистрированные перегрузки во внутреннем реестре.28142815Это можно использовать для освобождения памяти, занятой реестром.28162817Добавлено в версии 3.12.28182819#### `@typing.final`28202821Декоратор для указания окончательных методов и окончательных классов.28222823Декорирование метода с помощью `@final` указывает проверщику типов, что метод не может быть переопределён в подклассе. Декорирование класса с помощью `@final` указывает, что от него нельзя наследовать.28242825Например:28262827```python2828class Base:2829 @final2830 def done(self) -> None:2831 ...2832class Sub(Base):2833 def done(self) -> None: # Ошибка, выдаваемая проверщиком типов2834 ...28352836@final2837class Leaf:2838 ...2839class Other(Leaf): # Ошибка, выдаваемая проверщиком типов2840 ...2841```28422843Проверка этих свойств во время выполнения не выполняется. Подробнее см. [**PEP 591**](https://python-all.ru/3.15/library/typing.html).28442845Добавлено в версии 3.8.28462847Изменено в версии 3.11: Декоратор теперь будет пытаться установить атрибут `__final__` в значение `True` на декорированном объекте. Таким образом, проверку вида `if getattr(obj, "__final__", False)` можно использовать во время выполнения, чтобы определить, был ли объект `obj` помечен как окончательный (final). Если декорированный объект не поддерживает установку атрибутов, декоратор возвращает объект без изменений, не вызывая исключения.28482849#### `@typing.no_type_check`28502851Декоратор, указывающий, что аннотации не являются подсказками типов.28522853Это работает как [декоратор](https://python-all.ru/3.15/glossary.html#term-decorator) класса или функции. Для класса он применяется рекурсивно ко всем методам и классам, определённым в этом классе (но не к методам, определённым в его суперклассах или подклассах). Средства проверки типов будут игнорировать все аннотации в функции или классе с этим декоратором.28542855`@no_type_check` изменяет декорированный объект на месте.28562857#### `@typing.override`28582859Декоратор, указывающий, что метод в подклассе предназначен для переопределения метода или атрибута в суперклассе.28602861Средства проверки типов должны выдавать ошибку, если метод, декорированный `@override`, на самом деле ничего не переопределяет. Это помогает предотвратить ошибки, которые могут возникнуть, когда базовый класс изменяется без соответствующего изменения в дочернем классе.28622863Например:28642865```python2866class Base:2867 def log_status(self) -> None:2868 ...28692870class Sub(Base):2871 @override2872 def log_status(self) -> None: # ОК: переопределяет Base.log_status2873 ...28742875 @override2876 def done(self) -> None: # Ошибка, выдаваемая проверщиком типов2877 ...2878```28792880Проверка этого свойства во время выполнения не производится.28812882Декоратор будет пытаться установить атрибут `__override__` в значение `True` на декорированном объекте. Таким образом, проверку вида `if getattr(obj, "__override__", False)` можно использовать во время выполнения, чтобы определить, был ли объект `obj` помечен как переопределение. Если декорированный объект не поддерживает установку атрибутов, декоратор возвращает объект без изменений, не вызывая исключения.28832884См. [**PEP 698**](https://python-all.ru/3.15/library/typing.html) для получения дополнительных сведений.28852886Добавлено в версии 3.12.28872888#### `@typing.disjoint_base`28892890Декоратор для пометки класса как непересекающегося базового.28912892Типизаторы не допускают, чтобы дочерние классы непересекающегося базового `C` наследовали от других непересекающихся базовых, не являющихся родительскими или дочерними классами `C`.28932894Например:28952896```python2897@disjoint_base2898class Disjoint1: pass28992900@disjoint_base2901class Disjoint2: pass29022903class Disjoint3(Disjoint1, Disjoint2): pass # Ошибка проверки типов2904```29052906Средства проверки типов могут использовать информацию о непересекающихся базовых классах для обнаружения недостижимого кода и определения, когда два типа могут пересекаться.29072908Соответствующее понятие времени выполнения – сплошной базовый класс (см. [Множественное наследование](https://python-all.ru/3.15/reference/compound_stmts.html#multiple-inheritance)). Классы, являющиеся сплошными базовыми во время выполнения, можно пометить с помощью `@disjoint_base` в файлах заглушек. Пользователи также могут помечать другие классы как непересекающиеся базовые, чтобы указать типизаторам, что множественное наследование с другими непересекающимися базовыми не должно разрешаться.29092910Обратите внимание, что понятие сплошного базового класса является деталью реализации CPython, и точный набор классов стандартной библиотеки, являющихся непересекающимися базовыми во время выполнения, может измениться в будущих версиях Python.29112912Добавлено в версии 3.15.29132914#### `@typing.type_check_only`29152916Декоратор для пометки класса или функции как недоступных во время выполнения.29172918Сам этот декоратор недоступен во время выполнения. Он в основном предназначен для пометки классов, определённых в файлах заглушек типов (type stub), если реализация возвращает экземпляр закрытого класса:29192920```python2921@type_check_only2922class Response: # приватный или недоступный во время выполнения2923 code: int2924 def get_header(self, name: str) -> str: ...29252926def fetch_response() -> Response: ...2927```29282929Обратите внимание, что возврат экземпляров закрытых классов не рекомендуется. Обычно предпочтительнее делать такие классы открытыми.29302931### Вспомогательные функции для интроспекции29322933#### `typing.get_type_hints(obj, globalns=None, localns=None, include_extras=False, *, format=Format.VALUE)`29342935Возвращает словарь, содержащий подсказки типов для функции, метода, модуля, объекта класса или другого вызываемого объекта.29362937Часто это то же самое, что и [`annotationlib.get_annotations()`](https://python-all.ru/3.15/library/annotationlib.html#annotationlib.get_annotations), но эта функция вносит следующие изменения в словарь аннотаций:29382939- Прямые ссылки (forward references), закодированные как строковые литералы или объекты [`ForwardRef`](https://python-all.ru/3.15/library/typing.html#typing.ForwardRef), обрабатываются путём вычисления их в пространствах имён *globalns*, *localns* и (где применимо) пространстве имён *obj*’s [параметра типа](https://python-all.ru/3.15/reference/compound_stmts.html#type-params). Если *globalns* или *localns* не заданы, соответствующие словари пространств имён выводятся из *obj*.2940- `None` заменяется на [`types.NoneType`](https://python-all.ru/3.15/library/types.html#types.NoneType).2941- Если к *obj* был применён [`@no_type_check`](https://python-all.ru/3.15/library/typing.html#typing.no_type_check), возвращается пустой словарь.2942- Если *obj* – это класс `C`, функция возвращает словарь, объединяющий аннотации из базовых классов `C` с аннотациями, непосредственно указанными в `C`. Это делается путём обхода [`C.__mro__`](https://python-all.ru/3.15/reference/datamodel.html#type.__mro__) и итеративного объединения [аннотаций](https://python-all.ru/3.15/glossary.html#term-variable-annotation) каждого базового класса. Аннотации классов, встречающихся раньше в [порядке разрешения методов](https://python-all.ru/3.15/glossary.html#term-method-resolution-order), всегда имеют приоритет над аннотациями классов, встречающихся позже в порядке разрешения методов.2943- Функция рекурсивно заменяет все вхождения `Annotated[T, ...]`, `Required[T]`, `NotRequired[T]` и `ReadOnly[T]` на `T`, если только *include\_extras* не установлен в `True` (см. [`Annotated`](https://python-all.ru/3.15/library/typing.html#typing.Annotated) для получения дополнительной информации).29442945> **Внимание**2946>2947> Эта функция может выполнять произвольный код, содержащийся в аннотациях. См. [Последствия безопасности интроспекции аннотаций](https://python-all.ru/3.15/library/annotationlib.html#annotationlib-security) для получения дополнительной информации.29482949> **Примечание**2950>2951> Если используется [`Format.VALUE`](https://python-all.ru/3.15/library/annotationlib.html#annotationlib.Format.VALUE) и какие-либо прямые ссылки в аннотациях *obj* не могут быть разрешены, возникает исключение [`NameError`](https://python-all.ru/3.15/library/exceptions.html#NameError). Например, это может произойти с именами, импортированными с помощью [`if TYPE_CHECKING`](https://python-all.ru/3.15/library/typing.html#typing.TYPE_CHECKING). В более общем случае может возникнуть любое исключение, если аннотация содержит недопустимый код Python.29522953> **Примечание**2954>2955> Вызов `get_type_hints()` для экземпляра не поддерживается. Чтобы получить аннотации для экземпляра, вызовите `get_type_hints()` для класса этого экземпляра (например, `get_type_hints(type(obj))`).29562957Изменено в версии 3.9: Добавлен параметр `include_extras` в рамках [**PEP 593**](https://python-all.ru/3.15/library/typing.html). См. документацию по [`Annotated`](https://python-all.ru/3.15/library/typing.html#typing.Annotated) для получения дополнительных сведений.29582959Изменено в версии 3.11: Ранее `Optional[t]` добавлялась для аннотаций функций и методов, если было установлено значение по умолчанию, равное `None`. Теперь аннотация возвращается без изменений.29602961Изменено в версии 3.14: Добавлен параметр `format`. Подробнее см. в документации [`annotationlib.get_annotations()`](https://python-all.ru/3.15/library/annotationlib.html#annotationlib.get_annotations).29622963Изменено в версии 3.14: Вызов `get_type_hints()` на экземплярах больше не поддерживается. Некоторые экземпляры принимались в более ранних версиях как недокументированная деталь реализации.29642965#### `typing.get_origin(tp)`29662967Возвращает неиндексированную версию типа: для объекта typing вида `X[Y, Z, ...]` возвращает `X`.29682969Если `X` – это псевдоним из модуля typing для встроенного класса или класса [`collections`](https://python-all.ru/3.15/library/collections.html#module-collections), он будет нормализован до исходного класса. Если `X` является экземпляром [`ParamSpecArgs`](https://python-all.ru/3.15/library/typing.html#typing.ParamSpecArgs) или [`ParamSpecKwargs`](https://python-all.ru/3.15/library/typing.html#typing.ParamSpecKwargs), возвращается базовый [`ParamSpec`](https://python-all.ru/3.15/library/typing.html#typing.ParamSpec). Для неподдерживаемых объектов возвращается `None`.29702971Примеры:29722973```python2974assert get_origin(str) is None2975assert get_origin(Dict[str, int]) is dict2976assert get_origin(Union[int, str]) is Union2977assert get_origin(Annotated[str, "metadata"]) is Annotated2978P = ParamSpec('P')2979assert get_origin(P.args) is P2980assert get_origin(P.kwargs) is P2981```29822983Добавлено в версии 3.8.29842985#### `typing.get_args(tp)`29862987Возвращает аргументы типа после выполнения всех подстановок: для объекта typing вида `X[Y, Z, ...]` возвращает `(Y, Z, ...)`.29882989Если `X` является объединением (union) или [`Literal`](https://python-all.ru/3.15/library/typing.html#typing.Literal) содержится в другом обобщённом типе, порядок `(Y, Z, ...)` может отличаться от порядка исходных аргументов `[Y, Z, ...]` из-за кеширования типов. Для неподдерживаемых объектов возвращается `()`.29902991Примеры:29922993```python2994assert get_args(int) == ()2995assert get_args(Dict[int, str]) == (int, str)2996assert get_args(Union[int, str]) == (int, str)2997```29982999Добавлено в версии 3.8.30003001#### `typing.get_protocol_members(tp)`30023003Возвращает набор членов, определённых в [`Protocol`](https://python-all.ru/3.15/library/typing.html#typing.Protocol).30043005```pycon3006>>> from typing import Protocol, get_protocol_members3007>>> class P(Protocol):3008... def a(self) -> str: ...3009... b: int3010>>> get_protocol_members(P) == frozenset({'a', 'b'})3011True3012```30133014Возбуждает [`TypeError`](https://python-all.ru/3.15/library/exceptions.html#TypeError) для аргументов, не являющихся протоколами.30153016Добавлено в версии 3.13.30173018#### `typing.is_protocol(tp)`30193020Определяет, является ли тип [`Protocol`](https://python-all.ru/3.15/library/typing.html#typing.Protocol).30213022Например:30233024```python3025class P(Protocol):3026 def a(self) -> str: ...3027 b: int30283029assert is_protocol(P)3030assert not is_protocol(int)3031```30323033Эта функция возвращает true только для классов `Protocol`, а не для их [обобщённых псевдонимов](https://python-all.ru/3.15/library/stdtypes.html#types-genericalias).30343035```python3036class GenericP[T](Protocol):3037 def a(self) -> T: ...3038 b: int30393040assert not is_protocol(GenericP[int])3041```30423043Добавлено в версии 3.13.30443045#### `typing.is_typeddict(tp)`30463047Проверяет, является ли тип [`TypedDict`](https://python-all.ru/3.15/library/typing.html#typing.TypedDict).30483049Например:30503051```python3052class Film(TypedDict):3053 title: str3054 year: int30553056assert is_typeddict(Film)3057assert not is_typeddict(list | str)30583059# TypedDict – это фабрика для создания типизированных словарей,3060# а не сам типизированный словарь3061assert not is_typeddict(TypedDict)3062```30633064Эта функция возвращает true только для классов `TypedDict`, а не для их [обобщённых псевдонимов](https://python-all.ru/3.15/library/stdtypes.html#types-genericalias).30653066```python3067class GenericFilm[T](TypedDict):3068 title: str3069 year: T30703071assert not is_typeddict(GenericFilm[int])3072```30733074Добавлено в версии 3.10.30753076#### `class typing.ForwardRef`30773078Класс для внутреннего представления строковых прямых ссылок в typing.30793080Например, `List["SomeClass"]` неявно преобразуется в `List[ForwardRef("SomeClass")]`. `ForwardRef` не должен создаваться пользователем, но может использоваться инструментами интроспекции.30813082> **Примечание**3083>3084> обобщённые типы [**PEP 585**](https://python-all.ru/3.15/library/typing.html), такие как `list["SomeClass"]`, не будут неявно преобразовываться в `list[ForwardRef("SomeClass")]` и, следовательно, не будут автоматически разрешаться в `list[SomeClass]`.30853086Добавлено в версии 3.7.4.30873088Изменено в версии 3.14: Теперь это псевдоним для [`annotationlib.ForwardRef`](https://python-all.ru/3.15/library/annotationlib.html#annotationlib.ForwardRef). Были изменены некоторые недокументированные особенности поведения этого класса; например, после вычисления `ForwardRef` вычисленное значение больше не кешируется.30893090#### `typing.evaluate_forward_ref(forward_ref, *, owner=None, globals=None, locals=None, type_params=None, format=annotationlib.Format.VALUE)`30913092Вычисляет [`annotationlib.ForwardRef`](https://python-all.ru/3.15/library/annotationlib.html#annotationlib.ForwardRef) как [подсказку типа](https://python-all.ru/3.15/glossary.html#term-type-hint).30933094Это похоже на вызов [`annotationlib.ForwardRef.evaluate()`](https://python-all.ru/3.15/library/annotationlib.html#annotationlib.ForwardRef.evaluate), но, в отличие от этого метода, `evaluate_forward_ref()` также рекурсивно вычисляет прямые ссылки, вложенные в подсказку типа.30953096Значение параметров *owner*, *globals*, *locals*, *type\_params* и *format* см. в документации [`annotationlib.ForwardRef.evaluate()`](https://python-all.ru/3.15/library/annotationlib.html#annotationlib.ForwardRef.evaluate).30973098> **Внимание**3099>3100> Эта функция может выполнять произвольный код, содержащийся в аннотациях. См. [Последствия безопасности интроспекции аннотаций](https://python-all.ru/3.15/library/annotationlib.html#annotationlib-security) для получения дополнительной информации.31013102Добавлено в версии 3.14.31033104#### `typing.NoDefault`31053106Сторожевой объект, используемый для указания того, что параметр типа не имеет значения по умолчанию. Например:31073108```pycon3109>>> T = TypeVar("T")3110>>> T.__default__ is typing.NoDefault3111True3112>>> S = TypeVar("S", default=None)3113>>> S.__default__ is None3114True3115```31163117Добавлено в версии 3.13.31183119#### `typing.NoExtraItems`31203121Объект [`sentinel`](https://python-all.ru/3.15/library/functions.html#sentinel), указывающий, что у [`TypedDict`](https://python-all.ru/3.15/library/typing.html#typing.TypedDict) отсутствует аргумент класса *extra\_items*.31223123```pycon3124>>> from typing import TypedDict, NoExtraItems3125>>> class Point(TypedDict):3126... x: int3127... y: int3128...3129>>> Point.__extra_items__ is NoExtraItems3130True3131```31323133### Константа31343135#### `typing.TYPE_CHECKING`31363137Специальная константа, которая считается равной `True` статическими анализаторами типов. Во время выполнения она равна `False`.31383139Модуль, который дорого импортировать и который содержит только типы для аннотаций, можно безопасно импортировать внутри блока `if TYPE_CHECKING:`. Это предотвращает фактический импорт модуля во время выполнения; аннотации не вычисляются с нетерпением (см. [**PEP 649**](https://python-all.ru/3.15/library/typing.html)), поэтому использование неопределённых символов в аннотациях безвредно – если только вы не станете анализировать их позже. Ваш инструмент статического анализа типов установит `TYPE_CHECKING` в `True` во время статического анализа, что означает, что модуль будет импортирован, а типы будут корректно проверены во время такого анализа.31403141Использование:31423143```python3144if TYPE_CHECKING:3145 import expensive_mod31463147def fun(arg: expensive_mod.SomeType) -> None:3148 local_var: expensive_mod.AnotherType = other_fun()3149```31503151Если вам время от времени нужно просматривать аннотации типов во время выполнения, которые могут содержать неопределённые символы, используйте [`annotationlib.get_annotations()`](https://python-all.ru/3.15/library/annotationlib.html#annotationlib.get_annotations) с параметром `format` равным [`annotationlib.Format.STRING`](https://python-all.ru/3.15/library/annotationlib.html#annotationlib.Format.STRING) или [`annotationlib.Format.FORWARDREF`](https://python-all.ru/3.15/library/annotationlib.html#annotationlib.Format.FORWARDREF), чтобы безопасно получить аннотации без возникновения [`NameError`](https://python-all.ru/3.15/library/exceptions.html#NameError).31523153Добавлено в версии 3.5.2.31543155### Устаревшие псевдонимы31563157Этот модуль определяет несколько устаревших псевдонимов для уже существующих классов стандартной библиотеки. Изначально они были включены в модуль `typing` для поддержки параметризации этих обобщённых классов с помощью `[]`. Однако эти псевдонимы стали избыточными в Python 3.9, когда соответствующие существующие классы были улучшены для поддержки `[]` (см. [**PEP 585**](https://python-all.ru/3.15/library/typing.html)).31583159Избыточные типы считаются устаревшими начиная с Python 3.9. Однако, хотя псевдонимы могут быть удалены в какой-то момент, их удаление в настоящее время не планируется. Поэтому в настоящее время интерпретатор не выдаёт предупреждений об устаревании для этих псевдонимов.31603161Если в какой-то момент будет принято решение удалить эти устаревшие псевдонимы, интерпретатор будет выдавать предупреждение об устаревании как минимум за два релиза до удаления. Гарантируется, что псевдонимы останутся в модуле `typing` без предупреждений об устаревании как минимум до Python 3.14.31623163Проверяющим типы рекомендуется отмечать использование устаревших типов, если проверяемая программа нацелена на минимальную версию Python 3.9 или новее.31643165#### Псевдонимы встроенных типов31663167#### `class typing.Dict(dict, MutableMapping[KT, VT])`31683169Устаревший псевдоним [`dict`](https://python-all.ru/3.15/library/stdtypes.html#dict).31703171Обратите внимание, что для аннотации аргументов предпочтительнее использовать абстрактный тип коллекции, такой как [`Mapping`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Mapping), а не [`dict`](https://python-all.ru/3.15/library/stdtypes.html#dict) или `typing.Dict`.31723173Deprecated since version 3.9: [`builtins.dict`](https://python-all.ru/3.15/library/stdtypes.html#dict) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.15/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.15/library/stdtypes.html#types-genericalias).31743175#### `class typing.List(list, MutableSequence[T])`31763177Устаревший псевдоним [`list`](https://python-all.ru/3.15/library/stdtypes.html#list).31783179Обратите внимание, что для аннотации аргументов предпочтительнее использовать абстрактный тип коллекции, такой как [`Sequence`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Sequence) или [`Iterable`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Iterable), а не [`list`](https://python-all.ru/3.15/library/stdtypes.html#list) или `typing.List`.31803181Deprecated since version 3.9: [`builtins.list`](https://python-all.ru/3.15/library/stdtypes.html#list) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.15/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.15/library/stdtypes.html#types-genericalias).31823183#### `class typing.Set(set, MutableSet[T])`31843185Устаревший псевдоним [`builtins.set`](https://python-all.ru/3.15/library/stdtypes.html#set).31863187Обратите внимание, что для аннотации аргументов предпочтительнее использовать абстрактный тип коллекции, такой как [`collections.abc.Set`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Set), а не [`set`](https://python-all.ru/3.15/library/stdtypes.html#set) или [`typing.Set`](https://python-all.ru/3.15/library/typing.html#typing.Set).31883189Deprecated since version 3.9: [`builtins.set`](https://python-all.ru/3.15/library/stdtypes.html#set) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.15/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.15/library/stdtypes.html#types-genericalias).31903191#### `class typing.FrozenSet(frozenset, AbstractSet[T_co])`31923193Устаревший псевдоним [`builtins.frozenset`](https://python-all.ru/3.15/library/stdtypes.html#frozenset).31943195Deprecated since version 3.9: [`builtins.frozenset`](https://python-all.ru/3.15/library/stdtypes.html#frozenset) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.15/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.15/library/stdtypes.html#types-genericalias).31963197#### `typing.Tuple`31983199Устаревший псевдоним для [`tuple`](https://python-all.ru/3.15/library/stdtypes.html#tuple).32003201[`tuple`](https://python-all.ru/3.15/library/stdtypes.html#tuple) и `Tuple` являются особыми случаями в системе типов; см. [Аннотирование кортежей](https://python-all.ru/3.15/library/typing.html#annotating-tuples) для получения дополнительной информации.32023203Deprecated since version 3.9: [`builtins.tuple`](https://python-all.ru/3.15/library/stdtypes.html#tuple) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.15/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.15/library/stdtypes.html#types-genericalias).32043205#### `class typing.Type(Generic[CT_co])`32063207Устаревший псевдоним [`type`](https://python-all.ru/3.15/library/functions.html#type).32083209См. [Тип объектов класса](https://python-all.ru/3.15/library/typing.html#type-of-class-objects) для подробностей об использовании [`type`](https://python-all.ru/3.15/library/functions.html#type) или `typing.Type` в аннотациях типов.32103211Добавлено в версии 3.5.2.32123213Deprecated since version 3.9: [`builtins.type`](https://python-all.ru/3.15/library/functions.html#type) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.15/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.15/library/stdtypes.html#types-genericalias).32143215#### Псевдонимы типов в [`collections`](https://python-all.ru/3.15/library/collections.html#module-collections)32163217#### `class typing.DefaultDict(collections.defaultdict, MutableMapping[KT, VT])`32183219Устаревший псевдоним [`collections.defaultdict`](https://python-all.ru/3.15/library/collections.html#collections.defaultdict).32203221Добавлено в версии 3.5.2.32223223Deprecated since version 3.9: [`collections.defaultdict`](https://python-all.ru/3.15/library/collections.html#collections.defaultdict) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.15/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.15/library/stdtypes.html#types-genericalias).32243225#### `class typing.OrderedDict(collections.OrderedDict, MutableMapping[KT, VT])`32263227Устаревший псевдоним [`collections.OrderedDict`](https://python-all.ru/3.15/library/collections.html#collections.OrderedDict).32283229Добавлено в версии 3.7.2.32303231Deprecated since version 3.9: [`collections.OrderedDict`](https://python-all.ru/3.15/library/collections.html#collections.OrderedDict) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.15/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.15/library/stdtypes.html#types-genericalias).32323233#### `class typing.ChainMap(collections.ChainMap, MutableMapping[KT, VT])`32343235Устаревший псевдоним [`collections.ChainMap`](https://python-all.ru/3.15/library/collections.html#collections.ChainMap).32363237Добавлено в версии 3.6.1.32383239Deprecated since version 3.9: [`collections.ChainMap`](https://python-all.ru/3.15/library/collections.html#collections.ChainMap) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.15/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.15/library/stdtypes.html#types-genericalias).32403241#### `class typing.Counter(collections.Counter, Dict[T, int])`32423243Устаревший псевдоним [`collections.Counter`](https://python-all.ru/3.15/library/collections.html#collections.Counter).32443245Добавлено в версии 3.6.1.32463247Deprecated since version 3.9: [`collections.Counter`](https://python-all.ru/3.15/library/collections.html#collections.Counter) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.15/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.15/library/stdtypes.html#types-genericalias).32483249#### `class typing.Deque(deque, MutableSequence[T])`32503251Устаревший псевдоним [`collections.deque`](https://python-all.ru/3.15/library/collections.html#collections.deque).32523253Добавлено в версии 3.6.1.32543255Deprecated since version 3.9: [`collections.deque`](https://python-all.ru/3.15/library/collections.html#collections.deque) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.15/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.15/library/stdtypes.html#types-genericalias).32563257#### Псевдонимы для других конкретных типов32583259#### `class typing.Pattern`32603261#### `class typing.Match`32623263Устаревшие псевдонимы, соответствующие типам возвращаемых значений из [`re.compile()`](https://python-all.ru/3.15/library/re.html#re.compile) и [`re.search()`](https://python-all.ru/3.15/library/re.html#re.search).32643265Эти типы (и соответствующие функции) являются обобщёнными относительно [`AnyStr`](https://python-all.ru/3.15/library/typing.html#typing.AnyStr). `Pattern` может быть специализирован как `Pattern[str]` или `Pattern[bytes]`; `Match` может быть специализирован как `Match[str]` или `Match[bytes]`.32663267Устарело с версии 3.9: Классы `Pattern` и `Match` из [`re`](https://python-all.ru/3.15/library/re.html#module-re) теперь поддерживают `[]`. См. [**PEP 585**](https://python-all.ru/3.15/library/typing.html) и [Generic Alias Type](https://python-all.ru/3.15/library/stdtypes.html#types-genericalias).32683269#### `class typing.Text`32703271Устаревший псевдоним для [`str`](https://python-all.ru/3.15/library/stdtypes.html#str).32723273`Text` предоставляется для обеспечения совместимости с кодом Python 2: в Python 2 `Text` является псевдонимом для `unicode`.32743275Используйте `Text`, чтобы указать, что значение должно содержать строку Unicode, совместимую как с Python 2, так и с Python 3:32763277```python3278def add_unicode_checkmark(text: Text) -> Text:3279 return text + u' \u2713'3280```32813282Добавлено в версии 3.5.2.32833284Устарело с версии 3.11: Python 2 больше не поддерживается, и большинство проверщиков типов также больше не поддерживают проверку типов для кода Python 2. Удаление псевдонима в настоящее время не планируется, но пользователям рекомендуется использовать [`str`](https://python-all.ru/3.15/library/stdtypes.html#str) вместо `Text`.32853286#### Псевдонимы для контейнерных ABC в [`collections.abc`](https://python-all.ru/3.15/library/collections.abc.html#module-collections.abc)32873288#### `class typing.AbstractSet(Collection[T_co])`32893290Устаревший псевдоним [`collections.abc.Set`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Set).32913292Deprecated since version 3.9: [`collections.abc.Set`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Set) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.15/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.15/library/stdtypes.html#types-genericalias).32933294#### `class typing.ByteString(Sequence[int])`32953296Устаревший псевдоним [`collections.abc.ByteString`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.ByteString).32973298При помощи `isinstance(obj, collections.abc.Buffer)` проверяется, реализует ли `obj` [протокол буфера](https://python-all.ru/3.15/c-api/buffer.html#bufferobjects) во время выполнения. Для аннотаций типов используйте [`Buffer`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Buffer) или объединение, явно перечисляющее поддерживаемые типы (например, `bytes | bytearray | memoryview`).32993300`ByteString` изначально задумывался как абстрактный класс, служащий супертипом как для [`bytes`](https://python-all.ru/3.15/library/stdtypes.html#bytes), так и для [`bytearray`](https://python-all.ru/3.15/library/stdtypes.html#bytearray). Однако, поскольку у ABC никогда не было методов, знание того, что объект является экземпляром `ByteString`, никогда не давало полезной информации об объекте. Другие распространённые типы буферов, такие как [`memoryview`](https://python-all.ru/3.15/library/stdtypes.html#memoryview), также никогда не воспринимались как подтипы `ByteString` (ни во время выполнения, ни статическими проверками типов).33013302См. [**PEP 688**](https://python-all.ru/3.15/library/typing.html) для получения дополнительных сведений.33033304Устарело с версии 3.9, будет удалено в версии 3.17.33053306#### `class typing.Collection(Sized, Iterable[T_co], Container[T_co])`33073308Устаревший псевдоним [`collections.abc.Collection`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Collection).33093310Добавлено в версии 3.6.33113312Deprecated since version 3.9: [`collections.abc.Collection`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Collection) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.15/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.15/library/stdtypes.html#types-genericalias).33133314#### `class typing.Container(Generic[T_co])`33153316Устаревший псевдоним [`collections.abc.Container`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Container).33173318Deprecated since version 3.9: [`collections.abc.Container`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Container) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.15/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.15/library/stdtypes.html#types-genericalias).33193320#### `class typing.ItemsView(MappingView, AbstractSet[tuple[KT_co, VT_co]])`33213322Устаревший псевдоним [`collections.abc.ItemsView`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.ItemsView).33233324Deprecated since version 3.9: [`collections.abc.ItemsView`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.ItemsView) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.15/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.15/library/stdtypes.html#types-genericalias).33253326#### `class typing.KeysView(MappingView, AbstractSet[KT_co])`33273328Устаревший псевдоним [`collections.abc.KeysView`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.KeysView).33293330Deprecated since version 3.9: [`collections.abc.KeysView`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.KeysView) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.15/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.15/library/stdtypes.html#types-genericalias).33313332#### `class typing.Mapping(Collection[KT], Generic[KT, VT_co])`33333334Устаревший псевдоним [`collections.abc.Mapping`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Mapping).33353336Deprecated since version 3.9: [`collections.abc.Mapping`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Mapping) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.15/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.15/library/stdtypes.html#types-genericalias).33373338#### `class typing.MappingView(Sized)`33393340Устаревший псевдоним [`collections.abc.MappingView`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.MappingView).33413342Deprecated since version 3.9: [`collections.abc.MappingView`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.MappingView) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.15/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.15/library/stdtypes.html#types-genericalias).33433344#### `class typing.MutableMapping(Mapping[KT, VT])`33453346Устаревший псевдоним [`collections.abc.MutableMapping`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.MutableMapping).33473348Deprecated since version 3.9: [`collections.abc.MutableMapping`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.MutableMapping) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.15/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.15/library/stdtypes.html#types-genericalias).33493350#### `class typing.MutableSequence(Sequence[T])`33513352Устаревший псевдоним [`collections.abc.MutableSequence`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.MutableSequence).33533354Deprecated since version 3.9: [`collections.abc.MutableSequence`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.MutableSequence) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.15/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.15/library/stdtypes.html#types-genericalias).33553356#### `class typing.MutableSet(AbstractSet[T])`33573358Устаревший псевдоним [`collections.abc.MutableSet`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.MutableSet).33593360Deprecated since version 3.9: [`collections.abc.MutableSet`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.MutableSet) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.15/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.15/library/stdtypes.html#types-genericalias).33613362#### `class typing.Sequence(Reversible[T_co], Collection[T_co])`33633364Устаревший псевдоним [`collections.abc.Sequence`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Sequence).33653366Deprecated since version 3.9: [`collections.abc.Sequence`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Sequence) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.15/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.15/library/stdtypes.html#types-genericalias).33673368#### `class typing.ValuesView(MappingView, Collection[_VT_co])`33693370Устаревший псевдоним [`collections.abc.ValuesView`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.ValuesView).33713372Deprecated since version 3.9: [`collections.abc.ValuesView`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.ValuesView) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.15/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.15/library/stdtypes.html#types-genericalias).33733374#### Псевдонимы для асинхронных ABC в [`collections.abc`](https://python-all.ru/3.15/library/collections.abc.html#module-collections.abc)33753376#### `class typing.Coroutine(Awaitable[ReturnType], Generic[YieldType, SendType, ReturnType])`33773378Устаревший псевдоним [`collections.abc.Coroutine`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Coroutine).33793380See [Annotating generators and coroutines](https://python-all.ru/3.15/library/typing.html#annotating-generators-and-coroutines) for details on using [`collections.abc.Coroutine`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Coroutine) and `typing.Coroutine` in type annotations.33813382Добавлено в версии 3.5.3.33833384Deprecated since version 3.9: [`collections.abc.Coroutine`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Coroutine) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.15/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.15/library/stdtypes.html#types-genericalias).33853386#### `class typing.AsyncGenerator(AsyncIterator[YieldType], Generic[YieldType, SendType])`33873388Устаревший псевдоним [`collections.abc.AsyncGenerator`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.AsyncGenerator).33893390See [Annotating generators and coroutines](https://python-all.ru/3.15/library/typing.html#annotating-generators-and-coroutines) for details on using [`collections.abc.AsyncGenerator`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.AsyncGenerator) and `typing.AsyncGenerator` in type annotations.33913392Добавлено в версии 3.6.1.33933394Deprecated since version 3.9: [`collections.abc.AsyncGenerator`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.AsyncGenerator) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.15/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.15/library/stdtypes.html#types-genericalias).33953396Изменено в версии 3.13: параметр `SendType` теперь имеет значение по умолчанию.33973398#### `class typing.AsyncIterable(Generic[T_co])`33993400Устаревший псевдоним [`collections.abc.AsyncIterable`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.AsyncIterable).34013402Добавлено в версии 3.5.2.34033404Deprecated since version 3.9: [`collections.abc.AsyncIterable`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.AsyncIterable) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.15/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.15/library/stdtypes.html#types-genericalias).34053406#### `class typing.AsyncIterator(AsyncIterable[T_co])`34073408Устаревший псевдоним [`collections.abc.AsyncIterator`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.AsyncIterator).34093410Добавлено в версии 3.5.2.34113412Deprecated since version 3.9: [`collections.abc.AsyncIterator`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.AsyncIterator) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.15/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.15/library/stdtypes.html#types-genericalias).34133414#### `class typing.Awaitable(Generic[T_co])`34153416Устаревший псевдоним [`collections.abc.Awaitable`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Awaitable).34173418Добавлено в версии 3.5.2.34193420Deprecated since version 3.9: [`collections.abc.Awaitable`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Awaitable) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.15/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.15/library/stdtypes.html#types-genericalias).34213422#### Псевдонимы для других ABC в [`collections.abc`](https://python-all.ru/3.15/library/collections.abc.html#module-collections.abc)34233424#### `class typing.Iterable(Generic[T_co])`34253426Устаревший псевдоним [`collections.abc.Iterable`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Iterable).34273428Deprecated since version 3.9: [`collections.abc.Iterable`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Iterable) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.15/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.15/library/stdtypes.html#types-genericalias).34293430#### `class typing.Iterator(Iterable[T_co])`34313432Устаревший псевдоним [`collections.abc.Iterator`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Iterator).34333434Deprecated since version 3.9: [`collections.abc.Iterator`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Iterator) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.15/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.15/library/stdtypes.html#types-genericalias).34353436#### `typing.Callable`34373438Устаревший псевдоним [`collections.abc.Callable`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Callable).34393440See [Annotating callable objects](https://python-all.ru/3.15/library/typing.html#annotating-callables) for details on how to use [`collections.abc.Callable`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Callable) and `typing.Callable` in type annotations.34413442Deprecated since version 3.9: [`collections.abc.Callable`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Callable) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.15/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.15/library/stdtypes.html#types-genericalias).34433444Changed in version 3.10: `Callable` now supports [`ParamSpec`](https://python-all.ru/3.15/library/typing.html#typing.ParamSpec) and [`Concatenate`](https://python-all.ru/3.15/library/typing.html#typing.Concatenate). See [**PEP 612**](https://python-all.ru/3.15/library/typing.html) for more details.34453446#### `class typing.Generator(Iterator[YieldType], Generic[YieldType, SendType, ReturnType])`34473448Устаревший псевдоним [`collections.abc.Generator`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Generator).34493450See [Annotating generators and coroutines](https://python-all.ru/3.15/library/typing.html#annotating-generators-and-coroutines) for details on using [`collections.abc.Generator`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Generator) and `typing.Generator` in type annotations.34513452Deprecated since version 3.9: [`collections.abc.Generator`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Generator) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.15/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.15/library/stdtypes.html#types-genericalias).34533454Изменено в версии 3.13: Добавлены значения по умолчанию для типов send и return.34553456#### `class typing.Hashable`34573458Устаревший псевдоним [`collections.abc.Hashable`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Hashable).34593460Устарело с версии 3.12: Используйте непосредственно [`collections.abc.Hashable`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Hashable).34613462#### `class typing.Reversible(Iterable[T_co])`34633464Устаревший псевдоним [`collections.abc.Reversible`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Reversible).34653466Deprecated since version 3.9: [`collections.abc.Reversible`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Reversible) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.15/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.15/library/stdtypes.html#types-genericalias).34673468#### `class typing.Sized`34693470Устаревший псевдоним [`collections.abc.Sized`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Sized).34713472Устарело с версии 3.12: Используйте непосредственно [`collections.abc.Sized`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Sized).34733474#### Псевдонимы для [`contextlib`](https://python-all.ru/3.15/library/contextlib.html#module-contextlib) ABCs34753476#### `class typing.ContextManager(Generic[T_co, ExitT_co])`34773478Устаревший псевдоним [`contextlib.AbstractContextManager`](https://python-all.ru/3.15/library/contextlib.html#contextlib.AbstractContextManager).34793480Первый параметр типа, `T_co`, представляет тип, возвращаемый методом [`__enter__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__enter__). Необязательный второй параметр типа, `ExitT_co`, по умолчанию равный `bool | None`, представляет тип, возвращаемый методом [`__exit__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__exit__).34813482Добавлено в версии 3.5.4.34833484Deprecated since version 3.9: [`contextlib.AbstractContextManager`](https://python-all.ru/3.15/library/contextlib.html#contextlib.AbstractContextManager) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.15/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.15/library/stdtypes.html#types-genericalias).34853486Изменено в версии 3.13: Добавлен необязательный второй параметр типа, `ExitT_co`.34873488#### `class typing.AsyncContextManager(Generic[T_co, AExitT_co])`34893490Устаревший псевдоним [`contextlib.AbstractAsyncContextManager`](https://python-all.ru/3.15/library/contextlib.html#contextlib.AbstractAsyncContextManager).34913492Первый параметр типа, `T_co`, представляет тип, возвращаемый методом [`__aenter__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__aenter__). Необязательный второй параметр типа, `AExitT_co`, по умолчанию равный `bool | None`, представляет тип, возвращаемый методом [`__aexit__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__aexit__).34933494Добавлено в версии 3.6.2.34953496Deprecated since version 3.9: [`contextlib.AbstractAsyncContextManager`](https://python-all.ru/3.15/library/contextlib.html#contextlib.AbstractAsyncContextManager) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.15/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.15/library/stdtypes.html#types-genericalias).34973498Изменено в версии 3.13: Добавлен необязательный второй параметр типа, `AExitT_co`.34993500## Хронология устаревания основных возможностей35013502Некоторые возможности в `typing` устарели и могут быть удалены в будущей версии Python. Для удобства ниже приведена таблица с основными устаревшими элементами. Она может изменяться, и в ней перечислены не все устаревшие возможности.35033504| Возможность | Устарело в | Планируемое удаление | PEP/issue |3505| --- | --- | --- | --- |3506| `typing` версии стандартных коллекций | 3.9 | Не определено (см. [устаревшие псевдонимы](https://python-all.ru/3.15/library/typing.html#deprecated-aliases) для дополнительной информации) | [**PEP 585**](https://python-all.ru/3.15/library/typing.html) |3507| [`typing.ByteString`](https://python-all.ru/3.15/library/typing.html#typing.ByteString) | 3.9 | 3.17 | [gh-91896](https://python-all.ru/3.15/library/typing.html) |3508| [`typing.Text`](https://python-all.ru/3.15/library/typing.html#typing.Text) | 3.11 | Не определено | [gh-92332](https://python-all.ru/3.15/library/typing.html) |3509| [`typing.Hashable`](https://python-all.ru/3.15/library/typing.html#typing.Hashable) и [`typing.Sized`](https://python-all.ru/3.15/library/typing.html#typing.Sized) | 3.12 | Не определено | [gh-94309](https://python-all.ru/3.15/library/typing.html) |3510| [`typing.TypeAlias`](https://python-all.ru/3.15/library/typing.html#typing.TypeAlias) | 3.12 | Не определено | [**PEP 695**](https://python-all.ru/3.15/library/typing.html) |3511| [`typing.AnyStr`](https://python-all.ru/3.15/library/typing.html#typing.AnyStr) | 3.13 | 3.18 | [gh-105578](https://python-all.ru/3.15/library/typing.html) |3512