typing.md

1> **Источник:** https://python-all.ru/3.12/library/typing.html2>3> «Документация Python на русском» – неофициальный перевод официальной документации Python: версии от 2.6 до 3.16, полнотекстовый поиск, английский оригинал рядом с переводом. Эта Markdown-версия страницы предназначена для работы с LLM: вставьте её в ChatGPT, Claude или Cursor.45---67# [`typing`](https://python-all.ru/3.12/library/typing.html#module-typing) – Поддержка аннотаций типов89Добавлено в версии 3.5.1011**Исходный код:** [Lib/typing.py](https://python-all.ru/src/3.12/Lib/typing.py)1213> **Примечание**14>15> Среда выполнения Python не проверяет аннотации типов функций и переменных. Они могут использоваться сторонними инструментами, такими как [проверщики типов](https://python-all.ru/3.12/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.12/library/functions.html#float), на что указывает [аннотация типа](https://python-all.ru/3.12/glossary.html#term-type-hint) `edge_length: float`. Функция должна возвращать экземпляр [`str`](https://python-all.ru/3.12/library/stdtypes.html#str), на что указывает аннотация `-> str`.2930Хотя аннотации типов могут быть простыми классами, такими как [`float`](https://python-all.ru/3.12/library/functions.html#float) или [`str`](https://python-all.ru/3.12/library/stdtypes.html#str), они также могут быть более сложными. Модуль [`typing`](https://python-all.ru/3.12/library/typing.html#module-typing) предоставляет набор более продвинутых аннотаций типов.3132Новые функции часто добавляются в модуль `typing`. Пакет [typing\_extensions](https://python-all.ru/3.12/library/typing.html) предоставляет бэкпорты этих новых функций для старых версий Python.3334> **См. также**35>36> **[«Шпаргалка по аннотациям типов»](https://python-all.ru/3.12/library/typing.html)**37>38> Краткий обзор аннотаций типов (размещён в документации mypy)39>40> **Раздел «Type System Reference» [документации mypy](https://python-all.ru/3.12/library/typing.html)**41>42> Система типов Python стандартизирована через PEP, поэтому данное руководство должно в целом подходить для большинства проверщиков типов Python. (Некоторые части могут по-прежнему относиться только к mypy.)43>44> **[«Статическая типизация в Python»](https://python-all.ru/3.12/library/typing.html)**45>46> Независимая от проверщика типов документация, написанная сообществом, с подробным описанием возможностей системы типов, полезных инструментов, связанных с типизацией, и лучших практик типизации.4748## Спецификация системы типов Python4950Каноническая, актуальная спецификация системы типов Python находится в [«Specification for the Python type system»](https://python-all.ru/3.12/library/typing.html).5152## Псевдонимы типов5354Псевдоним типа определяется с помощью оператора [`type`](https://python-all.ru/3.12/reference/simple_stmts.html#type), который создаёт экземпляр [`TypeAliasType`](https://python-all.ru/3.12/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.12/reference/simple_stmts.html#type) появился в Python 3.12. Для обратной совместимости псевдонимы типов также можно создавать с помощью простого присваивания:8889```python90Vector = list[float]91```9293Или помечены [`TypeAlias`](https://python-all.ru/3.12/library/typing.html#typing.TypeAlias), чтобы было явно указано, что это псевдоним типа, а не обычное присваивание переменной:9495```python96from typing import TypeAlias9798Vector: TypeAlias = list[float]99```100101## NewType102103Используйте вспомогательную функцию [`NewType`](https://python-all.ru/3.12/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.12/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.12/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.12/glossary.html#term-callable) объекты – могут быть аннотированы с помощью [`collections.abc.Callable`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.Callable) или устаревшего [`typing.Callable`](https://python-all.ru/3.12/library/typing.html#typing.Callable). `Callable[[int], str]` обозначает функцию, которая принимает один параметр типа [`int`](https://python-all.ru/3.12/library/functions.html#int) и возвращает [`str`](https://python-all.ru/3.12/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.12/library/typing.html#typing.ParamSpec), [`Concatenate`](https://python-all.ru/3.12/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.12/library/typing.html#overload) или функции, имеющие только ключевые параметры. Однако эти сигнатуры можно выразить, определив класс [`Protocol`](https://python-all.ru/3.12/library/typing.html#typing.Protocol) с методом [`__call__()`](https://python-all.ru/3.12/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.12/library/typing.html#typing.ParamSpec). Кроме того, если такой вызываемый объект добавляет или удаляет аргументы из других вызываемых объектов, может использоваться оператор [`Concatenate`](https://python-all.ru/3.12/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.12/library/typing.html#typing.ParamSpec) and [`Concatenate`](https://python-all.ru/3.12/library/typing.html#typing.Concatenate). See [**PEP 612**](https://python-all.ru/3.12/library/typing.html) for more details.234235> **См. также**236>237> В документации к [`ParamSpec`](https://python-all.ru/3.12/library/typing.html#typing.ParamSpec) и [`Concatenate`](https://python-all.ru/3.12/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.12/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.12/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.12/library/stdtypes.html#list) принимает только один аргумент типа, поэтому анализатор типов выдал бы ошибку на присваивании `y` выше. Аналогично, [`Mapping`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.Mapping) принимает только два аргумента типа: первый указывает тип ключей, а второй – тип значений.298299Однако, в отличие от большинства других контейнеров Python, в идиоматическом коде Python часто встречаются кортежи, элементы которых не все одного типа. По этой причине кортежи обрабатываются особым образом в системе типов Python. [`tuple`](https://python-all.ru/3.12/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.12/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.12/library/functions.html#type) являются классы, [`Any`](https://python-all.ru/3.12/library/typing.html#typing.Any), [переменные типа](https://python-all.ru/3.12/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.12/library/functions.html#type), который является корнем [иерархии метаклассов](https://python-all.ru/3.12/reference/datamodel.html#metaclasses) Python.374375## Аннотация генераторов и корутин376377Генератор можно аннотировать с помощью обобщённого типа [`Generator[YieldType, SendType, ReturnType]`](https://python-all.ru/3.12/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.12/library/collections.abc.html#collections.abc.Generator) ведёт себя контравариантно, а не ковариантно или инвариантно.388389Если ваш генератор будет только выдавать значения, установите `SendType` и `ReturnType` в `None`:390391```python392def infinite_stream(start: int) -> Generator[int, None, None]:393    while True:394        yield start395        start += 1396```397398В качестве альтернативы аннотируйте генератор как имеющий тип возвращаемого значения либо `Iterable[YieldType]`, либо `Iterator[YieldType]`:399400```python401def infinite_stream(start: int) -> Iterator[int]:402    while True:403        yield start404        start += 1405```406407Асинхронные генераторы обрабатываются аналогичным образом, но не ожидают аргумента типа `ReturnType` ([`AsyncGenerator[YieldType, SendType]`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.AsyncGenerator)):408409```python410async def infinite_stream(start: int) -> AsyncGenerator[int, None]:411    while True:412        yield start413        start = await increment(start)414```415416Как и в синхронном случае, [`AsyncIterable[YieldType]`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.AsyncIterable) и [`AsyncIterator[YieldType]`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.AsyncIterator) также доступны:417418```python419async def infinite_stream(start: int) -> AsyncIterator[int]:420    while True:421        yield start422        start = await increment(start)423```424425Корутины можно аннотировать с помощью [`Coroutine[YieldType, SendType, ReturnType]`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.Coroutine). Обобщённые аргументы соответствуют аргументам [`Generator`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.Generator), например:426427```python428from collections.abc import Coroutine429c: Coroutine[list[str], str, int]  # Некоторая корутина, определённая в другом месте.430x = c.send('hi')                   # Выведенный тип 'x' – list[str].431async def bar() -> None:432    y = await c                    # Выведенный тип 'y' – int.433```434435## Пользовательские обобщённые типы436437Пользовательский класс можно определить как обобщённый класс.438439```python440from logging import Logger441442class LoggedVar[T]:443    def __init__(self, value: T, name: str, logger: Logger) -> None:444        self.name = name445        self.logger = logger446        self.value = value447448    def set(self, new: T) -> None:449        self.log('Set ' + repr(self.value))450        self.value = new451452    def get(self) -> T:453        self.log('Get ' + repr(self.value))454        return self.value455456    def log(self, message: str) -> None:457        self.logger.info('%s: %s', self.name, message)458```459460Этот синтаксис означает, что класс `LoggedVar` параметризован одной [переменной типа](https://python-all.ru/3.12/library/typing.html#typevar) `T`. Это также делает `T` допустимым типом в теле класса.461462Обобщённые классы неявно наследуются от [`Generic`](https://python-all.ru/3.12/library/typing.html#typing.Generic). Для совместимости с Python 3.11 и ниже можно также явно наследоваться от [`Generic`](https://python-all.ru/3.12/library/typing.html#typing.Generic), чтобы указать обобщённый класс:463464```python465from typing import TypeVar, Generic466467T = TypeVar('T')468469class LoggedVar(Generic[T]):470    ...471```472473Обобщённые классы имеют методы [`__class_getitem__()`](https://python-all.ru/3.12/reference/datamodel.html#object.__class_getitem__), что означает возможность параметризации во время выполнения (например, `LoggedVar[int]` ниже):474475```python476from collections.abc import Iterable477478def zero_all_vars(vars: Iterable[LoggedVar[int]]) -> None:479    for var in vars:480        var.set(0)481```482483Обобщённый тип может иметь любое количество переменных типа. Все разновидности [`TypeVar`](https://python-all.ru/3.12/library/typing.html#typing.TypeVar) допустимы в качестве параметров обобщённого типа:484485```python486from typing import TypeVar, Generic, Sequence487488class WeirdTrio[T, B: Sequence[bytes], S: (int, str)]:489    ...490491OldT = TypeVar('OldT', contravariant=True)492OldB = TypeVar('OldB', bound=Sequence[bytes], covariant=True)493OldS = TypeVar('OldS', int, str)494495class OldWeirdTrio(Generic[OldT, OldB, OldS]):496    ...497```498499Каждый аргумент-переменная типа для [`Generic`](https://python-all.ru/3.12/library/typing.html#typing.Generic) должен быть уникальным. Поэтому такой код некорректен:500501```python502from typing import TypeVar, Generic503...504505class Pair[M, M]:  # SyntaxError506    ...507508T = TypeVar('T')509510class Pair(Generic[T, T]):   # INVALID511    ...512```513514Обобщённые классы также могут наследоваться от других классов:515516```python517from collections.abc import Sized518519class LinkedList[T](Sized):520    ...521```522523При наследовании от обобщённых классов некоторые параметры типа могут быть фиксированными:524525```python526from collections.abc import Mapping527528class MyDict[T](Mapping[str, T]):529    ...530```531532В этом случае `MyDict` имеет один параметр – `T`.533534Использование обобщённого класса без указания параметров типа подразумевает [`Any`](https://python-all.ru/3.12/library/typing.html#typing.Any) для каждой позиции. В следующем примере `MyIterable` не является обобщённым, но неявно наследуется от `Iterable[Any]`:535536```python537from collections.abc import Iterable538539class MyIterable(Iterable): # То же, что и Iterable[Any].540    ...541```542543Также поддерживаются пользовательские псевдонимы обобщённых типов. Примеры:544545```python546from collections.abc import Iterable547548type Response[S] = Iterable[S] | int549550# Тип возвращаемого значения здесь такой же, как Iterable[str] | int551def response(query: str) -> Response[str]:552    ...553554type Vec[T] = Iterable[tuple[T, T]]555556def inproduct[T: (int, float, complex)](v: Vec[T]) -> T: # То же, что и Iterable[tuple[T, T]]557    return sum(x*y for x, y in v)558```559560Для обратной совместимости псевдонимы обобщённых типов можно также создать простым присваиванием:561562```python563from collections.abc import Iterable564from typing import TypeVar565566S = TypeVar("S")567Response = Iterable[S] | int568```569570Изменено в версии 3.7: [`Generic`](https://python-all.ru/3.12/library/typing.html#typing.Generic) больше не имеет собственного метакласса.571572Изменено в версии 3.12: Синтаксическая поддержка обобщений и псевдонимов типов появилась в версии 3.12. Ранее обобщённые классы должны были явно наследоваться от [`Generic`](https://python-all.ru/3.12/library/typing.html#typing.Generic) или содержать переменную типа в одной из своих баз.573574Пользовательские обобщённые типы для выражений параметров также поддерживаются через переменные спецификации параметров в форме `[**P]`. Поведение согласуется с описанными выше переменными типов, так как переменные спецификации параметров обрабатываются модулем typing как специализированные переменные типов. Единственное исключение состоит в том, что список типов может использоваться для подстановки [`ParamSpec`](https://python-all.ru/3.12/library/typing.html#typing.ParamSpec):575576```python577>>> class Z[T, **P]: ...  # T – это TypeVar; P – это ParamSpec578...579>>> Z[int, [dict, float]]580__main__.Z[int, [dict, float]]581```582583Классы, обобщённые по [`ParamSpec`](https://python-all.ru/3.12/library/typing.html#typing.ParamSpec), также можно создать с помощью явного наследования от [`Generic`](https://python-all.ru/3.12/library/typing.html#typing.Generic). В этом случае `**` не используется:584585```python586from typing import ParamSpec, Generic587588P = ParamSpec('P')589590class Z(Generic[P]):591    ...592```593594Ещё одно различие между [`TypeVar`](https://python-all.ru/3.12/library/typing.html#typing.TypeVar) и [`ParamSpec`](https://python-all.ru/3.12/library/typing.html#typing.ParamSpec) заключается в том, что обобщение только с одной переменной спецификации параметров принимает списки параметров в виде `X[[Type1, Type2, ...]]`, а также `X[Type1, Type2, ...]` из эстетических соображений. Внутренне последняя форма преобразуется в первую, поэтому следующие варианты эквивалентны:595596```python597>>> class X[**P]: ...598...599>>> X[int, str]600__main__.X[[int, str]]601>>> X[[int, str]]602__main__.X[[int, str]]603```604605Обратите внимание: обобщения с [`ParamSpec`](https://python-all.ru/3.12/library/typing.html#typing.ParamSpec) могут не иметь корректного `__parameters__` после подстановки в некоторых случаях, поскольку они предназначены в первую очередь для статической проверки типов.606607Изменено в версии 3.10: [`Generic`](https://python-all.ru/3.12/library/typing.html#typing.Generic) теперь можно параметризовать по выражениям параметров. Подробнее см. [`ParamSpec`](https://python-all.ru/3.12/library/typing.html#typing.ParamSpec) и [**PEP 612**](https://python-all.ru/3.12/library/typing.html).608609Пользовательский обобщённый класс может иметь ABC в качестве базовых классов без конфликта метаклассов. Обобщённые метаклассы не поддерживаются. Результат параметризации обобщённых типов кэшируется, и большинство типов в модуле typing являются [хэшируемыми](https://python-all.ru/3.12/glossary.html#term-hashable) и сравнимыми на равенство.610611## Тип [`Any`](https://python-all.ru/3.12/library/typing.html#typing.Any)612613Особым видом типа является [`Any`](https://python-all.ru/3.12/library/typing.html#typing.Any). Статический проверяющий типов будет считать каждый тип совместимым с [`Any`](https://python-all.ru/3.12/library/typing.html#typing.Any), а [`Any`](https://python-all.ru/3.12/library/typing.html#typing.Any) – совместимым с каждым типом.614615Это означает, что над значением типа [`Any`](https://python-all.ru/3.12/library/typing.html#typing.Any) можно выполнять любые операции или вызовы методов и присваивать его любой переменной:616617```python618from typing import Any619620a: Any = None621a = []          # ОК622a = 2           # ОК623624s: str = ''625s = a           # ОК626627def foo(item: Any) -> int:628    # Проходит проверку типов; 'item' может быть любого типа,629    # и этот тип может иметь метод 'bar'630    item.bar()631    ...632```633634Обратите внимание: при присваивании значения типа [`Any`](https://python-all.ru/3.12/library/typing.html#typing.Any) более точному типу проверка типов не выполняется. Например, статический анализатор типов не сообщил об ошибке при присваивании `a` переменной `s`, хотя `s` была объявлена как тип [`str`](https://python-all.ru/3.12/library/stdtypes.html#str) и во время выполнения получает значение [`int`](https://python-all.ru/3.12/library/functions.html#int)!635636Кроме того, все функции без указания типа возврата или типов параметров по умолчанию неявно используют [`Any`](https://python-all.ru/3.12/library/typing.html#typing.Any):637638```python639def legacy_parser(text):640    ...641    return data642643# Статический проверщик типов будет рассматривать вышеприведенное644# как имеющее ту же сигнатуру, что и:645def legacy_parser(text: Any) -> Any:646    ...647    return data648```649650Такое поведение позволяет использовать [`Any`](https://python-all.ru/3.12/library/typing.html#typing.Any) в качестве *запасного выхода*, когда нужно смешивать динамически и статически типизированный код.651652Сравните поведение [`Any`](https://python-all.ru/3.12/library/typing.html#typing.Any) с поведением [`object`](https://python-all.ru/3.12/library/functions.html#object). Как и [`Any`](https://python-all.ru/3.12/library/typing.html#typing.Any), каждый тип является подтипом [`object`](https://python-all.ru/3.12/library/functions.html#object). Однако, в отличие от [`Any`](https://python-all.ru/3.12/library/typing.html#typing.Any), обратное неверно: [`object`](https://python-all.ru/3.12/library/functions.html#object) *не* является подтипом любого другого типа.653654Это означает, что когда тип значения – [`object`](https://python-all.ru/3.12/library/functions.html#object), проверяющий типы будет отклонять почти все операции над ним, а присваивание его переменной (или использование в качестве возвращаемого значения) более специализированного типа является ошибкой типа. Например:655656```python657def hash_a(item: object) -> int:658    # Не проходит проверку типов; у объекта нет метода 'magic'.659    item.magic()660    ...661662def hash_b(item: Any) -> int:663    # Проходит проверку типов664    item.magic()665    ...666667# Проходит проверку типов, так как int и str являются подклассами object668hash_a(42)669hash_a("foo")670671# Проходит проверку типов, так как Any совместим со всеми типами672hash_b(42)673hash_b("foo")674```675676Используйте [`object`](https://python-all.ru/3.12/library/functions.html#object), чтобы указать, что значение может быть любого типа в типобезопасной манере. Используйте [`Any`](https://python-all.ru/3.12/library/typing.html#typing.Any), чтобы указать, что значение динамически типизировано.677678## Номинальная и структурная типизация679680Изначально [**PEP 484**](https://python-all.ru/3.12/library/typing.html) определял систему статической типизации Python как использующую *номинальное подтипирование*. Это означает, что класс `A` разрешён там, где ожидается класс `B`, если и только если `A` является подклассом `B`.681682Ранее это требование также применялось к абстрактным базовым классам, таким как [`Iterable`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.Iterable). Проблема такого подхода в том, что класс должен быть явно помечен для их поддержки, что непитонично и не похоже на то, что обычно делается в идиоматическом динамически типизированном коде Python. Например, следующее соответствует [**PEP 484**](https://python-all.ru/3.12/library/typing.html):683684```python685from collections.abc import Sized, Iterable, Iterator686687class Bucket(Sized, Iterable[int]):688    ...689    def __len__(self) -> int: ...690    def __iter__(self) -> Iterator[int]: ...691```692693[**PEP 544**](https://python-all.ru/3.12/library/typing.html) позволяет решить эту проблему, разрешая пользователям писать приведённый выше код без явных базовых классов в определении класса, что позволяет `Bucket` неявно считаться подтипом как `Sized`, так и `Iterable[int]` статическими проверяющими типов. Это называется *структурной подтипизацией* (или статической утиной типизацией):694695```python696from collections.abc import Iterator, Iterable697698class Bucket:  # Примечание: базовые классы отсутствуют699    ...700    def __len__(self) -> int: ...701    def __iter__(self) -> Iterator[int]: ...702703def collect(items: Iterable[int]) -> int: ...704result = collect(Bucket())  # Проходит проверку типов705```706707Более того, наследуя специальный класс [`Protocol`](https://python-all.ru/3.12/library/typing.html#typing.Protocol), пользователь может определять новые пользовательские протоколы, чтобы в полной мере использовать структурное подтипирование (см. примеры ниже).708709## Содержимое модуля710711Модуль `typing` определяет следующие классы, функции и декораторы.712713### Специальные примитивы типизации714715#### Специальные типы716717Их можно использовать в качестве типов в аннотациях. Они не поддерживают подписку с помощью `[]`.718719#### `typing.Any`720721Специальный тип, указывающий на неограниченный тип.722723- Каждый тип совместим с [`Any`](https://python-all.ru/3.12/library/typing.html#typing.Any).724- [`Any`](https://python-all.ru/3.12/library/typing.html#typing.Any) совместим с каждым типом.725726Изменено в версии 3.11: [`Any`](https://python-all.ru/3.12/library/typing.html#typing.Any) теперь можно использовать в качестве базового класса. Это может быть полезно для предотвращения ошибок проверки типов в классах, которые могут использовать утиную типизацию где угодно или являются сильно динамичными.727728#### `typing.AnyStr`729730[Ограниченная переменная типа](https://python-all.ru/3.12/library/typing.html#typing-constrained-typevar).731732Определение:733734```python735AnyStr = TypeVar('AnyStr', str, bytes)736```737738`AnyStr` предназначен для функций, которые могут принимать аргументы типа [`str`](https://python-all.ru/3.12/library/stdtypes.html#str) или [`bytes`](https://python-all.ru/3.12/library/stdtypes.html#bytes), но не допускают их смешивания.739740Например:741742```python743def concat(a: AnyStr, b: AnyStr) -> AnyStr:744    return a + b745746concat("foo", "bar")    # OK, результат имеет тип 'str'747concat(b"foo", b"bar")  # OK, результат имеет тип 'bytes'748concat("foo", b"bar")   # Ошибка, нельзя смешивать str и bytes749```750751Обратите внимание, что, несмотря на название, `AnyStr` не имеет никакого отношения к типу [`Any`](https://python-all.ru/3.12/library/typing.html#typing.Any) и не означает «любая строка». В частности, `AnyStr` и `str | bytes` отличаются друг от друга и имеют разные сценарии использования:752753```python754# Неверное использование AnyStr:755# Переменная типа используется только один раз в сигнатуре функции,756# поэтому не может быть «решена» проверщиком типов757def greet_bad(cond: bool) -> AnyStr:758    return "hi there!" if cond else b"greetings!"759760# Лучший способ аннотировать эту функцию:761def greet_proper(cond: bool) -> str | bytes:762    return "hi there!" if cond else b"greetings!"763```764765#### `typing.LiteralString`766767Специальный тип, включающий только строковые литералы.768769Любой строковый литерал совместим с `LiteralString`, как и другой `LiteralString`. Однако объект, типизированный просто как `str`, – нет. Строка, созданная композицией объектов типа `LiteralString`, также приемлема как `LiteralString`.770771Пример:772773```python774def run_query(sql: LiteralString) -> None:775    ...776777def caller(arbitrary_string: str, literal_string: LiteralString) -> None:778    run_query("SELECT * FROM students")  # ОК779    run_query(literal_string)  # ОК780    run_query("SELECT * FROM " + literal_string)  # ОК781    run_query(arbitrary_string)  # ошибка проверки типов782    run_query(  # ошибка проверки типов783        f"SELECT * FROM students WHERE name = {arbitrary_string}"784    )785```786787`LiteralString` полезен для чувствительных API, где произвольные пользовательские строки могут создавать проблемы. Например, два приведённых выше случая, которые вызывают ошибки проверки типов, могут быть уязвимы для SQL-инъекций.788789Подробнее см. [**PEP 675**](https://python-all.ru/3.12/library/typing.html).790791Добавлено в версии 3.12.792793#### `typing.Never`794795#### `typing.NoReturn`796797`Never` и `NoReturn` представляют [нижний тип](https://python-all.ru/3.12/library/typing.html), тип, не имеющий элементов.798799Их можно использовать для обозначения того, что функция никогда не возвращает значение, например [`sys.exit()`](https://python-all.ru/3.12/library/sys.html#sys.exit):800801```python802from typing import Never  # или NoReturn803804def stop() -> Never:805    raise RuntimeError('no way')806```807808Или для определения функции, которая никогда не должна вызываться, поскольку нет допустимых аргументов, например [`assert_never()`](https://python-all.ru/3.12/library/typing.html#typing.assert_never):809810```python811from typing import Never  # или NoReturn812813def never_call_me(arg: Never) -> None:814    pass815816def int_or_str(arg: int | str) -> None:817    never_call_me(arg)  # ошибка проверки типов818    match arg:819        case int():820            print("It's an int")821        case str():822            print("It's a str")823        case _:824            never_call_me(arg)  # OK, аргумент имеет тип Never (или NoReturn)825```826827`Never` и `NoReturn` имеют одинаковое значение в системе типов, и статические анализаторы типов обрабатывают их одинаково.828829Добавлено в версии 3.6.2: Добавлен [`NoReturn`](https://python-all.ru/3.12/library/typing.html#typing.NoReturn).830831Добавлено в версии 3.11: Добавлен [`Never`](https://python-all.ru/3.12/library/typing.html#typing.Never).832833#### `typing.Self`834835Специальный тип для представления текущего вложенного класса.836837Например:838839```python840from typing import Self, reveal_type841842class Foo:843    def return_self(self) -> Self:844        ...845        return self846847class SubclassOfFoo(Foo): pass848849reveal_type(Foo().return_self())  # Раскрытый тип – "Foo"850reveal_type(SubclassOfFoo().return_self())  # Раскрытый тип – "SubclassOfFoo"851```852853Эта аннотация семантически эквивалентна следующему, хотя и в более краткой форме:854855```python856from typing import TypeVar857858Self = TypeVar("Self", bound="Foo")859860class Foo:861    def return_self(self: Self) -> Self:862        ...863        return self864```865866В общем случае, если что-то возвращает `self`, как в примерах выше, следует использовать `Self` в качестве аннотации возвращаемого типа. Если `Foo.return_self` был аннотирован как возвращающий `"Foo"`, то анализатор типов выведет, что объект, возвращённый из `SubclassOfFoo.return_self`, имеет тип `Foo` , а не `SubclassOfFoo`.867868Другие распространённые случаи использования включают:869870- [`classmethod`](https://python-all.ru/3.12/library/functions.html#classmethod), которые используются как альтернативные конструкторы и возвращают экземпляры параметра `cls`.871- Аннотирование метода [`__enter__()`](https://python-all.ru/3.12/reference/datamodel.html#object.__enter__), который возвращает self.872873Не следует использовать `Self` в качестве аннотации возвращаемого типа, если метод не гарантирует возврат экземпляра подкласса при наследовании класса:874875```python876class Eggs:877    # Self здесь была бы некорректной аннотацией возврата,878    # так как возвращаемый объект всегда является экземпляром Eggs,879    # даже в подклассах.880    def returns_eggs(self) -> "Eggs":881        return Eggs()882```883884См. [**PEP 673**](https://python-all.ru/3.12/library/typing.html) для получения дополнительных сведений.885886Добавлено в версии 3.12.887888#### `typing.TypeAlias`889890Специальная аннотация для явного объявления [псевдонима типа](https://python-all.ru/3.12/library/typing.html#type-aliases).891892Например:893894```python895from typing import TypeAlias896897Factors: TypeAlias = list[int]898```899900`TypeAlias` особенно полезен в старых версиях Python для аннотирования псевдонимов, которые используют опережающие ссылки, поскольку анализаторам типов может быть трудно отличить их от обычных присваиваний переменных:901902```python903from typing import Generic, TypeAlias, TypeVar904905T = TypeVar("T")906907# "Box" ещё не существует,908# поэтому для прямой ссылки на Python <3.12 приходится использовать кавычки.909# Использование ``TypeAlias`` сообщает тайпчекеру, что это объявление псевдонима типа,910# а не присваивание переменной строкового значения.911BoxOfStrings: TypeAlias = "Box[str]"912913class Box(Generic[T]):914    @classmethod915    def make_box_of_strings(cls) -> BoxOfStrings: ...916```917918См. [**PEP 613**](https://python-all.ru/3.12/library/typing.html) для получения дополнительных сведений.919920Добавлено в версии 3.10.921922Устарело с версии 3.12: [`TypeAlias`](https://python-all.ru/3.12/library/typing.html#typing.TypeAlias) устарел в пользу инструкции [`type`](https://python-all.ru/3.12/reference/simple_stmts.html#type), которая создаёт экземпляры [`TypeAliasType`](https://python-all.ru/3.12/library/typing.html#typing.TypeAliasType) и поддерживает опережающие ссылки изначально. Обратите внимание, что, хотя [`TypeAlias`](https://python-all.ru/3.12/library/typing.html#typing.TypeAlias) и [`TypeAliasType`](https://python-all.ru/3.12/library/typing.html#typing.TypeAliasType) служат похожим целям и имеют похожие названия, они различаются, и последний не является типом первого. Удаление [`TypeAlias`](https://python-all.ru/3.12/library/typing.html#typing.TypeAlias) в настоящее время не планируется, но пользователям рекомендуется переходить на инструкции [`type`](https://python-all.ru/3.12/reference/simple_stmts.html#type).923924#### Специальные формы925926Их можно использовать в качестве типов в аннотациях. Они все поддерживают индексацию с помощью `[]`, но каждый из них имеет уникальный синтаксис.927928#### `typing.Union`929930Тип объединения; `Union[X, Y]` эквивалентно `X | Y` и означает X или Y.931932Для определения объединения используйте, например, `Union[int, str]` или сокращённую запись `int | str`. Рекомендуется использовать сокращённую запись. Подробности:933934- Аргументы должны быть типами, и их должно быть как минимум один.935- Объединения объединений разворачиваются, например:936937  ```python938  Union[Union[int, str], float] == Union[int, str, float]939  ```940- Объединения из одного аргумента исчезают, например:941942  ```python943  Union[int] == int  # Конструктор на самом деле возвращает int944  ```945- Повторяющиеся аргументы пропускаются, например:946947  ```python948  Union[int, str, int] == Union[int, str] == int | str949  ```950- При сравнении объединений порядок аргументов игнорируется, например:951952  ```python953  Union[int, str] == Union[str, int]954  ```955- Нельзя наследовать или создавать экземпляр `Union`.956- Нельзя записать `Union[X][Y]`.957958Изменено в версии 3.7: Явные подклассы не удаляются из объединений во время выполнения.959960Изменено в версии 3.10: Объединения теперь можно записывать как `X | Y`. См. [выражения типов объединений](https://python-all.ru/3.12/library/stdtypes.html#types-union).961962#### `typing.Optional`963964`Optional[X]` эквивалентен `X | None` (или `Union[X, None]`).965966Обратите внимание, что это не то же самое, что необязательный аргумент, который имеет значение по умолчанию. Необязательный аргумент с значением по умолчанию не требует квалификатора `Optional` в своей аннотации типа только потому, что он необязателен. Например:967968```python969def foo(arg: int = 0) -> None:970    ...971```972973С другой стороны, если явное значение `None` допускается, то использование `Optional` уместно, независимо от того, является ли аргумент необязательным или нет. Например:974975```python976def foo(arg: Optional[int] = None) -> None:977    ...978```979980Изменено в версии 3.10: Optional теперь можно записывать как `X | None`. См. [выражения типов объединений](https://python-all.ru/3.12/library/stdtypes.html#types-union).981982#### `typing.Concatenate`983984Специальная форма для аннотирования функций высшего порядка.985986`Concatenate` может использоваться совместно с [Callable](https://python-all.ru/3.12/library/typing.html#annotating-callables) и [`ParamSpec`](https://python-all.ru/3.12/library/typing.html#typing.ParamSpec) для аннотации вызываемого объекта высшего порядка, который добавляет, удаляет или преобразует параметры другого вызываемого объекта. Использование имеет форму `Concatenate[Arg1Type, Arg2Type, ..., ParamSpecVariable]`. `Concatenate` в настоящее время допустим только в качестве первого аргумента [Callable](https://python-all.ru/3.12/library/typing.html#annotating-callables). Последний параметр `Concatenate` должен быть [`ParamSpec`](https://python-all.ru/3.12/library/typing.html#typing.ParamSpec) или многоточием (`...`).987988Например, чтобы аннотировать декоратор `with_lock`, который предоставляет [`threading.Lock`](https://python-all.ru/3.12/library/threading.html#threading.Lock) декорируемой функции, можно использовать `Concatenate`, чтобы указать, что `with_lock` ожидает вызываемый объект, который принимает `Lock` в качестве первого аргумента, и возвращает вызываемый объект с другой сигнатурой типа. В этом случае [`ParamSpec`](https://python-all.ru/3.12/library/typing.html#typing.ParamSpec) указывает на то, что типы параметров возвращаемого вызываемого объекта зависят от типов параметров передаваемого вызываемого объекта:989990```python991from collections.abc import Callable992from threading import Lock993from typing import Concatenate994995# Используйте эту блокировку, чтобы гарантировать, что только один поток выполняет функцию996# в любой момент времени.997my_lock = Lock()998999def with_lock[**P, R](f: Callable[Concatenate[Lock, P], R]) -> Callable[P, R]:1000    '''Типобезопасный декоратор, предоставляющий блокировку.'''1001    def inner(*args: P.args, **kwargs: P.kwargs) -> R:1002        # Передайте блокировку в качестве первого аргумента.1003        return f(my_lock, *args, **kwargs)1004    return inner10051006@with_lock1007def sum_threadsafe(lock: Lock, numbers: list[float]) -> float:1008    '''Складывайте список чисел потокобезопасным способом.'''1009    with lock:1010        return sum(numbers)10111012# Нам не нужно передавать блокировку вручную благодаря декоратору.1013sum_threadsafe([1.1, 2.2, 3.3])1014```10151016Добавлено в версии 3.10.10171018> **См. также**1019>1020> - [**PEP 612**](https://python-all.ru/3.12/library/typing.html) – Переменные спецификации параметров (PEP, в котором были введены `ParamSpec` и `Concatenate`)1021> - [`ParamSpec`](https://python-all.ru/3.12/library/typing.html#typing.ParamSpec)1022> - [Аннотация вызываемых объектов](https://python-all.ru/3.12/library/typing.html#annotating-callables)10231024#### `typing.Literal`10251026Специальная форма типизации для определения «литеральных типов».10271028`Literal` можно использовать, чтобы указать проверяющим типа, что аннотированный объект имеет значение, эквивалентное одному из предоставленных литералов.10291030Например:10311032```python1033def validate_simple(data: Any) -> Literal[True]:  # всегда возвращает True1034    ...10351036type Mode = Literal['r', 'rb', 'w', 'wb']1037def open_helper(file: str, mode: Mode) -> str:1038    ...10391040open_helper('/some/path', 'r')      # Проходит проверку типов1041open_helper('/other/path', 'typo')  # Ошибка в тайпчекере1042```10431044`Literal[...]` нельзя наследовать. Во время выполнения произвольное значение допускается в качестве аргумента типа для `Literal[...]`, но проверяющие типа могут накладывать ограничения. См. [**PEP 586**](https://python-all.ru/3.12/library/typing.html) для получения дополнительных сведений о литеральных типах.10451046Добавлено в версии 3.8.10471048Изменено в версии 3.9.1: `Literal` теперь дедуплицирует параметры. Сравнения на равенство объектов `Literal` больше не зависят от порядка. Объекты `Literal` теперь будут вызывать исключение [`TypeError`](https://python-all.ru/3.12/library/exceptions.html#TypeError) при сравнении на равенство, если один из их параметров не является [хешируемым](https://python-all.ru/3.12/glossary.html#term-hashable).10491050#### `typing.ClassVar`10511052Специальная конструкция типа для пометки переменных класса.10531054Как представлено в [**PEP 526**](https://python-all.ru/3.12/library/typing.html), аннотация переменной, обёрнутая в ClassVar, указывает, что данный атрибут предназначен для использования в качестве переменной класса и не должен устанавливаться на экземплярах этого класса. Использование:10551056```python1057class Starship:1058    stats: ClassVar[dict[str, int]] = {} # переменная класса1059    damage: int = 10                     # переменная экземпляра1060```10611062[`ClassVar`](https://python-all.ru/3.12/library/typing.html#typing.ClassVar) принимает только типы и не может быть дополнительно индексирован.10631064[`ClassVar`](https://python-all.ru/3.12/library/typing.html#typing.ClassVar) сам по себе не является классом и не должен использоваться с [`isinstance()`](https://python-all.ru/3.12/library/functions.html#isinstance) или [`issubclass()`](https://python-all.ru/3.12/library/functions.html#issubclass). [`ClassVar`](https://python-all.ru/3.12/library/typing.html#typing.ClassVar) не меняет поведение Python во время выполнения, но может использоваться сторонними проверяющими типов. Например, проверяющий типов может отметить следующий код как ошибочный:10651066```python1067enterprise_d = Starship(3000)1068enterprise_d.stats = {} # Ошибка: установка переменной класса на экземпляре1069Starship.stats = {}     # Это корректно.1070```10711072Добавлено в версии 3.5.3.10731074#### `typing.Final`10751076Специальная конструкция типизации для указания проверяющим типам, что имена являются финальными.10771078Финальные имена нельзя переназначать ни в какой области видимости. Финальные имена, объявленные в области класса, нельзя переопределять в подклассах.10791080Например:10811082```python1083MAX_SIZE: Final = 90001084MAX_SIZE += 1  # Ошибка, выдаваемая проверщиком типов10851086class Connection:1087    TIMEOUT: Final[int] = 1010881089class FastConnector(Connection):1090    TIMEOUT = 1  # Ошибка, выдаваемая проверщиком типов1091```10921093Проверка этих свойств во время выполнения не выполняется. Подробнее см. [**PEP 591**](https://python-all.ru/3.12/library/typing.html).10941095Добавлено в версии 3.8.10961097#### `typing.Required`10981099Специальная конструкция типизации для пометки ключа [`TypedDict`](https://python-all.ru/3.12/library/typing.html#typing.TypedDict) как обязательного.11001101В основном это полезно для `total=False` TypedDict. Подробнее см. [`TypedDict`](https://python-all.ru/3.12/library/typing.html#typing.TypedDict) и [**PEP 655**](https://python-all.ru/3.12/library/typing.html).11021103Добавлено в версии 3.12.11041105#### `typing.NotRequired`11061107Специальная конструкция типизации для пометки ключа [`TypedDict`](https://python-all.ru/3.12/library/typing.html#typing.TypedDict) как потенциально отсутствующего.11081109Подробнее см. [`TypedDict`](https://python-all.ru/3.12/library/typing.html#typing.TypedDict) и [**PEP 655**](https://python-all.ru/3.12/library/typing.html).11101111Добавлено в версии 3.12.11121113#### `typing.Annotated`11141115Специальная форма типизации для добавления контекстно-зависимых метаданных к аннотации.11161117Добавляет метаданные `x` к заданному типу `T` с помощью аннотации `Annotated[T, x]`. Метаданные, добавленные с помощью `Annotated`, могут использоваться инструментами статического анализа или во время выполнения. Во время выполнения метаданные хранятся в атрибуте `__metadata__`.11181119Если библиотека или инструмент встречает аннотацию `Annotated[T, x]` и не имеет специальной логики для метаданных, он должен игнорировать метаданные и просто рассматривать аннотацию как `T`. Таким образом, `Annotated` может быть полезна для кода, который хочет использовать аннотации для целей, выходящих за рамки системы статической типизации Python.11201121Использование `Annotated[T, x]` в качестве аннотации по-прежнему допускает статическую проверку типов для `T`, поскольку проверяющие типы просто игнорируют метаданные `x`. Таким образом, `Annotated` отличается от декоратора [`@no_type_check`](https://python-all.ru/3.12/library/typing.html#typing.no_type_check), который также можно использовать для добавления аннотаций за пределами системы типизации, но полностью отключает проверку типов для функции или класса.11221123Ответственность за интерпретацию метаданных лежит на инструменте или библиотеке, встречающей аннотацию `Annotated`. Инструмент или библиотека, встречающие тип `Annotated`, могут просмотреть элементы метаданных, чтобы определить, представляют ли они интерес (например, с помощью [`isinstance()`](https://python-all.ru/3.12/library/functions.html#isinstance)).11241125#### `Annotated[<type>, <metadata>]`11261127Вот пример того, как можно использовать `Annotated` для добавления метаданных к аннотациям типов при выполнении анализа диапазонов:11281129```python1130@dataclass1131class ValueRange:1132    lo: int1133    hi: int11341135T1 = Annotated[int, ValueRange(-10, 5)]1136T2 = Annotated[T1, ValueRange(-20, 3)]1137```11381139Первый аргумент `Annotated` должен быть допустимым типом. Можно указать несколько элементов метаданных, так как `Annotated` поддерживает вариативные аргументы. Порядок элементов метаданных сохраняется и важен для проверок на равенство:11401141```python1142@dataclass1143class ctype:1144     kind: str11451146a1 = Annotated[int, ValueRange(3, 10), ctype("char")]1147a2 = Annotated[int, ctype("char"), ValueRange(3, 10)]11481149assert a1 != a2  # Порядок важен1150```11511152Инструмент, потребляющий аннотации, сам решает, разрешено ли клиенту добавлять несколько элементов метаданных к одной аннотации и как объединять эти аннотации.11531154Вложенные типы `Annotated` уплощаются. Порядок элементов метаданных начинается с самой внутренней аннотации:11551156```python1157assert Annotated[Annotated[int, ValueRange(3, 10)], ctype("char")] == Annotated[1158    int, ValueRange(3, 10), ctype("char")1159]1160```11611162Дублирующиеся элементы метаданных не удаляются:11631164```python1165assert Annotated[int, ValueRange(3, 10)] != Annotated[1166    int, ValueRange(3, 10), ValueRange(3, 10)1167]1168```11691170`Annotated` можно использовать с вложенными и обобщёнными псевдонимами:11711172> ```python1173> @dataclass1174> class MaxLen:1175>     value: int1176>1177> type Vec[T] = Annotated[list[tuple[T, T]], MaxLen(10)]1178>1179> # При использовании в аннотации типа тайпчекер будет обрабатывать "V" так же, как1180> # ``Annotated[list[tuple[int, int]], MaxLen(10)]``:1181> type V = Vec[int]1182> ```11831184`Annotated` нельзя использовать с распакованным [`TypeVarTuple`](https://python-all.ru/3.12/library/typing.html#typing.TypeVarTuple):11851186```python1187type Variadic[*Ts] = Annotated[*Ts, Ann1] = Annotated[T1, T2, T3, ..., Ann1]  # НЕДОПУСТИМО1188```11891190где `T1`, `T2`, … – это [`TypeVars`](https://python-all.ru/3.12/library/typing.html#typing.TypeVar). Это недопустимо, поскольку в Annotated должен передаваться только один тип.11911192По умолчанию [`get_type_hints()`](https://python-all.ru/3.12/library/typing.html#typing.get_type_hints) удаляет метаданные из аннотаций. Передайте `include_extras=True`, чтобы сохранить метаданные:11931194> ```pycon1195> >>> from typing import Annotated, get_type_hints1196> >>> def func(x: Annotated[int, "metadata"]) -> None: pass1197> ...1198> >>> get_type_hints(func)1199> {'x': <class 'int'>, 'return': <class 'NoneType'>}1200> >>> get_type_hints(func, include_extras=True)1201> {'x': typing.Annotated[int, 'metadata'], 'return': <class 'NoneType'>}1202> ```12031204Во время выполнения метаданные, связанные с типом `Annotated`, можно получить через атрибут `__metadata__`:12051206> ```pycon1207> >>> from typing import Annotated1208> >>> X = Annotated[int, "very", "important", "metadata"]1209> >>> X1210> typing.Annotated[int, 'very', 'important', 'metadata']1211> >>> X.__metadata__1212> ('very', 'important', 'metadata')1213> ```12141215Чтобы получить исходный тип, обёрнутый `Annotated`, используйте атрибут `__origin__`:12161217> ```pycon1218> >>> from typing import Annotated, get_origin1219> >>> Password = Annotated[str, "secret"]1220> >>> Password.__origin__1221> <class 'str'>1222> ```12231224Обратите внимание, что использование [`get_origin()`](https://python-all.ru/3.12/library/typing.html#typing.get_origin) вернёт сам `Annotated`:12251226> ```pycon1227> >>> get_origin(Password)1228> <class 'typing.Annotated'>1229> ```12301231> **См. также**1232>1233> **[**PEP 593**](https://python-all.ru/3.12/library/typing.html) – Гибкие аннотации функций и переменных**1234>1235> PEP, вводящий `Annotated` в стандартную библиотеку.12361237Добавлено в версии 3.9.12381239#### `typing.TypeGuard`12401241Специальная конструкция типов для пометки пользовательских функций-охранников типа.12421243`TypeGuard` можно использовать для аннотации возвращаемого типа пользовательской функции-охранника типа. `TypeGuard` принимает только один аргумент типа. Во время выполнения функции, отмеченные таким образом, должны возвращать логическое значение.12441245`TypeGuard` направлен на использование *сужения типа* – метода, используемого статическими проверками типов для определения более точного типа выражения в потоке кода программы. Обычно сужение типа выполняется путем анализа условного потока кода и применения сужения к блоку кода. Условное выражение в этом случае иногда называют «охранником типа»:12461247```python1248def is_str(val: str | float):1249    # защита типа "isinstance"1250    if isinstance(val, str):1251        # Тип ``val`` сужается до ``str``1252        ...1253    else:1254        # Иначе тип ``val`` сужается до ``float``.1255        ...1256```12571258Иногда бывает удобно использовать пользовательскую логическую функцию в качестве охранника типа. Такая функция должна использовать `TypeGuard[...]` в качестве своего возвращаемого типа, чтобы предупредить статические проверки типов об этом намерении.12591260Использование `-> TypeGuard` сообщает статическому анализатору типов, что для данной функции:126112621. Возвращаемое значение – boolean.12632. Если возвращаемое значение – `True`, то тип аргумента – это тип внутри `TypeGuard`.12641265Например:12661267```python1268def is_str_list(val: list[object]) -> TypeGuard[list[str]]:1269    '''Определяет, все ли объекты в списке являются строками'''1270    return all(isinstance(x, str) for x in val)12711272def func1(val: list[object]):1273    if is_str_list(val):1274        # Тип ``val`` сужается до ``list[str]``.1275        print(" ".join(val))1276    else:1277        # Тип ``val`` остаётся как ``list[object]``.1278        print("Not a list of strings!")1279```12801281Если `is_str_list` является методом класса или экземпляра, то тип в `TypeGuard` соответствует типу второго параметра (после `cls` или `self`).12821283Короче говоря, форма `def foo(arg: TypeA) -> TypeGuard[TypeB]: ...` означает, что если `foo(arg)` возвращает `True`, то `arg` сужается с `TypeA` до `TypeB`.12841285> **Примечание**1286>1287> `TypeB` не обязательно должен быть более узкой формой `TypeA` – он может быть даже более широкой формой. Основная причина – допускать такие ситуации, как сужение `list[object]` до `list[str]`, даже если последний не является подтипом первого, поскольку `list` инвариантен. Ответственность за написание типобезопасных охранников типа возлагается на пользователя.12881289`TypeGuard` также работает с переменными типа. См. [**PEP 647**](https://python-all.ru/3.12/library/typing.html) для подробностей.12901291Добавлено в версии 3.10.12921293#### `typing.Unpack`12941295Оператор typing для концептуальной пометки объекта как распакованного.12961297Например, использование оператора распаковки `*` для [кортежа переменных типа](https://python-all.ru/3.12/library/typing.html#typevartuple) эквивалентно использованию `Unpack`, чтобы пометить кортеж переменных типа как распакованный:12981299```python1300Ts = TypeVarTuple('Ts')1301tup: tuple[*Ts]1302# Фактически делает:1303tup: tuple[Unpack[Ts]]1304```13051306На самом деле, `Unpack` и `*` можно использовать взаимозаменяемо в контексте типов [`typing.TypeVarTuple`](https://python-all.ru/3.12/library/typing.html#typing.TypeVarTuple) и [`builtins.tuple`](https://python-all.ru/3.12/library/stdtypes.html#tuple). В старых версиях Python можно встретить явное использование `Unpack`, когда `*` нельзя было применять в определённых местах:13071308```python1309# В старых версиях Python TypeVarTuple и Unpack1310# находятся в пакете обратной совместимости `typing_extensions`.1311from typing_extensions import TypeVarTuple, Unpack13121313Ts = TypeVarTuple('Ts')1314tup: tuple[*Ts]         # Синтаксическая ошибка на Python <= 3.10!1315tup: tuple[Unpack[Ts]]  # Семантически эквивалентно и обратно совместимо1316```13171318`Unpack` также можно использовать вместе с [`typing.TypedDict`](https://python-all.ru/3.12/library/typing.html#typing.TypedDict) для типизации `**kwargs` в сигнатуре функции:13191320```python1321from typing import TypedDict, Unpack13221323class Movie(TypedDict):1324    name: str1325    year: int13261327# Эта функция ожидает два именованных аргумента: `name` типа `str`1328# и `year` типа `int`.1329def foo(**kwargs: Unpack[Movie]): ...1330```13311332Подробнее об использовании `Unpack` для типизации `**kwargs` см. в [**PEP 692**](https://python-all.ru/3.12/library/typing.html).13331334Добавлено в версии 3.12.13351336#### Построение обобщённых типов и псевдонимов типов13371338Следующие классы не следует использовать непосредственно в качестве аннотаций. Их предназначение – быть строительными блоками для создания обобщённых типов и псевдонимов типов.13391340Эти объекты можно создавать с помощью специального синтаксиса ([списки параметров типов](https://python-all.ru/3.12/reference/compound_stmts.html#type-params) и оператора [`type`](https://python-all.ru/3.12/reference/simple_stmts.html#type)). Для совместимости с Python 3.11 и более ранними версиями их также можно создавать без специального синтаксиса, как описано ниже.13411342#### `class typing.Generic`13431344Абстрактный базовый класс для обобщённых типов.13451346Обобщённый тип обычно объявляется добавлением списка параметров типа после имени класса:13471348```python1349class Mapping[KT, VT]:1350    def __getitem__(self, key: KT) -> VT:1351        ...1352        # И т.д.1353```13541355Такой класс неявно наследуется от `Generic`. Семантика этого синтаксиса во время выполнения обсуждается в [Справочнике по языку](https://python-all.ru/3.12/reference/compound_stmts.html#generic-classes).13561357Затем этот класс можно использовать следующим образом:13581359```python1360def lookup_name[X, Y](mapping: Mapping[X, Y], key: X, default: Y) -> Y:1361    try:1362        return mapping[key]1363    except KeyError:1364        return default1365```13661367Здесь квадратные скобки после имени функции указывают на [обобщённую функцию](https://python-all.ru/3.12/reference/compound_stmts.html#generic-functions).13681369Для обратной совместимости обобщённые классы также можно объявлять явным наследованием от `Generic`. В этом случае параметры типа должны быть объявлены отдельно:13701371```python1372KT = TypeVar('KT')1373VT = TypeVar('VT')13741375class Mapping(Generic[KT, VT]):1376    def __getitem__(self, key: KT) -> VT:1377        ...1378        # И т.д.1379```13801381#### `class typing.TypeVar(name, *constraints, bound=None, covariant=False, contravariant=False, infer_variance=False)`13821383Переменная типа.13841385Предпочтительный способ создания переменной типа – специальный синтаксис для [обобщённых функций](https://python-all.ru/3.12/reference/compound_stmts.html#generic-functions), [обобщённых классов](https://python-all.ru/3.12/reference/compound_stmts.html#generic-classes) и [обобщённых псевдонимов типов](https://python-all.ru/3.12/reference/compound_stmts.html#generic-type-aliases):13861387```python1388class Sequence[T]:  # T – это TypeVar1389    ...1390```13911392Этот синтаксис также можно использовать для создания переменных типа с границей и ограничениями:13931394```python1395class StrSequence[S: str]:  # S – это TypeVar с верхней границей `str`;1396    ...                     # можно сказать, что S "ограничен `str`"13971398class StrOrBytesSequence[A: (str, bytes)]:  # A – это TypeVar, ограниченный str или bytes1399    ...1400```14011402Однако при желании переиспользуемые переменные типа можно создавать и вручную, например так:14031404```python1405T = TypeVar('T')  # Может быть чем угодно1406S = TypeVar('S', bound=str)  # Может быть любым подтипом str1407A = TypeVar('A', str, bytes)  # Должно быть ровно str или bytes1408```14091410Переменные типа существуют в первую очередь для статических проверок типов. Они служат параметрами для обобщённых типов, а также для определений обобщённых функций и псевдонимов типов. Дополнительную информацию об обобщённых типах см. в [`Generic`](https://python-all.ru/3.12/library/typing.html#typing.Generic). Обобщённые функции работают следующим образом:14111412```python1413def repeat[T](x: T, n: int) -> Sequence[T]:1414    """Возвращает список, содержащий n ссылок на x."""1415    return [x]*n14161417def print_capitalized[S: str](x: S) -> S:1418    """Печатает x с заглавной буквы и возвращает x."""1419    print(x.capitalize())1420    return x14211422def concatenate[A: (str, bytes)](x: A, y: A) -> A:1423    """Складывает две строки или два объекта bytes."""1424    return x + y1425```14261427Обратите внимание, что переменные типа могут быть с *границей*, с *ограничениями* или ни с тем, ни с другим, но не могут быть одновременно и с границей, *и* с ограничениями.14281429Вариантность переменных типа выводится проверщиками типов, когда они создаются через [синтаксис параметров типа](https://python-all.ru/3.12/reference/compound_stmts.html#type-params) или когда передаётся `infer_variance=True`. Вручную созданные переменные типа могут быть явно помечены как ковариантные или контравариантные передачей `covariant=True` или `contravariant=True`. По умолчанию вручную созданные переменные типа инвариантны. Подробнее см. в [**PEP 484**](https://python-all.ru/3.12/library/typing.html) и [**PEP 695**](https://python-all.ru/3.12/library/typing.html).14301431Переменные типа с границей и с ограничениями имеют разную семантику в нескольких важных аспектах. Использование переменной типа с *границей* означает, что `TypeVar` будет выведен как наиболее конкретный возможный тип:14321433```python1434x = print_capitalized('a string')1435reveal_type(x)  # выявленный тип – str14361437class StringSubclass(str):1438    pass14391440y = print_capitalized(StringSubclass('another string'))1441reveal_type(y)  # раскрытый тип – StringSubclass14421443z = print_capitalized(45)  # ошибка: int не является подтипом str1444```14451446Верхней границей переменной типа может быть конкретный тип, абстрактный тип (ABC или протокол) или даже объединение типов:14471448```python1449# Может быть чем угодно с методом __abs__1450def print_abs[T: SupportsAbs](arg: T) -> None:1451    print("Absolute value:", abs(arg))14521453U = TypeVar('U', bound=str|bytes)  # Может быть любым подтипом объединения str|bytes1454V = TypeVar('V', bound=SupportsAbs)  # Может быть чем угодно с методом __abs__1455```14561457Однако использование переменной типа с *ограничениями* означает, что `TypeVar` может быть выведен только как один из заданных ограничений:14581459```python1460a = concatenate('one', 'two')1461reveal_type(a)  # выявленный тип – str14621463b = concatenate(StringSubclass('one'), StringSubclass('two'))1464reveal_type(b)  # выявленный тип – str, несмотря на то что передан StringSubclass14651466c = concatenate('one', b'two')  # ошибка: типовая переменная 'A' может быть либо str, либо bytes в вызове функции, но не обоими одновременно1467```14681469Во время выполнения `isinstance(x, T)` вызовет [`TypeError`](https://python-all.ru/3.12/library/exceptions.html#TypeError).14701471#### `__name__`14721473Имя переменной типа.14741475#### `__covariant__`14761477Является ли переменная типа явно помеченной как ковариантная.14781479#### `__contravariant__`14801481Является ли переменная типа явно помеченной как контравариантная.14821483#### `__infer_variance__`14841485Должна ли вариативность переменной типа выводиться средствами проверки типов.14861487Добавлено в версии 3.12.14881489#### `__bound__`14901491Верхняя граница переменной типа, если она задана.14921493Изменено в версии 3.12: Для переменных типа, созданных с помощью [синтаксиса параметров типа](https://python-all.ru/3.12/reference/compound_stmts.html#type-params), граница вычисляется только при обращении к атрибуту, а не при создании переменной типа (см. [Ленивое вычисление](https://python-all.ru/3.12/reference/executionmodel.html#lazy-evaluation)).14941495#### `__constraints__`14961497Кортеж, содержащий ограничения переменной типа, если они есть.14981499Изменено в версии 3.12: Для переменных типа, созданных с помощью [синтаксиса параметров типа](https://python-all.ru/3.12/reference/compound_stmts.html#type-params), ограничения вычисляются только при обращении к атрибуту, а не при создании переменной типа (см. [Ленивое вычисление](https://python-all.ru/3.12/reference/executionmodel.html#lazy-evaluation)).15001501Изменено в версии 3.12: Переменные типа теперь можно объявлять с помощью синтаксиса [параметров типа](https://python-all.ru/3.12/reference/compound_stmts.html#type-params), введённого в [**PEP 695**](https://python-all.ru/3.12/library/typing.html). Был добавлен параметр `infer_variance`.15021503#### `class typing.TypeVarTuple(name)`15041505Кортежная переменная типа. Специализированная форма [переменной типа](https://python-all.ru/3.12/library/typing.html#typevar), которая позволяет использовать *вариативные* обобщения.15061507Кортежные переменные типа можно объявлять в [списках параметров типа](https://python-all.ru/3.12/reference/compound_stmts.html#type-params) с помощью одной звёздочки (`*`) перед именем:15081509```python1510def move_first_element_to_last[T, *Ts](tup: tuple[T, *Ts]) -> tuple[*Ts, T]:1511    return (*tup[1:], tup[0])1512```15131514Или явным вызовом конструктора `TypeVarTuple`:15151516```python1517T = TypeVar("T")1518Ts = TypeVarTuple("Ts")15191520def move_first_element_to_last(tup: tuple[T, *Ts]) -> tuple[*Ts, T]:1521    return (*tup[1:], tup[0])1522```15231524Обычная переменная типа позволяет параметризацию одним типом. Кортежная переменная типа, напротив, позволяет параметризацию *произвольным* количеством типов, действуя как *произвольное* количество переменных типа, упакованных в кортеж. Например:15251526```python1527# T привязан к int, Ts привязан к ()1528# Возвращаемое значение – (1,), тип которого tuple[int]1529move_first_element_to_last(tup=(1,))15301531# T привязан к int, Ts привязан к (str,)1532# Возвращаемое значение – ('spam', 1), тип которого tuple[str, int]1533move_first_element_to_last(tup=(1, 'spam'))15341535# T привязан к int, Ts привязан к (str, float)1536# Возвращаемое значение – ('spam', 3.0, 1), тип которого tuple[str, float, int]1537move_first_element_to_last(tup=(1, 'spam', 3.0))15381539# Это не проходит проверку типов (и завершается ошибкой во время выполнения)1540# потому что tuple[()] несовместим с tuple[T, *Ts]1541# (требуется хотя бы один элемент)1542move_first_element_to_last(tup=())1543```15441545Обратите внимание на использование оператора распаковки `*` в `tuple[T, *Ts]`. Концептуально можно представить `Ts` как кортеж переменных типа `(T1, T2, ...)`. Тогда `tuple[T, *Ts]` станет `tuple[T, *(T1, T2, ...)]`, что эквивалентно `tuple[T, T1, T2, ...]`. (Обратите внимание, что в более старых версиях Python это могло быть записано с использованием [`Unpack`](https://python-all.ru/3.12/library/typing.html#typing.Unpack), например, `Unpack[Ts]`.)15461547Кортежные переменные типа *всегда* должны быть распакованы. Это помогает отличать кортежные переменные типа от обычных:15481549```python1550x: Ts          # Недействительно1551x: tuple[Ts]   # Недействительно1552x: tuple[*Ts]  # Правильный способ сделать это1553```15541555Кортежные переменные типа можно использовать в тех же контекстах, что и обычные переменные типа. Например, в определениях классов, аргументах и возвращаемых типах:15561557```python1558class Array[*Shape]:1559    def __getitem__(self, key: tuple[*Shape]) -> float: ...1560    def __abs__(self) -> "Array[*Shape]": ...1561    def get_shape(self) -> tuple[*Shape]: ...1562```15631564Кортежные переменные типа можно без проблем комбинировать с обычными переменными типа:15651566```python1567class Array[DType, *Shape]:  # Это нормально1568    pass15691570class Array2[*Shape, DType]:  # Это тоже нормально1571    pass15721573class Height: ...1574class Width: ...15751576float_array_1d: Array[float, Height] = Array()     # Совершенно нормально1577int_array_2d: Array[int, Height, Width] = Array()  # Да, тоже нормально1578```15791580Однако обратите внимание, что в одном списке аргументов типа или параметров типа может присутствовать не более одной кортежной переменной типа:15811582```python1583x: tuple[*Ts, *Ts]            # Недействительно1584class Array[*Shape, *Shape]:  # Недействительно1585    pass1586```15871588Наконец, распакованная кортежная переменная типа может использоваться в качестве аннотации типа для `*args`:15891590```python1591def call_soon[*Ts](1592    callback: Callable[[*Ts], None],1593    *args: *Ts1594) -> None:1595    ...1596    callback(*args)1597```15981599В отличие от нераспакованных аннотаций `*args`, например `*args: int`, которые указывают, что *все* аргументы имеют тип `int`, `*args: *Ts` позволяет ссылаться на типы *отдельных* аргументов в `*args`. Здесь это позволяет нам убедиться, что типы `*args`, передаваемых в `call_soon`, соответствуют типам (позиционных) аргументов `callback`.16001601Подробнее о кортежах переменных типа см. в [**PEP 646**](https://python-all.ru/3.12/library/typing.html).16021603#### `__name__`16041605Имя кортежа переменных типа.16061607Добавлено в версии 3.12.16081609Changed in version 3.12: Type variable tuples can now be declared using the [type parameter](https://python-all.ru/3.12/reference/compound_stmts.html#type-params) syntax introduced by [**PEP 695**](https://python-all.ru/3.12/library/typing.html).16101611#### `class typing.ParamSpec(name, *, bound=None, covariant=False, contravariant=False)`16121613Переменная спецификации параметров. Специализированная версия [переменных типа](https://python-all.ru/3.12/library/typing.html#typevar).16141615В [списках параметров типа](https://python-all.ru/3.12/reference/compound_stmts.html#type-params) спецификации параметров можно объявлять с двумя звёздочками (`**`):16161617```python1618type IntFunc[**P] = Callable[P, int]1619```16201621Для совместимости с Python 3.11 и более ранними версиями объекты `ParamSpec` можно также создавать следующим образом:16221623```python1624P = ParamSpec('P')1625```16261627Переменные спецификации параметров существуют в первую очередь для статических проверок типов. Они используются для передачи типов параметров одного вызываемого объекта другому вызываемому объекту – шаблон, часто встречающийся в функциях высшего порядка и декораторах. Они допустимы только при использовании в `Concatenate`, или как первый аргумент `Callable`, или как параметры пользовательских обобщённых типов (Generics). См. [`Generic`](https://python-all.ru/3.12/library/typing.html#typing.Generic) для получения дополнительной информации об обобщённых типах.16281629Например, чтобы добавить базовое логирование в функцию, можно создать декоратор `add_logging` для логирования вызовов функций. Переменная спецификации параметров сообщает проверяющему типы, что вызываемый объект, переданный в декоратор, и новый вызываемый объект, возвращаемый им, имеют взаимозависимые параметры типа:16301631```python1632from collections.abc import Callable1633import logging16341635def add_logging[T, **P](f: Callable[P, T]) -> Callable[P, T]:1636    '''Типобезопасный декоратор для добавления логирования в функцию.'''1637    def inner(*args: P.args, **kwargs: P.kwargs) -> T:1638        logging.info(f'{f.__name__} was called')1639        return f(*args, **kwargs)1640    return inner16411642@add_logging1643def add_two(x: float, y: float) -> float:1644    '''Складывает два числа.'''1645    return x + y1646```16471648Без `ParamSpec` ранее самый простой способ аннотировать это заключался в использовании [`TypeVar`](https://python-all.ru/3.12/library/typing.html#typing.TypeVar) с верхней границей `Callable[..., Any]`. Однако это вызывает две проблемы:164916501. Проверяющий типы не может проверить типы функции `inner`, потому что `*args` и `**kwargs` должны быть типизированы как [`Any`](https://python-all.ru/3.12/library/typing.html#typing.Any).16512. [`cast()`](https://python-all.ru/3.12/library/typing.html#typing.cast) может потребоваться в теле декоратора `add_logging` при возврате функции `inner`, или статической проверке типов нужно указать игнорировать `return inner`.16521653#### `args`16541655#### `kwargs`16561657Поскольку `ParamSpec` захватывает как позиционные, так и ключевые параметры, `P.args` и `P.kwargs` можно использовать для разделения `ParamSpec` на составляющие. `P.args` представляет кортеж позиционных параметров в заданном вызове и должен использоваться только для аннотации `*args`. `P.kwargs` представляет отображение ключевых параметров на их значения в заданном вызове и должен использоваться только для аннотации `**kwargs`. Оба атрибута требуют, чтобы аннотируемый параметр находился в области видимости. Во время выполнения `P.args` и `P.kwargs` являются экземплярами соответственно [`ParamSpecArgs`](https://python-all.ru/3.12/library/typing.html#typing.ParamSpecArgs) и [`ParamSpecKwargs`](https://python-all.ru/3.12/library/typing.html#typing.ParamSpecKwargs).16581659#### `__name__`16601661Имя спецификации параметров.16621663Переменные спецификации параметров, созданные с помощью `covariant=True` или `contravariant=True`, можно использовать для объявления ковариантных или контравариантных обобщённых типов. Аргумент `bound` также принимается, как и в [`TypeVar`](https://python-all.ru/3.12/library/typing.html#typing.TypeVar). Однако фактическая семантика этих ключевых слов ещё не определена.16641665Добавлено в версии 3.10.16661667Изменено в версии 3.12: Спецификации параметров теперь можно объявлять с помощью синтаксиса [type parameter](https://python-all.ru/3.12/reference/compound_stmts.html#type-params), введённого в [**PEP 695**](https://python-all.ru/3.12/library/typing.html).16681669> **Примечание**1670>1671> Только переменные спецификации параметров, определённые в глобальной области видимости, могут быть pickled.16721673> **См. также**1674>1675> - [**PEP 612**](https://python-all.ru/3.12/library/typing.html) – Переменные спецификации параметров (PEP, в котором были введены `ParamSpec` и `Concatenate`)1676> - [`Concatenate`](https://python-all.ru/3.12/library/typing.html#typing.Concatenate)1677> - [Аннотация вызываемых объектов](https://python-all.ru/3.12/library/typing.html#annotating-callables)16781679#### `typing.ParamSpecArgs`16801681#### `typing.ParamSpecKwargs`16821683Атрибуты аргументов и именованных аргументов (keyword arguments) объекта [`ParamSpec`](https://python-all.ru/3.12/library/typing.html#typing.ParamSpec). Атрибут `P.args` объекта `ParamSpec` является экземпляром `ParamSpecArgs`, а `P.kwargs` – экземпляром `ParamSpecKwargs`. Они предназначены для интроспекции во время выполнения и не имеют особого значения для статических проверяющих типы.16841685Вызов [`get_origin()`](https://python-all.ru/3.12/library/typing.html#typing.get_origin) для любого из этих объектов вернёт исходный `ParamSpec`:16861687```pycon1688>>> from typing import ParamSpec, get_origin1689>>> P = ParamSpec("P")1690>>> get_origin(P.args) is P1691True1692>>> get_origin(P.kwargs) is P1693True1694```16951696Добавлено в версии 3.10.16971698#### `class typing.TypeAliasType(name, value, *, type_params=())`16991700Тип псевдонимов типов, созданных с помощью оператора [`type`](https://python-all.ru/3.12/reference/simple_stmts.html#type).17011702Пример:17031704```pycon1705>>> type Alias = int1706>>> type(Alias)1707<class 'typing.TypeAliasType'>1708```17091710Добавлено в версии 3.12.17111712#### `__name__`17131714Имя псевдонима типа:17151716```pycon1717>>> type Alias = int1718>>> Alias.__name__1719'Alias'1720```17211722#### `__module__`17231724Модуль, в котором был определён псевдоним типа:17251726```python1727>>> type Alias = int1728>>> Alias.__module__1729'__main__'1730```17311732#### `__type_params__`17331734Параметры типа псевдонима типа или пустой кортеж, если псевдоним не является обобщённым (generic):17351736```pycon1737>>> type ListOrSet[T] = list[T] | set[T]1738>>> ListOrSet.__type_params__1739(T,)1740>>> type NotGeneric = int1741>>> NotGeneric.__type_params__1742()1743```17441745#### `__value__`17461747Значение псевдонима типа. Оно [вычисляется лениво](https://python-all.ru/3.12/reference/executionmodel.html#lazy-evaluation), поэтому имена, используемые в определении псевдонима, не разрешаются до тех пор, пока не будет получен доступ к атрибуту `__value__`:17481749```pycon1750>>> type Mutually = Recursive1751>>> type Recursive = Mutually1752>>> Mutually1753Mutually1754>>> Recursive1755Recursive1756>>> Mutually.__value__1757Recursive1758>>> Recursive.__value__1759Mutually1760```17611762#### Другие специальные директивы17631764Эти функции и классы не следует использовать напрямую в качестве аннотаций. Их предназначение – быть строительными блоками для создания и объявления типов.17651766#### `class typing.NamedTuple`17671768Типизированная версия [`collections.namedtuple()`](https://python-all.ru/3.12/library/collections.html#collections.namedtuple).17691770Использование:17711772```python1773class Employee(NamedTuple):1774    name: str1775    id: int1776```17771778Это эквивалентно:17791780```python1781Employee = collections.namedtuple('Employee', ['name', 'id'])1782```17831784Чтобы задать полю значение по умолчанию, можно присвоить его в теле класса:17851786```python1787class Employee(NamedTuple):1788    name: str1789    id: int = 317901791employee = Employee('Guido')1792assert employee.id == 31793```17941795Поля со значением по умолчанию должны следовать после полей без значения по умолчанию.17961797Полученный класс имеет дополнительный атрибут `__annotations__`, который содержит словарь, отображающий имена полей на их типы. (Имена полей находятся в атрибуте `_fields`, а значения по умолчанию – в атрибуте `_field_defaults`; оба они являются частью API [`namedtuple()`](https://python-all.ru/3.12/library/collections.html#collections.namedtuple).)17981799Подклассы `NamedTuple` также могут иметь докстринги и методы:18001801```python1802class Employee(NamedTuple):1803    """Представляет сотрудника."""1804    name: str1805    id: int = 318061807    def __repr__(self) -> str:1808        return f'<Employee {self.name}, id={self.id}>'1809```18101811Подклассы `NamedTuple` могут быть обобщёнными (generic):18121813```python1814class Group[T](NamedTuple):1815    key: T1816    group: list[T]1817```18181819Обратно совместимое использование:18201821```python1822# Для создания обобщённого NamedTuple в Python 3.111823T = TypeVar("T")18241825class Group(NamedTuple, Generic[T]):1826    key: T1827    group: list[T]18281829# Также поддерживается функциональный синтаксис1830Employee = NamedTuple('Employee', [('name', str), ('id', int)])1831```18321833Изменено в версии 3.6: Добавлена поддержка синтаксиса аннотации переменных [**PEP 526**](https://python-all.ru/3.12/library/typing.html).18341835Изменено в версии 3.6.1: Добавлена поддержка значений по умолчанию, методов и строк документации.18361837Изменено в версии 3.8: Атрибуты `_field_types` и `__annotations__` теперь являются обычными словарями, а не экземплярами `OrderedDict`.18381839Изменено в версии 3.9: Атрибут `_field_types` удалён в пользу более стандартного атрибута `__annotations__`, который содержит ту же информацию.18401841Изменено в версии 3.11: Добавлена поддержка обобщённых именованных кортежей (generic namedtuples).18421843#### `class typing.NewType(name, tp)`18441845Вспомогательный класс для создания [отдельных типов с низкими накладными расходами](https://python-all.ru/3.12/library/typing.html#distinct).18461847`NewType` считается отдельным типом для проверщика типов. Однако во время выполнения вызов `NewType` возвращает свой аргумент без изменений.18481849Использование:18501851```python1852UserId = NewType('UserId', int)  # Объявить NewType "UserId"1853first_user = UserId(1)  # "UserId" возвращает аргумент без изменений во время выполнения1854```18551856#### `__module__`18571858Модуль, в котором определён новый тип.18591860#### `__name__`18611862Имя нового типа.18631864#### `__supertype__`18651866Тип, на котором основан новый тип.18671868Добавлено в версии 3.5.2.18691870Изменено в версии 3.10: `NewType` теперь является классом, а не функцией.18711872#### `class typing.Protocol(Generic)`18731874Базовый класс для протокольных классов.18751876Протокольные классы определяются следующим образом:18771878```python1879class Proto(Protocol):1880    def meth(self) -> int:1881        ...1882```18831884Такие классы в основном используются со статическими проверяющими типов, которые распознают структурную подтипизацию (статическую утиную типизацию), например:18851886```python1887class C:1888    def meth(self) -> int:1889        return 018901891def func(x: Proto) -> int:1892    return x.meth()18931894func(C())  # Проходит статическую проверку типов1895```18961897См. [**PEP 544**](https://python-all.ru/3.12/library/typing.html) для получения дополнительных сведений. Классы-протоколы, декорированные [`runtime_checkable()`](https://python-all.ru/3.12/library/typing.html#typing.runtime_checkable) (описано далее), действуют как простые протоколы времени выполнения, которые проверяют только наличие заданных атрибутов, игнорируя их сигнатуры типов.18981899Протокольные классы могут быть обобщёнными, например:19001901```python1902class GenProto[T](Protocol):1903    def meth(self) -> T:1904        ...1905```19061907В коде, который должен быть совместим с Python 3.11 или более старыми версиями, обобщённые протоколы можно записать следующим образом:19081909```python1910T = TypeVar("T")19111912class GenProto(Protocol[T]):1913    def meth(self) -> T:1914        ...1915```19161917Добавлено в версии 3.8.19181919#### `@typing.runtime_checkable`19201921Помечает протокольный класс как протокол времени выполнения.19221923Такой протокол может использоваться с [`isinstance()`](https://python-all.ru/3.12/library/functions.html#isinstance) и [`issubclass()`](https://python-all.ru/3.12/library/functions.html#issubclass). При применении к классу, не являющемуся протоколом, возникает [`TypeError`](https://python-all.ru/3.12/library/exceptions.html#TypeError). Это позволяет выполнять простую структурную проверку, очень похожую на “one trick ponies” в [`collections.abc`](https://python-all.ru/3.12/library/collections.abc.html#module-collections.abc), таких как [`Iterable`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.Iterable). Например:19241925```python1926@runtime_checkable1927class Closable(Protocol):1928    def close(self): ...19291930assert isinstance(open('/some/file'), Closable)19311932@runtime_checkable1933class Named(Protocol):1934    name: str19351936import threading1937assert isinstance(threading.Thread(name='Bob'), Named)1938```19391940> **Примечание**1941>1942> `runtime_checkable()` будет проверять только наличие требуемых методов или атрибутов, но не их сигнатуры типов или сами типы. Например, [`ssl.SSLObject`](https://python-all.ru/3.12/library/ssl.html#ssl.SSLObject) является классом, поэтому он проходит проверку [`issubclass()`](https://python-all.ru/3.12/library/functions.html#issubclass) на соответствие [Callable](https://python-all.ru/3.12/library/typing.html#annotating-callables). Однако метод `ssl.SSLObject.__init__` существует только для того, чтобы вызвать [`TypeError`](https://python-all.ru/3.12/library/exceptions.html#TypeError) с более информативным сообщением, что делает невозможным вызов (создание экземпляра) [`ssl.SSLObject`](https://python-all.ru/3.12/library/ssl.html#ssl.SSLObject).19431944> **Примечание**1945>1946> Проверка [`isinstance()`](https://python-all.ru/3.12/library/functions.html#isinstance) на соответствие протоколу с проверкой во время выполнения может быть удивительно медленной по сравнению с проверкой `isinstance()` для непротокольного класса. Рекомендуется использовать альтернативные идиомы, такие как вызовы [`hasattr()`](https://python-all.ru/3.12/library/functions.html#hasattr) для структурных проверок в коде, чувствительном к производительности.19471948Добавлено в версии 3.8.19491950Изменено в версии 3.12: Внутренняя реализация проверок [`isinstance()`](https://python-all.ru/3.12/library/functions.html#isinstance) на соответствие протоколам, проверяемым во время выполнения, теперь использует [`inspect.getattr_static()`](https://python-all.ru/3.12/library/inspect.html#inspect.getattr_static) для поиска атрибутов (ранее использовался [`hasattr()`](https://python-all.ru/3.12/library/functions.html#hasattr)). В результате некоторые объекты, которые ранее считались экземплярами проверяемого протокола, могут перестать считаться экземплярами этого протокола на Python 3.12+, и наоборот. Большинство пользователей вряд ли затронет это изменение.19511952Изменено в версии 3.12: Члены протокола, проверяемого во время выполнения, теперь считаются «замороженными» во время выполнения сразу после создания класса. Модификация атрибутов такого протокола будет по-прежнему работать, но не повлияет на результаты проверок [`isinstance()`](https://python-all.ru/3.12/library/functions.html#isinstance), сравнивающих объекты с этим протоколом. См. [«Что нового в Python 3.12»](https://python-all.ru/3.12/whatsnew/3.12.html#whatsnew-typing-py312) для получения дополнительных сведений.19531954#### `class typing.TypedDict(dict)`19551956Специальная конструкция для добавления подсказок типов к словарю. Во время выполнения это обычный [`dict`](https://python-all.ru/3.12/library/stdtypes.html#dict).19571958`TypedDict` объявляет тип словаря, который ожидает, что все его экземпляры будут иметь определённый набор ключей, где каждый ключ связан со значением согласованного типа. Это ожидание не проверяется во время выполнения, а обеспечивается только средствами проверки типов. Использование:19591960```python1961class Point2D(TypedDict):1962    x: int1963    y: int1964    label: str19651966a: Point2D = {'x': 1, 'y': 2, 'label': 'good'}  # ОК1967b: Point2D = {'z': 3, 'label': 'bad'}           # Не проходит проверку типов19681969assert Point2D(x=1, y=2, label='first') == dict(x=1, y=2, label='first')1970```19711972Чтобы разрешить использование этой возможности в старых версиях Python, которые не поддерживают [**PEP 526**](https://python-all.ru/3.12/library/typing.html), `TypedDict` поддерживает две дополнительные эквивалентные синтаксические формы:19731974- Использование литерала [`dict`](https://python-all.ru/3.12/library/stdtypes.html#dict) в качестве второго аргумента:19751976  ```python1977  Point2D = TypedDict('Point2D', {'x': int, 'y': int, 'label': str})1978  ```1979- Использование именованных аргументов:19801981  ```python1982  Point2D = TypedDict('Point2D', x=int, y=int, label=str)1983  ```19841985  Устарело с версии 3.11, будет удалено в версии 3.13: Синтаксис именованных аргументов устарел в 3.11 и будет удалён в 3.13. Он также может не поддерживаться статическими проверщиками типов.19861987Этот функциональный синтаксис позволяет определять ключи, которые не являются допустимыми [идентификаторами](https://python-all.ru/3.12/reference/lexical_analysis.html#identifiers), например, потому что они являются ключевыми словами или содержат дефисы, или когда имена ключей не должны быть [искажены](https://python-all.ru/3.12/reference/expressions.html#private-name-mangling), как обычные закрытые имена:19881989```python1990# возбуждает SyntaxError1991class Point2D(TypedDict):1992    in: int  # 'in' – ключевое слово1993    x-y: int  # имя с дефисами19941995class Definition(TypedDict):1996    __schema: str  # искажено до `_Definition__schema`19971998# ОК, функциональный синтаксис1999Point2D = TypedDict('Point2D', {'in': int, 'x-y': int})2000Definition = TypedDict('Definition', {'__schema': str})  # не искажается2001```20022003По умолчанию все ключи должны присутствовать в `TypedDict`. Можно пометить отдельные ключи как необязательные с помощью [`NotRequired`](https://python-all.ru/3.12/library/typing.html#typing.NotRequired):20042005```python2006class Point2D(TypedDict):2007    x: int2008    y: int2009    label: NotRequired[str]20102011# Альтернативный синтаксис2012Point2D = TypedDict('Point2D', {'x': int, 'y': int, 'label': NotRequired[str]})2013```20142015Это означает, что `Point2D` `TypedDict` может не содержать ключ `label`.20162017Также можно по умолчанию пометить все ключи как необязательные, указав totality `False`:20182019```python2020class Point2D(TypedDict, total=False):2021    x: int2022    y: int20232024# Альтернативный синтаксис2025Point2D = TypedDict('Point2D', {'x': int, 'y': int}, total=False)2026```20272028Это означает, что `Point2D` `TypedDict` может не содержать любой из ключей. Средство проверки типов должно поддерживать только литерал `False` или `True` в качестве значения аргумента `total`. `True` – значение по умолчанию, и оно делает все элементы, определённые в теле класса, обязательными.20292030Отдельные ключи `total=False` `TypedDict` можно пометить как обязательные с помощью [`Required`](https://python-all.ru/3.12/library/typing.html#typing.Required):20312032```python2033class Point2D(TypedDict, total=False):2034    x: Required[int]2035    y: Required[int]2036    label: str20372038# Альтернативный синтаксис2039Point2D = TypedDict('Point2D', {2040    'x': Required[int],2041    'y': Required[int],2042    'label': str2043}, total=False)2044```20452046`TypedDict` может наследоваться от одного или нескольких других типов `TypedDict` с использованием синтаксиса на основе классов. Использование:20472048```python2049class Point3D(Point2D):2050    z: int2051```20522053`Point3D` содержит три элемента: `x`, `y` и `z`. Это эквивалентно следующему определению:20542055```python2056class Point3D(TypedDict):2057    x: int2058    y: int2059    z: int2060```20612062`TypedDict` не может наследоваться от класса, не являющегося `TypedDict`, за исключением [`Generic`](https://python-all.ru/3.12/library/typing.html#typing.Generic). Например:20632064```python2065class X(TypedDict):2066    x: int20672068class Y(TypedDict):2069    y: int20702071class Z(object): pass  # Класс, не являющийся TypedDict20722073class XY(X, Y): pass  # ОК20742075class XZ(X, Z): pass  # вызывает TypeError2076```20772078`TypedDict` может быть обобщённым:20792080```python2081class Group[T](TypedDict):2082    key: T2083    group: list[T]2084```20852086Чтобы создать обобщённый `TypedDict`, совместимый с Python 3.11 и ниже, явно унаследуйтесь от [`Generic`](https://python-all.ru/3.12/library/typing.html#typing.Generic):20872088```python2089T = TypeVar("T")20902091class Group(TypedDict, Generic[T]):2092    key: T2093    group: list[T]2094```20952096`TypedDict` может быть проанализирован с помощью словарей аннотаций (см. [Лучшие практики работы с аннотациями](https://python-all.ru/3.12/howto/annotations.html#annotations-howto) для получения дополнительной информации о лучших практиках работы с аннотациями), [`__total__`](https://python-all.ru/3.12/library/typing.html#typing.TypedDict.__total__), [`__required_keys__`](https://python-all.ru/3.12/library/typing.html#typing.TypedDict.__required_keys__) и [`__optional_keys__`](https://python-all.ru/3.12/library/typing.html#typing.TypedDict.__optional_keys__).20972098#### `__total__`20992100`Point2D.__total__` возвращает значение аргумента `total`. Пример:21012102```pycon2103>>> from typing import TypedDict2104>>> class Point2D(TypedDict): pass2105>>> Point2D.__total__2106True2107>>> class Point2D(TypedDict, total=False): pass2108>>> Point2D.__total__2109False2110>>> class Point3D(Point2D): pass2111>>> Point3D.__total__2112True2113```21142115Этот атрибут отражает *только* значение аргумента `total` текущего класса `TypedDict`, а не то, является ли класс семантически полным. Например, `TypedDict` с `__total__`, равным `True`, может иметь ключи, помеченные [`NotRequired`](https://python-all.ru/3.12/library/typing.html#typing.NotRequired), или наследоваться от другого `TypedDict` с `total=False`. Поэтому для анализа обычно лучше использовать [`__required_keys__`](https://python-all.ru/3.12/library/typing.html#typing.TypedDict.__required_keys__) и [`__optional_keys__`](https://python-all.ru/3.12/library/typing.html#typing.TypedDict.__optional_keys__).21162117#### `__required_keys__`21182119Добавлено в версии 3.9.21202121#### `__optional_keys__`21222123`Point2D.__required_keys__` и `Point2D.__optional_keys__` возвращают объекты [`frozenset`](https://python-all.ru/3.12/library/stdtypes.html#frozenset), содержащие обязательные и необязательные ключи соответственно.21242125Ключи, помеченные [`Required`](https://python-all.ru/3.12/library/typing.html#typing.Required), всегда будут появляться в `__required_keys__`, а ключи, помеченные [`NotRequired`](https://python-all.ru/3.12/library/typing.html#typing.NotRequired), всегда будут появляться в `__optional_keys__`.21262127Для обратной совместимости с Python 3.10 и ниже также можно использовать наследование для объявления как обязательных, так и необязательных ключей в одном `TypedDict`. Это делается путём объявления `TypedDict` с одним значением аргумента `total`, а затем наследования от него в другом `TypedDict` с другим значением для `total`:21282129```pycon2130>>> class Point2D(TypedDict, total=False):2131...     x: int2132...     y: int2133...2134>>> class Point3D(Point2D):2135...     z: int2136...2137>>> Point3D.__required_keys__ == frozenset({'z'})2138True2139>>> Point3D.__optional_keys__ == frozenset({'x', 'y'})2140True2141```21422143Добавлено в версии 3.9.21442145> **Примечание**2146>2147> Если используется `from __future__ import annotations` или аннотации заданы в виде строк, аннотации не вычисляются при определении `TypedDict`. Поэтому анализ во время выполнения, на который полагаются `__required_keys__` и `__optional_keys__`, может работать неправильно, и значения атрибутов могут быть неверными.21482149Смотрите [**PEP 589**](https://python-all.ru/3.12/library/typing.html) для дополнительных примеров и подробных правил использования `TypedDict`.21502151Добавлено в версии 3.8.21522153Изменено в версии 3.11: Добавлена поддержка пометки отдельных ключей как [`Required`](https://python-all.ru/3.12/library/typing.html#typing.Required) или [`NotRequired`](https://python-all.ru/3.12/library/typing.html#typing.NotRequired). См. [**PEP 655**](https://python-all.ru/3.12/library/typing.html).21542155Изменено в версии 3.11: Добавлена поддержка обобщённых `TypedDict`.21562157### Протоколы21582159Следующие протоколы предоставляются модулем typing. Все они декорированы [`@runtime_checkable`](https://python-all.ru/3.12/library/typing.html#typing.runtime_checkable).21602161#### `class typing.SupportsAbs`21622163ABC с одним абстрактным методом `__abs__`, ковариантным по типу возвращаемого значения.21642165#### `class typing.SupportsBytes`21662167ABC с одним абстрактным методом `__bytes__`.21682169#### `class typing.SupportsComplex`21702171ABC с одним абстрактным методом `__complex__`.21722173#### `class typing.SupportsFloat`21742175ABC с одним абстрактным методом `__float__`.21762177#### `class typing.SupportsIndex`21782179ABC с одним абстрактным методом `__index__`.21802181Добавлено в версии 3.8.21822183#### `class typing.SupportsInt`21842185ABC с одним абстрактным методом `__int__`.21862187#### `class typing.SupportsRound`21882189ABC с одним абстрактным методом `__round__` ковариантным по возвращаемому типу.21902191### Абстрактные базовые классы для работы с IO21922193#### `class typing.IO`21942195#### `class typing.TextIO`21962197#### `class typing.BinaryIO`21982199Обобщённый тип `IO[AnyStr]` и его подклассы `TextIO(IO[str])` и `BinaryIO(IO[bytes])` представляют типы потоков ввода-вывода, такие как возвращаемые [`open()`](https://python-all.ru/3.12/library/functions.html#open).22002201### Функции и декораторы22022203#### `typing.cast(typ, val)`22042205Приводит значение к типу.22062207Это возвращает значение без изменений. Для проверщика типов это сигнализирует, что возвращаемое значение имеет указанный тип, но во время выполнения мы намеренно ничего не проверяем (мы хотим, чтобы это было как можно быстрее).22082209#### `typing.assert_type(val, typ, /)`22102211Запросить у статического проверщика типов подтверждение, что *val* имеет выведенный тип *typ*.22122213Во время выполнения эта функция ничего не делает: она возвращает первый аргумент без изменений, без проверок или побочных эффектов, независимо от фактического типа аргумента.22142215Когда статический проверщик типов встречает вызов `assert_type()`, он выдает ошибку, если значение не относится к указанному типу:22162217```python2218def greet(name: str) -> None:2219    assert_type(name, str)  # ОК, выведенный тип `name` – `str`2220    assert_type(name, int)  # ошибка проверки типов2221```22222223Эта функция полезна для проверки того, что понимание скрипта проверщиком типов соответствует намерениям разработчика:22242225```python2226def complex_function(arg: object):2227    # Выполнить сложную логику сужения типа,2228    # после чего ожидается, что выведенный тип станет `int`2229    ...2230    # Проверить, правильно ли проверщик типов понимает нашу функцию2231    assert_type(arg, int)2232```22332234Добавлено в версии 3.12.22352236#### `typing.assert_never(arg, /)`22372238Попросить статический проверщик типов подтвердить, что строка кода недостижима.22392240Пример:22412242```python2243def int_or_str(arg: int | str) -> None:2244    match arg:2245        case int():2246            print("It's an int")2247        case str():2248            print("It's a str")2249        case _ as unreachable:2250            assert_never(unreachable)2251```22522253Здесь аннотации позволяют проверщику типов вывести, что последний случай никогда не выполнится, поскольку `arg` является либо [`int`](https://python-all.ru/3.12/library/functions.html#int), либо [`str`](https://python-all.ru/3.12/library/stdtypes.html#str), и оба варианта уже покрыты предыдущими случаями.22542255Если проверщик типов обнаружит, что вызов `assert_never()` достижим, он выдаст ошибку. Например, если бы аннотация типа для `arg` вместо этого была `int | str | float`, проверщик типов выдал бы ошибку, указывающую, что `unreachable` имеет тип [`float`](https://python-all.ru/3.12/library/functions.html#float). Для того чтобы вызов `assert_never` прошел проверку типов, выведенный тип переданного аргумента должен быть нижним типом [`Never`](https://python-all.ru/3.12/library/typing.html#typing.Never) и ничем иным.22562257Во время выполнения эта функция выбрасывает исключение при вызове.22582259> **См. также**2260>2261> В разделе [Unreachable Code and Exhaustiveness Checking](https://python-all.ru/3.12/library/typing.html) содержится дополнительная информация о проверке полноты с помощью статической типизации.22622263Добавлено в версии 3.12.22642265#### `typing.reveal_type(obj, /)`22662267Попросить статический проверщик типов показать выведенный тип выражения.22682269Когда статический проверщик типов встречает вызов этой функции, он выдает диагностическое сообщение с выведенным типом аргумента. Например:22702271```python2272x: int = 12273reveal_type(x)  # Раскрытый тип – "builtins.int"2274```22752276Это может быть полезно для отладки того, как проверщик типов обрабатывает конкретный фрагмент кода.22772278Во время выполнения эта функция выводит тип аргумента во время выполнения в [`sys.stderr`](https://python-all.ru/3.12/library/sys.html#sys.stderr) и возвращает аргумент без изменений (что позволяет использовать вызов внутри выражения):22792280```python2281x = reveal_type(1)  # выводит «Runtime type is int»2282print(x)  # выводит "1"2283```22842285Обратите внимание, что тип во время выполнения может отличаться от статически выведенного типа (быть более или менее конкретным).22862287Большинство проверщиков типов поддерживают `reveal_type()` в любом месте, даже если имя не импортировано из `typing`. Однако импорт имени из `typing` позволяет коду выполняться без ошибок времени выполнения и более четко выражает намерения.22882289Добавлено в версии 3.12.22902291#### `@typing.dataclass_transform(*, eq_default=True, order_default=False, kw_only_default=False, frozen_default=False, field_specifiers=(), **kwargs)`22922293Декоратор для пометки объекта как предоставляющего поведение, подобное [`dataclass`](https://python-all.ru/3.12/library/dataclasses.html#dataclasses.dataclass).22942295`dataclass_transform` может использоваться для декорирования класса, метакласса или функции, которая сама является декоратором. Наличие `@dataclass_transform()` сообщает статическому проверщику типов, что декорированный объект выполняет во время выполнения «магию», преобразующую класс аналогично [`@dataclasses.dataclass`](https://python-all.ru/3.12/library/dataclasses.html#dataclasses.dataclass).22962297Пример использования с функцией-декоратором:22982299```python2300@dataclass_transform()2301def create_model[T](cls: type[T]) -> type[T]:2302    ...2303    return cls23042305@create_model2306class CustomerModel:2307    id: int2308    name: str2309```23102311На базовом классе:23122313```python2314@dataclass_transform()2315class ModelBase: ...23162317class CustomerModel(ModelBase):2318    id: int2319    name: str2320```23212322На метаклассе:23232324```python2325@dataclass_transform()2326class ModelMeta(type): ...23272328class ModelBase(metaclass=ModelMeta): ...23292330class CustomerModel(ModelBase):2331    id: int2332    name: str2333```23342335Классы `CustomerModel`, определенные выше, будут обрабатываться проверщиками типов аналогично классам, созданным с помощью [`@dataclasses.dataclass`](https://python-all.ru/3.12/library/dataclasses.html#dataclasses.dataclass). Например, проверщики типов будут предполагать, что эти классы имеют методы `__init__`, которые принимают `id` и `name`.23362337Декорированный класс, метакласс или функция могут принимать следующие булевы аргументы, которые, как будет считать проверщик типов, имеют тот же эффект, что и для декоратора [`@dataclasses.dataclass`](https://python-all.ru/3.12/library/dataclasses.html#dataclasses.dataclass): `init`, `eq`, `order`, `unsafe_hash`, `frozen`, `match_args`, `kw_only` и `slots`. Значения этих аргументов (`True` или `False`) должны быть статически вычислимыми.23382339Аргументы декоратора `dataclass_transform` могут использоваться для настройки поведения по умолчанию декорированного класса, метакласса или функции:23402341**Параметры:**23422343- **eq\_default** ([*bool*](https://python-all.ru/3.12/library/functions.html#bool)) – Указывает, предполагается ли параметр `eq` равным `True` или `False`, если он опущен вызывающей стороной. По умолчанию `True`.2344- **order\_default** ([*bool*](https://python-all.ru/3.12/library/functions.html#bool)) – Указывает, предполагается ли параметр `order` равным `True` или `False`, если он опущен вызывающей стороной. По умолчанию `False`.2345- **kw\_only\_default** ([*bool*](https://python-all.ru/3.12/library/functions.html#bool)) – Указывает, предполагается ли параметр `kw_only` равным `True` или `False`, если он опущен вызывающей стороной. По умолчанию `False`.2346- **frozen\_default** ([*bool*](https://python-all.ru/3.12/library/functions.html#bool)) –23472348  Указывает, считается ли параметр `frozen` равным `True` или `False`, если он опущен вызывающей стороной. По умолчанию `False`.23492350  Добавлено в версии 3.12.2351- **field\_specifiers** ([*tuple*](https://python-all.ru/3.12/library/stdtypes.html#tuple)*\[*[*Callable*](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.Callable)*\[**...**,* *Any**\]**,* *...**\]*) – Задаёт статический список поддерживаемых классов или функций, описывающих поля, аналогично [`dataclasses.field()`](https://python-all.ru/3.12/library/dataclasses.html#dataclasses.field). По умолчанию `()`.2352- **\*\*kwargs** (*Any*) – Допускаются произвольные другие именованные аргументы, чтобы обеспечить возможность будущих расширений.23532354Проверщики типов распознают следующие необязательные параметры в спецификаторах полей:23552356| Имя параметра | Описание |2357| --- | --- |2358| `init` | Указывает, должно ли поле быть включено в синтезируемый метод `__init__`. Если не указано, `init` по умолчанию равно `True`. |2359| `default` | Предоставляет значение по умолчанию для поля. |2360| `default_factory` | Предоставляет колбэк времени выполнения, возвращающий значение по умолчанию для поля. Если не указаны ни `default`, ни `default_factory`, считается, что поле не имеет значения по умолчанию, и при создании экземпляра класса для него должно быть предоставлено значение. |2361| `factory` | Псевдоним для параметра `default_factory` в спецификаторах полей. |2362| `kw_only` | Указывает, должно ли поле быть помечено как keyword-only. Если `True`, поле будет keyword-only. Если `False`, оно не будет keyword-only. Если не указано, будет использовано значение параметра `kw_only` объекта, декорированного с помощью `dataclass_transform`, или, если оно не указано, значение `kw_only_default` на `dataclass_transform`. |2363| `alias` | Предоставляет альтернативное имя для поля. Это альтернативное имя используется в синтезируемом методе `__init__`. |23642365Во время выполнения этот декоратор записывает свои аргументы в атрибут `__dataclass_transform__` декорированного объекта. Других эффектов во время выполнения нет.23662367Подробнее см. [**PEP 681**](https://python-all.ru/3.12/library/typing.html).23682369Добавлено в версии 3.12.23702371#### `@typing.overload`23722373Декоратор для создания перегруженных функций и методов.23742375Декоратор `@overload` позволяет описывать функции и методы, поддерживающие несколько различных комбинаций типов аргументов. За серией определений, декорированных `@overload`, должно следовать ровно одно определение, не декорированное `@overload` (для той же функции/метода).23762377Определения, декорированные `@overload`, предназначены только для проверщика типов, поскольку они будут перезаписаны определением, не декорированным `@overload`. Определение, не декорированное `@overload`, в свою очередь, будет использоваться во время выполнения, но должно игнорироваться проверщиком типов. Во время выполнения прямой вызов функции, декорированной `@overload`, вызовет [`NotImplementedError`](https://python-all.ru/3.12/library/exceptions.html#NotImplementedError).23782379Пример перегрузки, которая даёт более точный тип, чем можно выразить с помощью объединения или переменной типа:23802381```python2382@overload2383def process(response: None) -> None:2384    ...2385@overload2386def process(response: int) -> tuple[int, str]:2387    ...2388@overload2389def process(response: bytes) -> str:2390    ...2391def process(response):2392    ...  # здесь находится фактическая реализация2393```23942395Подробнее и сравнение с другими семантиками типизации см. [**PEP 484**](https://python-all.ru/3.12/library/typing.html).23962397Изменено в версии 3.11: Перегруженные функции теперь можно интроспектировать во время выполнения с помощью [`get_overloads()`](https://python-all.ru/3.12/library/typing.html#typing.get_overloads).23982399#### `typing.get_overloads(func)`24002401Возвращает последовательность определений, декорированных [`@overload`](https://python-all.ru/3.12/library/typing.html#typing.overload), для *func*.24022403*func* – это объект функции для реализации перегруженной функции. Например, если дано определение `process` в документации для [`@overload`](https://python-all.ru/3.12/library/typing.html#typing.overload), `get_overloads(process)` вернёт последовательность из трёх объектов функций для трёх определённых перегрузок. Если вызвана для функции без перегрузок, `get_overloads()` возвращает пустую последовательность.24042405`get_overloads()` можно использовать для интроспекции перегруженной функции во время выполнения.24062407Добавлено в версии 3.12.24082409#### `typing.clear_overloads()`24102411Очищает все зарегистрированные перегрузки во внутреннем реестре.24122413Это можно использовать для освобождения памяти, занятой реестром.24142415Добавлено в версии 3.12.24162417#### `@typing.final`24182419Декоратор для указания окончательных методов и окончательных классов.24202421Декорирование метода с помощью `@final` указывает проверщику типов, что метод не может быть переопределён в подклассе. Декорирование класса с помощью `@final` указывает, что от него нельзя наследовать.24222423Например:24242425```python2426class Base:2427    @final2428    def done(self) -> None:2429        ...2430class Sub(Base):2431    def done(self) -> None:  # Ошибка, выдаваемая проверщиком типов2432        ...24332434@final2435class Leaf:2436    ...2437class Other(Leaf):  # Ошибка, выдаваемая проверщиком типов2438    ...2439```24402441Проверка этих свойств во время выполнения не выполняется. Подробнее см. [**PEP 591**](https://python-all.ru/3.12/library/typing.html).24422443Добавлено в версии 3.8.24442445Изменено в версии 3.11: Декоратор теперь будет пытаться установить атрибут `__final__` в значение `True` на декорированном объекте. Таким образом, проверку вида `if getattr(obj, "__final__", False)` можно использовать во время выполнения, чтобы определить, был ли объект `obj` помечен как окончательный (final). Если декорированный объект не поддерживает установку атрибутов, декоратор возвращает объект без изменений, не вызывая исключения.24462447#### `@typing.no_type_check`24482449Декоратор, указывающий, что аннотации не являются подсказками типов.24502451Это работает как [декоратор](https://python-all.ru/3.12/glossary.html#term-decorator) класса или функции. Для класса он применяется рекурсивно ко всем методам и классам, определённым в этом классе (но не к методам, определённым в его суперклассах или подклассах). Средства проверки типов будут игнорировать все аннотации в функции или классе с этим декоратором.24522453`@no_type_check` изменяет декорированный объект на месте.24542455#### `@typing.no_type_check_decorator`24562457Декоратор, придающий другому декоратору эффект [`no_type_check()`](https://python-all.ru/3.12/library/typing.html#typing.no_type_check).24582459Он оборачивает декоратор чем-то, что оборачивает декорированную функцию в [`no_type_check()`](https://python-all.ru/3.12/library/typing.html#typing.no_type_check).24602461#### `@typing.override`24622463Декоратор, указывающий, что метод в подклассе предназначен для переопределения метода или атрибута в суперклассе.24642465Средства проверки типов должны выдавать ошибку, если метод, декорированный `@override`, на самом деле ничего не переопределяет. Это помогает предотвратить ошибки, которые могут возникнуть, когда базовый класс изменяется без соответствующего изменения в дочернем классе.24662467Например:24682469```python2470class Base:2471    def log_status(self) -> None:2472        ...24732474class Sub(Base):2475    @override2476    def log_status(self) -> None:  # ОК: переопределяет Base.log_status2477        ...24782479    @override2480    def done(self) -> None:  # Ошибка, выдаваемая проверщиком типов2481        ...2482```24832484Проверка этого свойства во время выполнения не производится.24852486Декоратор будет пытаться установить атрибут `__override__` в значение `True` на декорированном объекте. Таким образом, проверку вида `if getattr(obj, "__override__", False)` можно использовать во время выполнения, чтобы определить, был ли объект `obj` помечен как переопределение. Если декорированный объект не поддерживает установку атрибутов, декоратор возвращает объект без изменений, не вызывая исключения.24872488См. [**PEP 698**](https://python-all.ru/3.12/library/typing.html) для получения дополнительных сведений.24892490Добавлено в версии 3.12.24912492#### `@typing.type_check_only`24932494Декоратор для пометки класса или функции как недоступных во время выполнения.24952496Сам этот декоратор недоступен во время выполнения. Он в основном предназначен для пометки классов, определённых в файлах заглушек типов (type stub), если реализация возвращает экземпляр закрытого класса:24972498```python2499@type_check_only2500class Response:  # приватный или недоступный во время выполнения2501    code: int2502    def get_header(self, name: str) -> str: ...25032504def fetch_response() -> Response: ...2505```25062507Обратите внимание, что возврат экземпляров закрытых классов не рекомендуется. Обычно предпочтительнее делать такие классы открытыми.25082509### Вспомогательные функции для интроспекции25102511#### `typing.get_type_hints(obj, globalns=None, localns=None, include_extras=False)`25122513Возвращает словарь, содержащий аннотации типов для функции, метода, модуля или объекта класса.25142515Часто это то же самое, что и `obj.__annotations__`, но эта функция вносит следующие изменения в словарь аннотаций:25162517- Прямые ссылки (forward references), закодированные как строковые литералы или объекты [`ForwardRef`](https://python-all.ru/3.12/library/typing.html#typing.ForwardRef), обрабатываются путём вычисления их в пространствах имён *globalns*, *localns* и (где применимо) пространстве имён *obj*’s [параметра типа](https://python-all.ru/3.12/reference/compound_stmts.html#type-params). Если *globalns* или *localns* не заданы, соответствующие словари пространств имён выводятся из *obj*.2518- `None` заменяется на [`types.NoneType`](https://python-all.ru/3.12/library/types.html#types.NoneType).2519- Если к *obj* был применён [`@no_type_check`](https://python-all.ru/3.12/library/typing.html#typing.no_type_check), возвращается пустой словарь.2520- Если *obj* – это класс `C`, функция возвращает словарь, который объединяет аннотации из базовых классов `C` с теми, что указаны непосредственно в `C`. Это делается путём обхода [`C.__mro__`](https://python-all.ru/3.12/reference/datamodel.html#type.__mro__) и последовательного объединения словарей `__annotations__`. Аннотации классов, расположенных раньше в [порядке разрешения методов](https://python-all.ru/3.12/glossary.html#term-method-resolution-order), всегда имеют приоритет над аннотациями классов, расположенных позже в порядке разрешения методов.2521- Функция рекурсивно заменяет все вхождения `Annotated[T, ...]` на `T`, если только *include\_extras* не равен `True` (см. [`Annotated`](https://python-all.ru/3.12/library/typing.html#typing.Annotated) для получения дополнительной информации).25222523См. также [`inspect.get_annotations()`](https://python-all.ru/3.12/library/inspect.html#inspect.get_annotations) – функция более низкого уровня, которая возвращает аннотации более напрямую.25242525> **Примечание**2526>2527> Если какие-либо прямые ссылки (forward references) в аннотациях *obj* не могут быть разрешены или не являются валидным кодом Python, эта функция вызовет исключение [`NameError`](https://python-all.ru/3.12/library/exceptions.html#NameError). Например, это может произойти с импортированными [псевдонимами типов](https://python-all.ru/3.12/library/typing.html#type-aliases), содержащими прямые ссылки, или с именами, импортированными через [`if TYPE_CHECKING`](https://python-all.ru/3.12/library/typing.html#typing.TYPE_CHECKING).25282529Изменено в версии 3.9: Добавлен параметр `include_extras` в рамках [**PEP 593**](https://python-all.ru/3.12/library/typing.html). См. документацию по [`Annotated`](https://python-all.ru/3.12/library/typing.html#typing.Annotated) для получения дополнительных сведений.25302531Изменено в версии 3.11: Ранее `Optional[t]` добавлялась для аннотаций функций и методов, если было установлено значение по умолчанию, равное `None`. Теперь аннотация возвращается без изменений.25322533#### `typing.get_origin(tp)`25342535Возвращает неиндексированную версию типа: для объекта typing вида `X[Y, Z, ...]` возвращает `X`.25362537Если `X` – это псевдоним из модуля typing для встроенного класса или класса [`collections`](https://python-all.ru/3.12/library/collections.html#module-collections), он будет нормализован до исходного класса. Если `X` является экземпляром [`ParamSpecArgs`](https://python-all.ru/3.12/library/typing.html#typing.ParamSpecArgs) или [`ParamSpecKwargs`](https://python-all.ru/3.12/library/typing.html#typing.ParamSpecKwargs), возвращается базовый [`ParamSpec`](https://python-all.ru/3.12/library/typing.html#typing.ParamSpec). Для неподдерживаемых объектов возвращается `None`.25382539Примеры:25402541```python2542assert get_origin(str) is None2543assert get_origin(Dict[str, int]) is dict2544assert get_origin(Union[int, str]) is Union2545assert get_origin(Annotated[str, "metadata"]) is Annotated2546P = ParamSpec('P')2547assert get_origin(P.args) is P2548assert get_origin(P.kwargs) is P2549```25502551Добавлено в версии 3.8.25522553#### `typing.get_args(tp)`25542555Возвращает аргументы типа после выполнения всех подстановок: для объекта typing вида `X[Y, Z, ...]` возвращает `(Y, Z, ...)`.25562557Если `X` является объединением (union) или [`Literal`](https://python-all.ru/3.12/library/typing.html#typing.Literal) содержится в другом обобщённом типе, порядок `(Y, Z, ...)` может отличаться от порядка исходных аргументов `[Y, Z, ...]` из-за кеширования типов. Для неподдерживаемых объектов возвращается `()`.25582559Примеры:25602561```python2562assert get_args(int) == ()2563assert get_args(Dict[int, str]) == (int, str)2564assert get_args(Union[int, str]) == (int, str)2565```25662567Добавлено в версии 3.8.25682569#### `typing.is_typeddict(tp)`25702571Проверяет, является ли тип [`TypedDict`](https://python-all.ru/3.12/library/typing.html#typing.TypedDict).25722573Например:25742575```python2576class Film(TypedDict):2577    title: str2578    year: int25792580assert is_typeddict(Film)2581assert not is_typeddict(list | str)25822583# TypedDict – это фабрика для создания типизированных словарей,2584# а не сам типизированный словарь2585assert not is_typeddict(TypedDict)2586```25872588Добавлено в версии 3.10.25892590#### `class typing.ForwardRef`25912592Класс для внутреннего представления строковых прямых ссылок в typing.25932594Например, `List["SomeClass"]` неявно преобразуется в `List[ForwardRef("SomeClass")]`. `ForwardRef` не должен создаваться пользователем, но может использоваться инструментами интроспекции.25952596> **Примечание**2597>2598> обобщённые типы [**PEP 585**](https://python-all.ru/3.12/library/typing.html), такие как `list["SomeClass"]`, не будут неявно преобразовываться в `list[ForwardRef("SomeClass")]` и, следовательно, не будут автоматически разрешаться в `list[SomeClass]`.25992600Добавлено в версии 3.7.4.26012602### Константа26032604#### `typing.TYPE_CHECKING`26052606Специальная константа, которая, как считается, равна `True` для сторонних статических анализаторов типов. Во время выполнения её значение – `False`.26072608Использование:26092610```python2611if TYPE_CHECKING:2612    import expensive_mod26132614def fun(arg: 'expensive_mod.SomeType') -> None:2615    local_var: expensive_mod.AnotherType = other_fun()2616```26172618Первую аннотацию типа необходимо заключать в кавычки, превращая её в «прямую ссылку» (forward reference), чтобы скрыть ссылку `expensive_mod` от интерпретатора во время выполнения. Аннотации типов для локальных переменных не вычисляются, поэтому вторую аннотацию не нужно заключать в кавычки.26192620> **Примечание**2621>2622> Если используется `from __future__ import annotations`, аннотации не вычисляются во время определения функции. Вместо этого они сохраняются как строки в `__annotations__`. Это избавляет от необходимости заключать аннотацию в кавычки (см. [**PEP 563**](https://python-all.ru/3.12/library/typing.html)).26232624Добавлено в версии 3.5.2.26252626### Устаревшие псевдонимы26272628Этот модуль определяет несколько устаревших псевдонимов для уже существующих классов стандартной библиотеки. Изначально они были включены в модуль typing для поддержки параметризации этих обобщённых классов с помощью `[]`. Однако эти псевдонимы стали избыточными в Python 3.9, когда соответствующие существующие классы были расширены для поддержки `[]` (см. [**PEP 585**](https://python-all.ru/3.12/library/typing.html)).26292630Избыточные типы считаются устаревшими начиная с Python 3.9. Однако, хотя псевдонимы могут быть удалены в какой-то момент, их удаление в настоящее время не планируется. Поэтому в настоящее время интерпретатор не выдаёт предупреждений об устаревании для этих псевдонимов.26312632Если в какой-то момент будет принято решение удалить эти устаревшие псевдонимы, интерпретатор будет выдавать предупреждение об устаревании как минимум за два релиза до удаления. Псевдонимы гарантированно останутся в модуле typing без предупреждений об устаревании как минимум до Python 3.14.26332634Проверяющим типы рекомендуется отмечать использование устаревших типов, если проверяемая программа нацелена на минимальную версию Python 3.9 или новее.26352636#### Псевдонимы встроенных типов26372638#### `class typing.Dict(dict, MutableMapping[KT, VT])`26392640Устаревший псевдоним [`dict`](https://python-all.ru/3.12/library/stdtypes.html#dict).26412642Обратите внимание, что для аннотации аргументов предпочтительнее использовать абстрактный тип коллекции, такой как [`Mapping`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.Mapping), а не [`dict`](https://python-all.ru/3.12/library/stdtypes.html#dict) или `typing.Dict`.26432644Deprecated since version 3.9: [`builtins.dict`](https://python-all.ru/3.12/library/stdtypes.html#dict) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.12/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.12/library/stdtypes.html#types-genericalias).26452646#### `class typing.List(list, MutableSequence[T])`26472648Устаревший псевдоним [`list`](https://python-all.ru/3.12/library/stdtypes.html#list).26492650Обратите внимание, что для аннотации аргументов предпочтительнее использовать абстрактный тип коллекции, такой как [`Sequence`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.Sequence) или [`Iterable`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.Iterable), а не [`list`](https://python-all.ru/3.12/library/stdtypes.html#list) или `typing.List`.26512652Deprecated since version 3.9: [`builtins.list`](https://python-all.ru/3.12/library/stdtypes.html#list) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.12/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.12/library/stdtypes.html#types-genericalias).26532654#### `class typing.Set(set, MutableSet[T])`26552656Устаревший псевдоним [`builtins.set`](https://python-all.ru/3.12/library/stdtypes.html#set).26572658Обратите внимание, что для аннотации аргументов предпочтительнее использовать абстрактный тип коллекции, такой как [`collections.abc.Set`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.Set), а не [`set`](https://python-all.ru/3.12/library/stdtypes.html#set) или [`typing.Set`](https://python-all.ru/3.12/library/typing.html#typing.Set).26592660Deprecated since version 3.9: [`builtins.set`](https://python-all.ru/3.12/library/stdtypes.html#set) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.12/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.12/library/stdtypes.html#types-genericalias).26612662#### `class typing.FrozenSet(frozenset, AbstractSet[T_co])`26632664Устаревший псевдоним [`builtins.frozenset`](https://python-all.ru/3.12/library/stdtypes.html#frozenset).26652666Deprecated since version 3.9: [`builtins.frozenset`](https://python-all.ru/3.12/library/stdtypes.html#frozenset) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.12/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.12/library/stdtypes.html#types-genericalias).26672668#### `typing.Tuple`26692670Устаревший псевдоним для [`tuple`](https://python-all.ru/3.12/library/stdtypes.html#tuple).26712672[`tuple`](https://python-all.ru/3.12/library/stdtypes.html#tuple) и `Tuple` являются особыми случаями в системе типов; см. [Аннотирование кортежей](https://python-all.ru/3.12/library/typing.html#annotating-tuples) для получения дополнительной информации.26732674Deprecated since version 3.9: [`builtins.tuple`](https://python-all.ru/3.12/library/stdtypes.html#tuple) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.12/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.12/library/stdtypes.html#types-genericalias).26752676#### `class typing.Type(Generic[CT_co])`26772678Устаревший псевдоним [`type`](https://python-all.ru/3.12/library/functions.html#type).26792680См. [Тип объектов класса](https://python-all.ru/3.12/library/typing.html#type-of-class-objects) для подробностей об использовании [`type`](https://python-all.ru/3.12/library/functions.html#type) или `typing.Type` в аннотациях типов.26812682Добавлено в версии 3.5.2.26832684Deprecated since version 3.9: [`builtins.type`](https://python-all.ru/3.12/library/functions.html#type) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.12/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.12/library/stdtypes.html#types-genericalias).26852686#### Псевдонимы типов в [`collections`](https://python-all.ru/3.12/library/collections.html#module-collections)26872688#### `class typing.DefaultDict(collections.defaultdict, MutableMapping[KT, VT])`26892690Устаревший псевдоним [`collections.defaultdict`](https://python-all.ru/3.12/library/collections.html#collections.defaultdict).26912692Добавлено в версии 3.5.2.26932694Deprecated since version 3.9: [`collections.defaultdict`](https://python-all.ru/3.12/library/collections.html#collections.defaultdict) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.12/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.12/library/stdtypes.html#types-genericalias).26952696#### `class typing.OrderedDict(collections.OrderedDict, MutableMapping[KT, VT])`26972698Устаревший псевдоним [`collections.OrderedDict`](https://python-all.ru/3.12/library/collections.html#collections.OrderedDict).26992700Добавлено в версии 3.7.2.27012702Deprecated since version 3.9: [`collections.OrderedDict`](https://python-all.ru/3.12/library/collections.html#collections.OrderedDict) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.12/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.12/library/stdtypes.html#types-genericalias).27032704#### `class typing.ChainMap(collections.ChainMap, MutableMapping[KT, VT])`27052706Устаревший псевдоним [`collections.ChainMap`](https://python-all.ru/3.12/library/collections.html#collections.ChainMap).27072708Добавлено в версии 3.6.1.27092710Deprecated since version 3.9: [`collections.ChainMap`](https://python-all.ru/3.12/library/collections.html#collections.ChainMap) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.12/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.12/library/stdtypes.html#types-genericalias).27112712#### `class typing.Counter(collections.Counter, Dict[T, int])`27132714Устаревший псевдоним [`collections.Counter`](https://python-all.ru/3.12/library/collections.html#collections.Counter).27152716Добавлено в версии 3.6.1.27172718Deprecated since version 3.9: [`collections.Counter`](https://python-all.ru/3.12/library/collections.html#collections.Counter) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.12/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.12/library/stdtypes.html#types-genericalias).27192720#### `class typing.Deque(deque, MutableSequence[T])`27212722Устаревший псевдоним [`collections.deque`](https://python-all.ru/3.12/library/collections.html#collections.deque).27232724Добавлено в версии 3.6.1.27252726Deprecated since version 3.9: [`collections.deque`](https://python-all.ru/3.12/library/collections.html#collections.deque) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.12/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.12/library/stdtypes.html#types-genericalias).27272728#### Псевдонимы для других конкретных типов27292730> Устарело с версии 3.8, будет удалено в версии 3.13: Пространство имён `typing.io` устарело и будет удалено. Эти типы следует импортировать напрямую из `typing`.27312732#### `class typing.Pattern`27332734#### `class typing.Match`27352736Устаревшие псевдонимы, соответствующие типам возвращаемых значений из [`re.compile()`](https://python-all.ru/3.12/library/re.html#re.compile) и [`re.match()`](https://python-all.ru/3.12/library/re.html#re.match).27372738Эти типы (и соответствующие функции) являются обобщёнными относительно [`AnyStr`](https://python-all.ru/3.12/library/typing.html#typing.AnyStr). `Pattern` может быть специализирован как `Pattern[str]` или `Pattern[bytes]`; `Match` может быть специализирован как `Match[str]` или `Match[bytes]`.27392740Устарело с версии 3.8, будет удалено в версии 3.13: Пространство имён `typing.re` устарело и будет удалено. Эти типы следует импортировать напрямую из `typing`.27412742Устарело с версии 3.9: Классы `Pattern` и `Match` из [`re`](https://python-all.ru/3.12/library/re.html#module-re) теперь поддерживают `[]`. См. [**PEP 585**](https://python-all.ru/3.12/library/typing.html) и [Generic Alias Type](https://python-all.ru/3.12/library/stdtypes.html#types-genericalias).27432744#### `class typing.Text`27452746Устаревший псевдоним для [`str`](https://python-all.ru/3.12/library/stdtypes.html#str).27472748`Text` предоставляется для обеспечения совместимости с кодом Python 2: в Python 2 `Text` является псевдонимом для `unicode`.27492750Используйте `Text`, чтобы указать, что значение должно содержать строку Unicode, совместимую как с Python 2, так и с Python 3:27512752```python2753def add_unicode_checkmark(text: Text) -> Text:2754    return text + u' \u2713'2755```27562757Добавлено в версии 3.5.2.27582759Устарело с версии 3.11: Python 2 больше не поддерживается, и большинство проверщиков типов также больше не поддерживают проверку типов для кода Python 2. Удаление псевдонима в настоящее время не планируется, но пользователям рекомендуется использовать [`str`](https://python-all.ru/3.12/library/stdtypes.html#str) вместо `Text`.27602761#### Псевдонимы для контейнерных ABC в [`collections.abc`](https://python-all.ru/3.12/library/collections.abc.html#module-collections.abc)27622763#### `class typing.AbstractSet(Collection[T_co])`27642765Устаревший псевдоним [`collections.abc.Set`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.Set).27662767Deprecated since version 3.9: [`collections.abc.Set`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.Set) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.12/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.12/library/stdtypes.html#types-genericalias).27682769#### `class typing.ByteString(Sequence[int])`27702771Этот тип представляет типы [`bytes`](https://python-all.ru/3.12/library/stdtypes.html#bytes), [`bytearray`](https://python-all.ru/3.12/library/stdtypes.html#bytearray) и [`memoryview`](https://python-all.ru/3.12/library/stdtypes.html#memoryview) последовательностей байтов.27722773Устарело с версии 3.9, будет удалено в версии 3.14: Предпочтительнее использовать [`collections.abc.Buffer`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.Buffer) или объединение наподобие `bytes | bytearray | memoryview`.27742775#### `class typing.Collection(Sized, Iterable[T_co], Container[T_co])`27762777Устаревший псевдоним [`collections.abc.Collection`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.Collection).27782779Добавлено в версии 3.6.27802781Deprecated since version 3.9: [`collections.abc.Collection`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.Collection) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.12/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.12/library/stdtypes.html#types-genericalias).27822783#### `class typing.Container(Generic[T_co])`27842785Устаревший псевдоним [`collections.abc.Container`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.Container).27862787Deprecated since version 3.9: [`collections.abc.Container`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.Container) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.12/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.12/library/stdtypes.html#types-genericalias).27882789#### `class typing.ItemsView(MappingView, AbstractSet[tuple[KT_co, VT_co]])`27902791Устаревший псевдоним [`collections.abc.ItemsView`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.ItemsView).27922793Deprecated since version 3.9: [`collections.abc.ItemsView`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.ItemsView) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.12/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.12/library/stdtypes.html#types-genericalias).27942795#### `class typing.KeysView(MappingView, AbstractSet[KT_co])`27962797Устаревший псевдоним [`collections.abc.KeysView`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.KeysView).27982799Deprecated since version 3.9: [`collections.abc.KeysView`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.KeysView) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.12/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.12/library/stdtypes.html#types-genericalias).28002801#### `class typing.Mapping(Collection[KT], Generic[KT, VT_co])`28022803Устаревший псевдоним [`collections.abc.Mapping`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.Mapping).28042805Deprecated since version 3.9: [`collections.abc.Mapping`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.Mapping) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.12/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.12/library/stdtypes.html#types-genericalias).28062807#### `class typing.MappingView(Sized)`28082809Устаревший псевдоним [`collections.abc.MappingView`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.MappingView).28102811Deprecated since version 3.9: [`collections.abc.MappingView`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.MappingView) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.12/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.12/library/stdtypes.html#types-genericalias).28122813#### `class typing.MutableMapping(Mapping[KT, VT])`28142815Устаревший псевдоним [`collections.abc.MutableMapping`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.MutableMapping).28162817Deprecated since version 3.9: [`collections.abc.MutableMapping`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.MutableMapping) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.12/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.12/library/stdtypes.html#types-genericalias).28182819#### `class typing.MutableSequence(Sequence[T])`28202821Устаревший псевдоним [`collections.abc.MutableSequence`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.MutableSequence).28222823Deprecated since version 3.9: [`collections.abc.MutableSequence`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.MutableSequence) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.12/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.12/library/stdtypes.html#types-genericalias).28242825#### `class typing.MutableSet(AbstractSet[T])`28262827Устаревший псевдоним [`collections.abc.MutableSet`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.MutableSet).28282829Deprecated since version 3.9: [`collections.abc.MutableSet`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.MutableSet) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.12/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.12/library/stdtypes.html#types-genericalias).28302831#### `class typing.Sequence(Reversible[T_co], Collection[T_co])`28322833Устаревший псевдоним [`collections.abc.Sequence`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.Sequence).28342835Deprecated since version 3.9: [`collections.abc.Sequence`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.Sequence) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.12/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.12/library/stdtypes.html#types-genericalias).28362837#### `class typing.ValuesView(MappingView, Collection[_VT_co])`28382839Устаревший псевдоним [`collections.abc.ValuesView`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.ValuesView).28402841Deprecated since version 3.9: [`collections.abc.ValuesView`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.ValuesView) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.12/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.12/library/stdtypes.html#types-genericalias).28422843#### Псевдонимы для асинхронных ABC в [`collections.abc`](https://python-all.ru/3.12/library/collections.abc.html#module-collections.abc)28442845#### `class typing.Coroutine(Awaitable[ReturnType], Generic[YieldType, SendType, ReturnType])`28462847Устаревший псевдоним [`collections.abc.Coroutine`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.Coroutine).28482849See [Annotating generators and coroutines](https://python-all.ru/3.12/library/typing.html#annotating-generators-and-coroutines) for details on using [`collections.abc.Coroutine`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.Coroutine) and `typing.Coroutine` in type annotations.28502851Добавлено в версии 3.5.3.28522853Deprecated since version 3.9: [`collections.abc.Coroutine`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.Coroutine) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.12/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.12/library/stdtypes.html#types-genericalias).28542855#### `class typing.AsyncGenerator(AsyncIterator[YieldType], Generic[YieldType, SendType])`28562857Устаревший псевдоним [`collections.abc.AsyncGenerator`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.AsyncGenerator).28582859See [Annotating generators and coroutines](https://python-all.ru/3.12/library/typing.html#annotating-generators-and-coroutines) for details on using [`collections.abc.AsyncGenerator`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.AsyncGenerator) and `typing.AsyncGenerator` in type annotations.28602861Добавлено в версии 3.6.1.28622863Deprecated since version 3.9: [`collections.abc.AsyncGenerator`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.AsyncGenerator) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.12/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.12/library/stdtypes.html#types-genericalias).28642865#### `class typing.AsyncIterable(Generic[T_co])`28662867Устаревший псевдоним [`collections.abc.AsyncIterable`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.AsyncIterable).28682869Добавлено в версии 3.5.2.28702871Deprecated since version 3.9: [`collections.abc.AsyncIterable`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.AsyncIterable) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.12/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.12/library/stdtypes.html#types-genericalias).28722873#### `class typing.AsyncIterator(AsyncIterable[T_co])`28742875Устаревший псевдоним [`collections.abc.AsyncIterator`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.AsyncIterator).28762877Добавлено в версии 3.5.2.28782879Deprecated since version 3.9: [`collections.abc.AsyncIterator`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.AsyncIterator) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.12/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.12/library/stdtypes.html#types-genericalias).28802881#### `class typing.Awaitable(Generic[T_co])`28822883Устаревший псевдоним [`collections.abc.Awaitable`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.Awaitable).28842885Добавлено в версии 3.5.2.28862887Deprecated since version 3.9: [`collections.abc.Awaitable`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.Awaitable) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.12/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.12/library/stdtypes.html#types-genericalias).28882889#### Псевдонимы для других ABC в [`collections.abc`](https://python-all.ru/3.12/library/collections.abc.html#module-collections.abc)28902891#### `class typing.Iterable(Generic[T_co])`28922893Устаревший псевдоним [`collections.abc.Iterable`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.Iterable).28942895Deprecated since version 3.9: [`collections.abc.Iterable`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.Iterable) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.12/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.12/library/stdtypes.html#types-genericalias).28962897#### `class typing.Iterator(Iterable[T_co])`28982899Устаревший псевдоним [`collections.abc.Iterator`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.Iterator).29002901Deprecated since version 3.9: [`collections.abc.Iterator`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.Iterator) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.12/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.12/library/stdtypes.html#types-genericalias).29022903#### `typing.Callable`29042905Устаревший псевдоним [`collections.abc.Callable`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.Callable).29062907See [Annotating callable objects](https://python-all.ru/3.12/library/typing.html#annotating-callables) for details on how to use [`collections.abc.Callable`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.Callable) and `typing.Callable` in type annotations.29082909Deprecated since version 3.9: [`collections.abc.Callable`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.Callable) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.12/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.12/library/stdtypes.html#types-genericalias).29102911Changed in version 3.10: `Callable` now supports [`ParamSpec`](https://python-all.ru/3.12/library/typing.html#typing.ParamSpec) and [`Concatenate`](https://python-all.ru/3.12/library/typing.html#typing.Concatenate). See [**PEP 612**](https://python-all.ru/3.12/library/typing.html) for more details.29122913#### `class typing.Generator(Iterator[YieldType], Generic[YieldType, SendType, ReturnType])`29142915Устаревший псевдоним [`collections.abc.Generator`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.Generator).29162917See [Annotating generators and coroutines](https://python-all.ru/3.12/library/typing.html#annotating-generators-and-coroutines) for details on using [`collections.abc.Generator`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.Generator) and `typing.Generator` in type annotations.29182919Deprecated since version 3.9: [`collections.abc.Generator`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.Generator) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.12/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.12/library/stdtypes.html#types-genericalias).29202921#### `class typing.Hashable`29222923Устаревший псевдоним [`collections.abc.Hashable`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.Hashable).29242925Устарело с версии 3.12: Используйте непосредственно [`collections.abc.Hashable`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.Hashable).29262927#### `class typing.Reversible(Iterable[T_co])`29282929Устаревший псевдоним [`collections.abc.Reversible`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.Reversible).29302931Deprecated since version 3.9: [`collections.abc.Reversible`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.Reversible) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.12/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.12/library/stdtypes.html#types-genericalias).29322933#### `class typing.Sized`29342935Устаревший псевдоним [`collections.abc.Sized`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.Sized).29362937Устарело с версии 3.12: Используйте непосредственно [`collections.abc.Sized`](https://python-all.ru/3.12/library/collections.abc.html#collections.abc.Sized).29382939#### Псевдонимы для [`contextlib`](https://python-all.ru/3.12/library/contextlib.html#module-contextlib) ABCs29402941#### `class typing.ContextManager(Generic[T_co])`29422943Устаревший псевдоним [`contextlib.AbstractContextManager`](https://python-all.ru/3.12/library/contextlib.html#contextlib.AbstractContextManager).29442945Добавлено в версии 3.5.4.29462947Deprecated since version 3.9: [`contextlib.AbstractContextManager`](https://python-all.ru/3.12/library/contextlib.html#contextlib.AbstractContextManager) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.12/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.12/library/stdtypes.html#types-genericalias).29482949#### `class typing.AsyncContextManager(Generic[T_co])`29502951Устаревший псевдоним [`contextlib.AbstractAsyncContextManager`](https://python-all.ru/3.12/library/contextlib.html#contextlib.AbstractAsyncContextManager).29522953Добавлено в версии 3.6.2.29542955Deprecated since version 3.9: [`contextlib.AbstractAsyncContextManager`](https://python-all.ru/3.12/library/contextlib.html#contextlib.AbstractAsyncContextManager) now supports subscripting (`[]`). See [**PEP 585**](https://python-all.ru/3.12/library/typing.html) and [Generic Alias Type](https://python-all.ru/3.12/library/stdtypes.html#types-genericalias).29562957## Хронология устаревания основных возможностей29582959Некоторые возможности в `typing` устарели и могут быть удалены в будущей версии Python. Для удобства ниже приведена таблица с основными устаревшими элементами. Она может изменяться, и в ней перечислены не все устаревшие возможности.29602961| Возможность | Устарело в | Планируемое удаление | PEP/issue |2962| --- | --- | --- | --- |2963| `typing.io` и `typing.re` подмодули | 3.8 | 3.13 | [bpo-38291](https://python-all.ru/3.12/library/typing.html) |2964| `typing` версии стандартных коллекций | 3.9 | Не определено (см. [устаревшие псевдонимы](https://python-all.ru/3.12/library/typing.html#deprecated-aliases) для дополнительной информации) | [**PEP 585**](https://python-all.ru/3.12/library/typing.html) |2965| [`typing.ByteString`](https://python-all.ru/3.12/library/typing.html#typing.ByteString) | 3.9 | 3.14 | [gh-91896](https://python-all.ru/3.12/library/typing.html) |2966| [`typing.Text`](https://python-all.ru/3.12/library/typing.html#typing.Text) | 3.11 | Не определено | [gh-92332](https://python-all.ru/3.12/library/typing.html) |2967| [`typing.Hashable`](https://python-all.ru/3.12/library/typing.html#typing.Hashable) и [`typing.Sized`](https://python-all.ru/3.12/library/typing.html#typing.Sized) | 3.12 | Не определено | [gh-94309](https://python-all.ru/3.12/library/typing.html) |2968| [`typing.TypeAlias`](https://python-all.ru/3.12/library/typing.html#typing.TypeAlias) | 3.12 | Не определено | [**PEP 695**](https://python-all.ru/3.12/library/typing.html) |2969