`typing.md`

875 строк · 51.2 КБ · обычная страница · сырой текст · скачать
1> **Источник:** https://python-all.ru/3.5/library/typing.html2>3> «Документация Python на русском» – неофициальный перевод официальной документации Python: версии от 2.6 до 3.16, полнотекстовый поиск, английский оригинал рядом с переводом. Эта Markdown-версия страницы предназначена для работы с LLM: вставьте её в ChatGPT, Claude или Cursor.45---67# 26.1. [`typing`](https://python-all.ru/3.5/library/typing.html#module-typing) – Поддержка подсказок типов89Новое в версии 3.5.1011**Исходный код:** [Lib/typing.py](https://python-all.ru/src/3.5/Lib/typing.py)1213---1415Этот модуль поддерживает подсказки типов, как указано в [**PEP 484**](https://python-all.ru/3.5/library/typing.html). Основная поддержка включает типы [`Any`](https://python-all.ru/3.5/library/typing.html#typing.Any), [`Union`](https://python-all.ru/3.5/library/typing.html#typing.Union), [`Tuple`](https://python-all.ru/3.5/library/typing.html#typing.Tuple), [`Callable`](https://python-all.ru/3.5/library/typing.html#typing.Callable), [`TypeVar`](https://python-all.ru/3.5/library/typing.html#typing.TypeVar) и [`Generic`](https://python-all.ru/3.5/library/typing.html#typing.Generic). Полную спецификацию см. в [**PEP 484**](https://python-all.ru/3.5/library/typing.html). Упрощённое введение в подсказки типов см. в [**PEP 483**](https://python-all.ru/3.5/library/typing.html).1617Функция ниже принимает и возвращает строку и аннотирована следующим образом:1819```python20def greeting(name: str) -> str:21    return 'Hello ' + name22```2324В функции `greeting` аргумент `name` ожидается типа [`str`](https://python-all.ru/3.5/library/stdtypes.html#str), а возвращаемый тип – [`str`](https://python-all.ru/3.5/library/stdtypes.html#str). Подтипы допускаются в качестве аргументов.2526## 26.1.1. Псевдонимы типов2728Псевдоним типа определяется присваиванием типа псевдониму. В этом примере `Vector` и `List[float]` будут рассматриваться как взаимозаменяемые синонимы:2930```python31from typing import List32Vector = List[float]3334def scale(scalar: float, vector: Vector) -> Vector:35    return [scalar * num for num in vector]3637# Проходит проверку типов; список чисел с плавающей запятой считается Vector.38new_vector = scale(2.0, [1.0, -4.2, 5.4])39```4041Псевдонимы типов полезны для упрощения сложных сигнатур типов. Например:4243```python44from typing import Dict, Tuple, List4546ConnectionOptions = Dict[str, str]47Address = Tuple[str, int]48Server = Tuple[Address, ConnectionOptions]4950def broadcast_message(message: str, servers: List[Server]) -> None:51    ...5253# Статическая проверка типов будет считать предыдущую сигнатуру типа как54# полностью эквивалентную этой.55def broadcast_message(56        message: str,57        servers: List[Tuple[Tuple[str, int], Dict[str, str]]]) -> None:58    ...59```6061Обратите внимание, что `None` как аннотация типа является особым случаем и заменяется на `type(None)`.6263## 26.1.2. NewType6465Для создания отдельных типов используется вспомогательная функция [`NewType()`](https://python-all.ru/3.5/library/typing.html#typing.NewType):6667```python68from typing import NewType6970UserId = NewType('UserId', int)71some_id = UserId(524313)72```7374Статический проверщик типов будет рассматривать новый тип как подкласс исходного типа. Это полезно для выявления логических ошибок:7576```python77def get_user_name(user_id: UserId) -> str:78    ...7980# Проходит проверку типов.81user_a = get_user_name(UserId(42351))8283# Не проходит проверку типов; int не является UserId.84user_b = get_user_name(-1)85```8687Можно по-прежнему выполнять все операции `int` над переменной типа `UserId`, но результат всегда будет типа `int`. Это позволяет передавать `UserId` везде, где может ожидаться `int`, но предотвращает случайное создание `UserId` недопустимым способом:8889```python90# 'output' имеет тип 'int', а не 'UserId'91output = UserId(23413) + UserId(54341)92```9394Обратите внимание, что эти проверки выполняются только статическим анализатором типов. Во время выполнения инструкция `Derived = NewType('Derived', Base)` превращает `Derived` в функцию, которая немедленно возвращает переданный ей параметр. Это означает, что выражение `Derived(some_value)` не создаёт новый класс и не вносит никаких накладных расходов, кроме обычного вызова функции.9596Точнее, выражение `some_value is Derived(some_value)` во время выполнения всегда истинно.9798Это также означает, что невозможно создать подтип `Derived`, поскольку во время выполнения это функция идентичности, а не реальный тип. Аналогично, нельзя создать другой [`NewType()`](https://python-all.ru/3.5/library/typing.html#typing.NewType) на основе типа `Derived`:99100```python101from typing import NewType102103UserId = NewType('UserId', int)104105# Завершается ошибкой во время выполнения и не проходит проверку типов.106class AdminUserId(UserId): pass107108# Также не проверяет типы109ProUserId = NewType('ProUserId', UserId)110```111112Подробнее см. [**PEP 484**](https://python-all.ru/3.5/library/typing.html).113114> **Примечание**115>116> Напомним, что использование псевдонима типа объявляет два типа *эквивалентными* друг другу. Использование `Alias = Original` заставит статический анализатор типов считать `Alias` *точно эквивалентным* `Original` во всех случаях. Это полезно, когда требуется упростить сложные сигнатуры типов.117>118> В отличие от этого, `NewType` объявляет один тип *подтипом* другого. Использование `Derived = NewType('Derived', Original)` заставит статический анализатор типов считать `Derived` *подклассом* `Original`, что означает, что значение типа `Original` не может использоваться там, где ожидается значение типа `Derived`. Это полезно для предотвращения логических ошибок с минимальными затратами времени выполнения.119120## 26.1.3. Callable121122Фреймворки, ожидающие функции обратного вызова с определённой сигнатурой, могут быть аннотированы с помощью `Callable[[Arg1Type, Arg2Type], ReturnType]`.123124Например:125126```python127from typing import Callable128129def feeder(get_next_item: Callable[[], str]) -> None:130    # Тело131132def async_query(on_success: Callable[[int], None],133                on_error: Callable[[int, Exception], None]) -> None:134    # Тело135```136137Можно объявить возвращаемый тип вызываемого объекта, не указывая сигнатуру вызова, заменив список аргументов многоточием в аннотации типа: `Callable[..., ReturnType]`.138139## 26.1.4. Generics140141Поскольку информацию о типах объектов, хранящихся в контейнерах, нельзя статически вывести обобщённым способом, абстрактные базовые классы были расширены для поддержки параметризации типами, чтобы обозначить ожидаемые типы элементов контейнера.142143```python144from typing import Mapping, Sequence145146def notify_by_email(employees: Sequence[Employee],147                    overrides: Mapping[str, str]) -> None: ...148```149150Обобщённые типы можно параметризовать с помощью новой фабрики, доступной в typing, называемой [`TypeVar`](https://python-all.ru/3.5/library/typing.html#typing.TypeVar).151152```python153from typing import Sequence, TypeVar154155T = TypeVar('T')      # Объявить переменную типа156157def first(l: Sequence[T]) -> T:   # Обобщённая функция158    return l[0]159```160161## 26.1.5. Пользовательские обобщённые типы162163Пользовательский класс можно определить как обобщённый класс.164165```python166from typing import TypeVar, Generic167from logging import Logger168169T = TypeVar('T')170171class LoggedVar(Generic[T]):172    def __init__(self, value: T, name: str, logger: Logger) -> None:173        self.name = name174        self.logger = logger175        self.value = value176177    def set(self, new: T) -> None:178        self.log('Set ' + repr(self.value))179        self.value = new180181    def get(self) -> T:182        self.log('Get ' + repr(self.value))183        return self.value184185    def log(self, message: str) -> None:186        self.logger.info('%s: %s', self.name, message)187```188189`Generic[T]` в качестве базового класса определяет, что класс `LoggedVar` принимает один параметр типа `T`. Это также делает `T` допустимым типом внутри тела класса.190191Базовый класс [`Generic`](https://python-all.ru/3.5/library/typing.html#typing.Generic) использует метакласс, который определяет [`__getitem__()`](https://python-all.ru/3.5/reference/datamodel.html#object.__getitem__) так, чтобы `LoggedVar[t]` был допустимым в качестве типа:192193```python194from typing import Iterable195196def zero_all_vars(vars: Iterable[LoggedVar[int]]) -> None:197    for var in vars:198        var.set(0)199```200201Обобщённый тип может иметь любое количество переменных типа, и эти переменные могут быть ограничены:202203```python204from typing import TypeVar, Generic205...206207T = TypeVar('T')208S = TypeVar('S', int, str)209210class StrangePair(Generic[T, S]):211    ...212```213214Каждый аргумент-переменная типа для [`Generic`](https://python-all.ru/3.5/library/typing.html#typing.Generic) должен быть уникальным. Поэтому такой код некорректен:215216```python217from typing import TypeVar, Generic218...219220T = TypeVar('T')221222class Pair(Generic[T, T]):   # НЕДОПУСТИМО223    ...224```225226Можно использовать множественное наследование с [`Generic`](https://python-all.ru/3.5/library/typing.html#typing.Generic):227228```python229from typing import TypeVar, Generic, Sized230231T = TypeVar('T')232233class LinkedList(Sized, Generic[T]):234    ...235```236237При наследовании от обобщённых классов некоторые переменные типа могут быть зафиксированы:238239```python240from typing import TypeVar, Mapping241242T = TypeVar('T')243244class MyDict(Mapping[str, T]):245    ...246```247248В этом случае `MyDict` имеет один параметр – `T`.249250Использование обобщённого класса без указания параметров типа подразумевает [`Any`](https://python-all.ru/3.5/library/typing.html#typing.Any) для каждой позиции. В следующем примере `MyIterable` не является обобщённым, но неявно наследуется от `Iterable[Any]`:251252```python253from typing import Iterable254255class MyIterable(Iterable): # То же, что и Iterable[Any].256```257258Пользовательские обобщённые псевдонимы типов также поддерживаются. Примеры:259260```python261from typing import TypeVar, Iterable, Tuple, Union262S = TypeVar('S')263Response = Union[Iterable[S], int]264265# Тип возврата здесь такой же, как Union[Iterable[str], int]266def response(query: str) -> Response[str]:267    ...268269T = TypeVar('T', int, float, complex)270Vec = Iterable[Tuple[T, T]]271272def inproduct(v: Vec[T]) -> T: # То же, что Iterable[Tuple[T, T]]273    return sum(x*y for x, y in v)274```275276Метакласс, используемый [`Generic`](https://python-all.ru/3.5/library/typing.html#typing.Generic), является подклассом [`abc.ABCMeta`](https://python-all.ru/3.5/library/abc.html#abc.ABCMeta). Обобщённый класс может быть ABC, если содержит абстрактные методы или свойства, и обобщённые классы также могут иметь ABC в качестве базовых классов без конфликта метаклассов. Обобщённые метаклассы не поддерживаются. Результат параметризации дженериков кэшируется, а большинство типов в модуле typing являются хэшируемыми и сравнимыми на равенство.277278## 26.1.6. Тип [`Any`](https://python-all.ru/3.5/library/typing.html#typing.Any)279280Особым видом типа является [`Any`](https://python-all.ru/3.5/library/typing.html#typing.Any). Статический проверяющий типов будет считать каждый тип совместимым с [`Any`](https://python-all.ru/3.5/library/typing.html#typing.Any), а [`Any`](https://python-all.ru/3.5/library/typing.html#typing.Any) – совместимым с каждым типом.281282Это означает, что над значением типа [`Any`](https://python-all.ru/3.5/library/typing.html#typing.Any) можно выполнять любые операции или вызовы методов и присваивать его любой переменной:283284```python285from typing import Any286287a = None    # type: Any288a = []      # ОК289a = 2       # ОК290291s = ''      # type: str292s = a       # ОК293294def foo(item: Any) -> int:295    # Проходит проверку типов; 'item' может быть любого типа,296    # и этот тип может иметь метод 'bar'297    item.bar()298    ...299```300301Обратите внимание, что никакая проверка типов не выполняется при присваивании значения типа [`Any`](https://python-all.ru/3.5/library/typing.html#typing.Any) более точному типу. Например, статический проверяющий типы не сообщил об ошибке при присваивании `a` переменной `s`, хотя `s` был объявлен как тип [`str`](https://python-all.ru/3.5/library/stdtypes.html#str) и получает значение [`int`](https://python-all.ru/3.5/library/functions.html#int) во время выполнения!302303Кроме того, все функции без указания типа возврата или типов параметров по умолчанию неявно используют [`Any`](https://python-all.ru/3.5/library/typing.html#typing.Any):304305```python306def legacy_parser(text):307    ...308    return data309310# Статический проверщик типов будет рассматривать вышеприведенное311# как имеющее ту же сигнатуру, что и:312def legacy_parser(text: Any) -> Any:313    ...314    return data315```316317Такое поведение позволяет использовать [`Any`](https://python-all.ru/3.5/library/typing.html#typing.Any) в качестве *запасного выхода*, когда нужно смешивать динамически и статически типизированный код.318319Сравните поведение [`Any`](https://python-all.ru/3.5/library/typing.html#typing.Any) с поведением [`object`](https://python-all.ru/3.5/library/functions.html#object). Как и [`Any`](https://python-all.ru/3.5/library/typing.html#typing.Any), каждый тип является подтипом [`object`](https://python-all.ru/3.5/library/functions.html#object). Однако, в отличие от [`Any`](https://python-all.ru/3.5/library/typing.html#typing.Any), обратное неверно: [`object`](https://python-all.ru/3.5/library/functions.html#object) *не* является подтипом любого другого типа.320321Это означает, что когда тип значения – [`object`](https://python-all.ru/3.5/library/functions.html#object), проверяющий типы будет отклонять почти все операции над ним, а присваивание его переменной (или использование в качестве возвращаемого значения) более специализированного типа является ошибкой типа. Например:322323```python324def hash_a(item: object) -> int:325    # Завершается ошибкой; у объекта нет метода 'magic'.326    item.magic()327    ...328329def hash_b(item: Any) -> int:330    # Проходит проверку типов.331    item.magic()332    ...333334# Проходит проверку типов, так как int и str являются подклассами object.335hash_a(42)336hash_a("foo")337338# Проходит проверку типов, так как Any совместим со всеми типами.339hash_b(42)340hash_b("foo")341```342343Используйте [`object`](https://python-all.ru/3.5/library/functions.html#object), чтобы указать, что значение может быть любого типа в типобезопасной манере. Используйте [`Any`](https://python-all.ru/3.5/library/typing.html#typing.Any), чтобы указать, что значение динамически типизировано.344345## 26.1.7. Классы, функции и декораторы346347Модуль определяет следующие классы, функции и декораторы:348349#### `class typing.TypeVar`350351Переменная типа.352353Использование:354355```python356T = TypeVar('T')  # Может быть чем угодно357A = TypeVar('A', str, bytes)  # Должно быть str или bytes358```359360Переменные типа существуют в первую очередь для статических анализаторов типов. Они служат параметрами для обобщённых типов, а также для определений обобщённых функций. См. класс Generic для получения дополнительной информации об обобщённых типах. Обобщённые функции работают следующим образом:361362```python363def repeat(x: T, n: int) -> Sequence[T]:364    """Возвращает список, содержащий n ссылок на x."""365    return [x]*n366367def longest(x: A, y: A) -> A:368    """Возвращает самую длинную из двух строк."""369    return x if len(x) >= len(y) else y370```371372Сигнатура последнего примера по сути является перегрузкой `(str, str) -> str` и `(bytes, bytes) -> bytes`. Также обратите внимание, что если аргументы являются экземплярами какого-либо подкласса [`str`](https://python-all.ru/3.5/library/stdtypes.html#str), возвращаемый тип остаётся простым [`str`](https://python-all.ru/3.5/library/stdtypes.html#str).373374Во время выполнения `isinstance(x, T)` вызовет [`TypeError`](https://python-all.ru/3.5/library/exceptions.html#TypeError). В общем, [`isinstance()`](https://python-all.ru/3.5/library/functions.html#isinstance) и [`issubclass()`](https://python-all.ru/3.5/library/functions.html#issubclass) не должны использоваться с типами.375376Переменные типа могут быть помечены как ковариантные или контравариантные путём передачи `covariant=True` или `contravariant=True`. См. [**PEP 484**](https://python-all.ru/3.5/library/typing.html) для подробностей. По умолчанию переменные типа инвариантны. В качестве альтернативы, переменная типа может указывать верхнюю границу с помощью `bound=<type>`. Это означает, что фактический тип, подставленный (явно или неявно) для переменной типа, должен быть подклассом граничного типа, см. [**PEP 484**](https://python-all.ru/3.5/library/typing.html).377378#### `class typing.Generic`379380Абстрактный базовый класс для обобщённых типов.381382Обобщённый тип обычно объявляется наследованием от экземпляра этого класса с одной или несколькими переменными типа. Например, обобщённый тип отображения может быть определён так:383384```python385class Mapping(Generic[KT, VT]):386    def __getitem__(self, key: KT) -> VT:387        ...388        # И т.д.389```390391Затем этот класс можно использовать следующим образом:392393```python394X = TypeVar('X')395Y = TypeVar('Y')396397def lookup_name(mapping: Mapping[X, Y], key: X, default: Y) -> Y:398    try:399        return mapping[key]400    except KeyError:401        return default402```403404#### `class typing.Type(Generic[CT_co])`405406Переменная, аннотированная `C`, может принимать значение типа `C`. Напротив, переменная, аннотированная `Type[C]`, может принимать значения, которые сами являются классами – а именно, она принимает *объект класса* `C`. Например:407408```python409a = 3         # Имеет тип 'int'410b = int       # Имеет тип 'Type[int]'411c = type(a)   # Также имеет тип 'Type[int]'412```413414Обратите внимание, что `Type[C]` ковариантен:415416```python417class User: ...418class BasicUser(User): ...419class ProUser(User): ...420class TeamUser(User): ...421422# Принимает User, BasicUser, ProUser, TeamUser, ...423def make_new_user(user_class: Type[User]) -> User:424    # ...425    return user_class()426```427428Тот факт, что `Type[C]` ковариантен, подразумевает, что все подклассы `C` должны реализовывать те же сигнатуры конструктора и методов класса, что и `C`. Средство проверки типов должно отмечать нарушения этого, но также должно разрешать вызовы конструкторов в подклассах, которые соответствуют вызовам конструктора в указанном базовом классе. То, как средство проверки типов должно обрабатывать этот конкретный случай, может измениться в будущих версиях [**PEP 484**](https://python-all.ru/3.5/library/typing.html).429430Единственные допустимые параметры для [`Type`](https://python-all.ru/3.5/library/typing.html#typing.Type) – это классы, объединения классов и [`Any`](https://python-all.ru/3.5/library/typing.html#typing.Any). Например:431432```python433def new_non_team_user(user_class: Type[Union[BaseUser, ProUser]]): ...434```435436`Type[Any]` эквивалентен `Type`, который в свою очередь эквивалентен `type`, корню метаклассовой иерархии Python.437438#### `class typing.Iterable(Generic[T_co])`439440Обобщённая версия [`collections.abc.Iterable`](https://python-all.ru/3.5/library/collections.abc.html#collections.abc.Iterable).441442#### `class typing.Iterator(Iterable[T_co])`443444Обобщённая версия [`collections.abc.Iterator`](https://python-all.ru/3.5/library/collections.abc.html#collections.abc.Iterator).445446#### `class typing.Reversible(Iterable[T_co])`447448Обобщённая версия `collections.abc.Reversible`.449450#### `class typing.SupportsInt`451452ABC с одним абстрактным методом `__int__`.453454#### `class typing.SupportsFloat`455456ABC с одним абстрактным методом `__float__`.457458#### `class typing.SupportsAbs`459460ABC с одним абстрактным методом `__abs__`, ковариантным по типу возвращаемого значения.461462#### `class typing.SupportsRound`463464ABC с одним абстрактным методом `__round__` ковариантным по возвращаемому типу.465466#### `class typing.Container(Generic[T_co])`467468Обобщённая версия [`collections.abc.Container`](https://python-all.ru/3.5/library/collections.abc.html#collections.abc.Container).469470#### `class typing.Hashable`471472Псевдоним для [`collections.abc.Hashable`](https://python-all.ru/3.5/library/collections.abc.html#collections.abc.Hashable)473474#### `class typing.Sized`475476Псевдоним для [`collections.abc.Sized`](https://python-all.ru/3.5/library/collections.abc.html#collections.abc.Sized)477478#### `class typing.AbstractSet(Sized, Iterable[T_co], Container[T_co])`479480Обобщённая версия [`collections.abc.Set`](https://python-all.ru/3.5/library/collections.abc.html#collections.abc.Set).481482#### `class typing.MutableSet(AbstractSet[T])`483484Обобщённая версия [`collections.abc.MutableSet`](https://python-all.ru/3.5/library/collections.abc.html#collections.abc.MutableSet).485486#### `class typing.Mapping(Sized, Iterable[KT], Container[KT], Generic[VT_co])`487488Обобщённая версия [`collections.abc.Mapping`](https://python-all.ru/3.5/library/collections.abc.html#collections.abc.Mapping).489490#### `class typing.MutableMapping(Mapping[KT, VT])`491492Обобщённая версия [`collections.abc.MutableMapping`](https://python-all.ru/3.5/library/collections.abc.html#collections.abc.MutableMapping).493494#### `class typing.Sequence(Sized, Iterable[T_co], Container[T_co])`495496Обобщённая версия [`collections.abc.Sequence`](https://python-all.ru/3.5/library/collections.abc.html#collections.abc.Sequence).497498#### `class typing.MutableSequence(Sequence[T])`499500Обобщённая версия [`collections.abc.MutableSequence`](https://python-all.ru/3.5/library/collections.abc.html#collections.abc.MutableSequence).501502#### `class typing.ByteString(Sequence[int])`503504Обобщённая версия [`collections.abc.ByteString`](https://python-all.ru/3.5/library/collections.abc.html#collections.abc.ByteString).505506Этот тип представляет типы [`bytes`](https://python-all.ru/3.5/library/functions.html#bytes), [`bytearray`](https://python-all.ru/3.5/library/functions.html#bytearray) и [`memoryview`](https://python-all.ru/3.5/library/stdtypes.html#memoryview).507508В качестве сокращения для этого типа [`bytes`](https://python-all.ru/3.5/library/functions.html#bytes) можно использовать для аннотации аргументов любого из упомянутых выше типов.509510#### `class typing.Deque(deque, MutableSequence[T])`511512Обобщённая версия [`collections.deque`](https://python-all.ru/3.5/library/collections.html#collections.deque).513514Новое в версии 3.5.4.515516#### `class typing.List(list, MutableSequence[T])`517518Обобщённая версия [`list`](https://python-all.ru/3.5/library/stdtypes.html#list). Полезна для аннотации возвращаемых типов. Для аннотации аргументов предпочтительнее использовать абстрактные типы коллекций, такие как [`Mapping`](https://python-all.ru/3.5/library/typing.html#typing.Mapping), [`Sequence`](https://python-all.ru/3.5/library/typing.html#typing.Sequence) или [`AbstractSet`](https://python-all.ru/3.5/library/typing.html#typing.AbstractSet).519520Этот тип можно использовать следующим образом:521522```python523T = TypeVar('T', int, float)524525def vec2(x: T, y: T) -> List[T]:526    return [x, y]527528def keep_positives(vector: Sequence[T]) -> List[T]:529    return [item for item in vector if item > 0]530```531532#### `class typing.Set(set, MutableSet[T])`533534Обобщённая версия [`builtins.set`](https://python-all.ru/3.5/library/stdtypes.html#set).535536#### `class typing.FrozenSet(frozenset, AbstractSet[T_co])`537538Обобщённая версия [`builtins.frozenset`](https://python-all.ru/3.5/library/stdtypes.html#frozenset).539540#### `class typing.MappingView(Sized, Iterable[T_co])`541542Обобщённая версия [`collections.abc.MappingView`](https://python-all.ru/3.5/library/collections.abc.html#collections.abc.MappingView).543544#### `class typing.KeysView(MappingView[KT_co], AbstractSet[KT_co])`545546Обобщённая версия [`collections.abc.KeysView`](https://python-all.ru/3.5/library/collections.abc.html#collections.abc.KeysView).547548#### `class typing.ItemsView(MappingView, Generic[KT_co, VT_co])`549550Обобщённая версия [`collections.abc.ItemsView`](https://python-all.ru/3.5/library/collections.abc.html#collections.abc.ItemsView).551552#### `class typing.ValuesView(MappingView[VT_co])`553554Обобщённая версия [`collections.abc.ValuesView`](https://python-all.ru/3.5/library/collections.abc.html#collections.abc.ValuesView).555556#### `class typing.Awaitable(Generic[T_co])`557558Обобщённая версия [`collections.abc.Awaitable`](https://python-all.ru/3.5/library/collections.abc.html#collections.abc.Awaitable).559560#### `class typing.Coroutine(Awaitable[V_co], Generic[T_co T_contra, V_co])`561562Обобщённая версия [`collections.abc.Coroutine`](https://python-all.ru/3.5/library/collections.abc.html#collections.abc.Coroutine). Вариантность и порядок переменных типа соответствуют таковым у [`Generator`](https://python-all.ru/3.5/library/typing.html#typing.Generator), например:563564```python565from typing import List, Coroutine566c = None # type: Coroutine[List[str], str, int]567...568x = c.send('hi') # type: List[str]569async def bar() -> None:570    x = await c # type: int571```572573#### `class typing.AsyncIterable(Generic[T_co])`574575Обобщённая версия [`collections.abc.AsyncIterable`](https://python-all.ru/3.5/library/collections.abc.html#collections.abc.AsyncIterable).576577#### `class typing.AsyncIterator(AsyncIterable[T_co])`578579Обобщённая версия [`collections.abc.AsyncIterator`](https://python-all.ru/3.5/library/collections.abc.html#collections.abc.AsyncIterator).580581#### `class typing.Dict(dict, MutableMapping[KT, VT])`582583Обобщённая версия [`dict`](https://python-all.ru/3.5/library/stdtypes.html#dict). Использование этого типа выглядит следующим образом:584585```python586def get_position_in_index(word_list: Dict[str, int], word: str) -> int:587    return word_list[word]588```589590#### `class typing.DefaultDict(collections.defaultdict, MutableMapping[KT, VT])`591592Обобщённая версия [`collections.defaultdict`](https://python-all.ru/3.5/library/collections.html#collections.defaultdict)593594#### `class typing.Generator(Iterator[T_co], Generic[T_co, T_contra, V_co])`595596Генератор можно аннотировать обобщённым типом `Generator[YieldType, SendType, ReturnType]`. Например:597598```python599def echo_round() -> Generator[int, float, str]:600    sent = yield 0601    while sent >= 0:602        sent = yield round(sent)603    return 'Done'604```605606Обратите внимание: в отличие от многих других обобщённых типов в модуле typing, `SendType` из [`Generator`](https://python-all.ru/3.5/library/typing.html#typing.Generator) ведёт себя контравариантно, а не ковариантно или инвариантно.607608Если ваш генератор будет только выдавать значения, установите `SendType` и `ReturnType` в `None`:609610```python611def infinite_stream(start: int) -> Generator[int, None, None]:612    while True:613        yield start614        start += 1615```616617В качестве альтернативы аннотируйте генератор как имеющий тип возвращаемого значения либо `Iterable[YieldType]`, либо `Iterator[YieldType]`:618619```python620def infinite_stream(start: int) -> Iterator[int]:621    while True:622        yield start623        start += 1624```625626#### `class typing.AsyncGenerator(AsyncIterator[T_co], Generic[T_co, T_contra])`627628Асинхронный генератор можно аннотировать обобщённым типом `AsyncGenerator[YieldType, SendType]`. Например:629630```python631async def echo_round() -> AsyncGenerator[int, float]:632    sent = yield 0633    while sent >= 0.0:634        rounded = await round(sent)635        sent = yield rounded636```637638В отличие от обычных генераторов, асинхронные генераторы не могут возвращать значение, поэтому параметр типа `ReturnType` отсутствует. Как и в случае с [`Generator`](https://python-all.ru/3.5/library/typing.html#typing.Generator), `SendType` ведёт себя контравариантно.639640Если генератор только выдаёт значения, установите `SendType` в `None`:641642```python643async def infinite_stream(start: int) -> AsyncGenerator[int, None]:644    while True:645        yield start646        start = await increment(start)647```648649В качестве альтернативы аннотируйте генератор как имеющий тип возвращаемого значения либо `AsyncIterable[YieldType]`, либо `AsyncIterator[YieldType]`:650651```python652async def infinite_stream(start: int) -> AsyncIterator[int]:653    while True:654        yield start655        start = await increment(start)656```657658Новое в версии 3.5.4.659660#### `class typing.Text`661662`Text` – это псевдоним для `str`. Он предоставляется для обеспечения совместимости с кодом Python 2: в Python 2 `Text` является псевдонимом для `unicode`.663664Используйте `Text`, чтобы указать, что значение должно содержать строку Unicode, совместимую как с Python 2, так и с Python 3:665666```python667def add_unicode_checkmark(text: Text) -> Text:668    return text + u' \u2713'669```670671#### `class typing.io`672673Пространство имён-обёртка для типов потоков ввода-вывода.674675Это определяет обобщённый тип `IO[AnyStr]` и псевдонимы `TextIO` и `BinaryIO` для `IO[str]` и `IO[bytes]` соответственно. Они представляют типы потоков ввода-вывода, такие как возвращаемые [`open()`](https://python-all.ru/3.5/library/functions.html#open).676677#### `class typing.re`678679Пространство имён-обёртка для типов сопоставления с регулярными выражениями.680681Это определяет псевдонимы типов `Pattern` и `Match`, которые соответствуют возвращаемым типам из [`re.compile()`](https://python-all.ru/3.5/library/re.html#re.compile) и [`re.match()`](https://python-all.ru/3.5/library/re.html#re.match). Эти типы (и соответствующие функции) являются обобщёнными по `AnyStr` и могут быть конкретизированы записью `Pattern[str]`, `Pattern[bytes]`, `Match[str]` или `Match[bytes]`.682683#### `typing.NamedTuple(typename, fields)`684685Типизированная версия namedtuple.686687Использование:688689```python690Employee = typing.NamedTuple('Employee', [('name', str), ('id', int)])691```692693Это эквивалентно:694695```python696Employee = collections.namedtuple('Employee', ['name', 'id'])697```698699Результирующий класс имеет один дополнительный атрибут: \_field\_types, предоставляющий словарь, сопоставляющий имена полей с типами. (Имена полей находятся в атрибуте \_fields, который является частью API namedtuple.)700701#### `typing.NewType(typ)`702703Вспомогательная функция для указания статическому анализатору, что тип является отдельным; см. [NewType](https://python-all.ru/3.5/library/typing.html#distinct). Во время выполнения возвращает функцию, которая возвращает свой аргумент. Использование:704705```python706UserId = NewType('UserId', int)707first_user = UserId(1)708```709710#### `typing.cast(typ, val)`711712Приводит значение к типу.713714Это возвращает значение без изменений. Для проверщика типов это сигнализирует, что возвращаемое значение имеет указанный тип, но во время выполнения мы намеренно ничего не проверяем (мы хотим, чтобы это было как можно быстрее).715716#### `typing.get_type_hints(obj[, globals[, locals]])`717718Возвращает словарь, содержащий аннотации типов для функции, метода, модуля или объекта класса.719720Это часто совпадает с `obj.__annotations__`. Кроме того, прямые ссылки, закодированные как строковые литералы, обрабатываются путём вычисления их в пространствах имён `globals` и `locals`. При необходимости `Optional[t]` добавляется для аннотаций функций и методов, если задано значение по умолчанию, равное `None`. Для класса `C` возвращается словарь, построенный объединением всех `__annotations__` по `C.__mro__` в обратном порядке.721722#### `@typing.overload`723724Декоратор `@overload` позволяет описывать функции и методы, поддерживающие несколько различных комбинаций типов аргументов. За серией определений, декорированных `@overload`, должно следовать ровно одно определение без `@overload` (для той же функции/метода). Определения с `@overload` предназначены только для проверки типов, так как они будут перезаписаны определением без `@overload`, которое используется во время выполнения, но должно игнорироваться проверщиком типов. Во время выполнения прямой вызов функции, декорированной `@overload`, вызовет `NotImplementedError`. Пример перегрузки, дающей более точный тип, чем можно выразить с помощью объединения или переменной типа:725726```python727@overload728def process(response: None) -> None:729    ...730@overload731def process(response: int) -> Tuple[int, str]:732    ...733@overload734def process(response: bytes) -> str:735    ...736def process(response):737    <actual implementation>738```739740См. [**PEP 484**](https://python-all.ru/3.5/library/typing.html) для подробностей и сравнения с другими семантиками типизации.741742#### `@typing.no_type_check(arg)`743744Декоратор, указывающий, что аннотации не являются подсказками типов.745746Аргументом должен быть класс или функция; если это класс, он применяется рекурсивно ко всем методам, определённым в этом классе (но не к методам, определённым в его суперклассах или подклассах).747748Это изменяет функцию(и) на месте.749750#### `@typing.no_type_check_decorator(decorator)`751752Декоратор, придающий другому декоратору эффект [`no_type_check()`](https://python-all.ru/3.5/library/typing.html#typing.no_type_check).753754Он оборачивает декоратор чем-то, что оборачивает декорированную функцию в [`no_type_check()`](https://python-all.ru/3.5/library/typing.html#typing.no_type_check).755756#### `typing.Any`757758Специальный тип, указывающий на неограниченный тип.759760- Каждый тип совместим с [`Any`](https://python-all.ru/3.5/library/typing.html#typing.Any).761- [`Any`](https://python-all.ru/3.5/library/typing.html#typing.Any) совместим с каждым типом.762763#### `typing.Union`764765Тип объединения; `Union[X, Y]` означает либо X, либо Y.766767Чтобы определить объединение, используйте, например, `Union[int, str]`. Подробности:768769- Аргументы должны быть типами, и их должно быть как минимум один.770- Объединения объединений разворачиваются, например:771772  ```python773  Union[Union[int, str], float] == Union[int, str, float]774  ```775- Объединения из одного аргумента исчезают, например:776777  ```python778  Union[int] == int  # Конструктор на самом деле возвращает int779  ```780- Повторяющиеся аргументы пропускаются, например:781782  ```python783  Union[int, str, int] == Union[int, str]784  ```785- При сравнении объединений порядок аргументов игнорируется, например:786787  ```python788  Union[int, str] == Union[str, int]789  ```790- Когда присутствуют класс и его подкласс, последний пропускается, например:791792  ```python793  Union[int, object] == object794  ```795- Нельзя создавать подкласс или экземпляр объединения.796- Нельзя записать `Union[X][Y]`.797- Можно использовать `Optional[X]` как сокращение для `Union[X, None]`.798799#### `typing.Optional`800801Тип Optional.802803`Optional[X]` эквивалентно `Union[X, None]`.804805Обратите внимание, что это не то же самое, что необязательный аргумент, который имеет значение по умолчанию. Необязательный аргумент со значением по умолчанию не обязан использовать квалификатор `Optional` в аннотации типа (хотя он выводится, если значение по умолчанию – `None`). Обязательный аргумент может по-прежнему иметь тип `Optional`, если допускается явное значение `None`.806807#### `typing.Tuple`808809Тип кортежа; `Tuple[X, Y]` – это тип кортежа из двух элементов с первым элементом типа X и вторым типа Y.810811Пример: `Tuple[T1, T2]` – это кортеж из двух элементов, соответствующих переменным типа T1 и T2. `Tuple[int, float, str]` – это кортеж из int, float и строки.812813Чтобы задать кортеж переменной длины из однотипных элементов, используйте литеральное многоточие, например `Tuple[int, ...]`. Простой [`Tuple`](https://python-all.ru/3.5/library/typing.html#typing.Tuple) эквивалентен `Tuple[Any, ...]`, а тот, в свою очередь, [`tuple`](https://python-all.ru/3.5/library/stdtypes.html#tuple).814815#### `typing.Callable`816817Тип Callable; `Callable[[int], str]` – это функция вида (int) -\> str.818819Синтаксис индексирования всегда должен использоваться ровно с двумя значениями: списком аргументов и типом возвращаемого значения. Список аргументов должен быть списком типов или многоточием; тип возвращаемого значения должен быть одним типом.820821Нет синтаксиса для указания необязательных или именованных аргументов; такие типы функций редко используются в качестве типов колбэков. `Callable[..., ReturnType]` (буквальное многоточие) можно использовать для аннотации вызываемого объекта, принимающего любое количество аргументов и возвращающего `ReturnType`. Обычное [`Callable`](https://python-all.ru/3.5/library/typing.html#typing.Callable) эквивалентно `Callable[..., Any]`, а в свою очередь – [`collections.abc.Callable`](https://python-all.ru/3.5/library/collections.abc.html#collections.abc.Callable).822823#### `typing.ClassVar`824825Специальная конструкция типа для пометки переменных класса.826827Как представлено в [**PEP 526**](https://python-all.ru/3.5/library/typing.html), аннотация переменной, обёрнутая в ClassVar, указывает, что данный атрибут предназначен для использования в качестве переменной класса и не должен устанавливаться на экземплярах этого класса. Использование:828829```python830class Starship:831    stats = {}  # type: ClassVar[Dict[str, int]] # class variable832    damage = 10 # type: int                      # instance variable833```834835[`ClassVar`](https://python-all.ru/3.5/library/typing.html#typing.ClassVar) принимает только типы и не может быть дополнительно индексирован.836837[`ClassVar`](https://python-all.ru/3.5/library/typing.html#typing.ClassVar) сам по себе не является классом, и его не следует использовать с [`isinstance()`](https://python-all.ru/3.5/library/functions.html#isinstance) или [`issubclass()`](https://python-all.ru/3.5/library/functions.html#issubclass). Обратите внимание, что [`ClassVar`](https://python-all.ru/3.5/library/typing.html#typing.ClassVar) не изменяет поведение Python во время выполнения; он может использоваться сторонними проверяющими типы, так что следующий код может помечаться ими как ошибочный:838839```python840enterprise_d = Starship(3000)841enterprise_d.stats = {} # Ошибка: установка переменной класса на экземпляре842Starship.stats = {}     # Это корректно.843```844845Новое в версии 3.5.3.846847#### `typing.AnyStr`848849`AnyStr` – это переменная типа, определённая как `AnyStr = TypeVar('AnyStr', str, bytes)`.850851Предназначен для функций, которые могут принимать строки любого типа, не допуская смешивания разных типов строк. Например:852853```python854def concat(a: AnyStr, b: AnyStr) -> AnyStr:855    return a + b856857concat(u"foo", u"bar")  # Ок, результат имеет тип 'unicode'858concat(b"foo", b"bar")  # Ок, результат имеет тип 'bytes'859concat(u"foo", b"bar")  # Ошибка, нельзя смешивать unicode и bytes860```861862#### `typing.TYPE_CHECKING`863864Специальная константа, которая считается `True` сторонними статическими проверщиками типов. Во время выполнения она равна `False`. Применение:865866```python867if TYPE_CHECKING:868    import expensive_mod869870def fun(arg: 'expensive_mod.SomeType') -> None:871    local_var: expensive_mod.AnotherType = other_fun()872```873874Обратите внимание, что первая аннотация типа должна быть заключена в кавычки, что делает её «отложенной ссылкой» (forward reference), чтобы скрыть ссылку `expensive_mod` от интерпретатора во время выполнения. Аннотации типов для локальных переменных не вычисляются, поэтому вторую аннотацию заключать в кавычки не нужно.875