Статическая и динамическая проверка типов средствами typing

Расширенные примеры использования typing

Generic с пользовательскими ограничениями

Создадим класс контейнера, который принимает только числовые типы.

from typing import Generic, TypeVar, Union

Numeric = TypeVar('Numeric', int, float)

class Vector(Generic[Numeric]):
    def __init__(self, x: Numeric, y: Numeric) -> None:
        self.x = x
        self.y = y
    
    def __add__(self, other: 'Vector[Numeric]') -> 'Vector[Numeric]':
        return Vector(self.x + other.x, self.y + other.y)

v1 = Vector(1.0, 2.0)
v2 = Vector(3.0, 4.0)
v3 = v1 + v2
print(v3.x, v3.y)  # 4.0 6.0

# v4 = Vector("a", "b")  # mypy укажет на ошибку: str не входит в Numeric

4.0 6.0

Декоратор с сохранением аннотаций типов

Используем ParamSpec и TypeVar для создания типобезопасного декоратора.

from typing import Callable, ParamSpec, TypeVar, Any

P = ParamSpec('P')
R = TypeVar('R')

def log_call(func: Callable[P, R]) -> Callable[P, R]:
    def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
        print(f"Вызов {func.__name__} с args={args}, kwargs={kwargs}")
        return func(*args, **kwargs)
    return wrapper

@log_call
def add(a: int, b: int) -> int:
    return a + b

add(2, 3)  # Вызов add с args=(2, 3), kwargs={}

Вызов add с args=(2, 3), kwargs={}

Использование Literal для ограничения возможных значений

Literal позволяет указать конкретные литералы, которые может принимать аргумент.

from typing import Literal

def set_mode(mode: Literal['read', 'write', 'append']) -> str:
    return f"Режим установлен: {mode}"

print(set_mode('read'))  # Режим установлен: read
# set_mode('delete')  # mypy: Argument 1 to "set_mode" has incompatible type "Literal['delete']"

Режим установлен: read

Создание псевдонимов типов с NewType

NewType создает новый тип, который отличается от базового для статической проверки, но в рантайме это тот же тип.

from typing import NewType

UserId = NewType('UserId', int)
PostId = NewType('PostId', int)

def get_user(user_id: UserId) -> str:
    return f"Пользователь {user_id}"

uid = UserId(42)
print(get_user(uid))  # Пользователь 42

# pid = PostId(10)
# get_user(pid)  # mypy: Argument 1 to "get_user" has incompatible type "PostId"; expected "UserId"

Пользователь 42

Ковариантность и контравариантность в Generics

Определение ковариантного (с covariant=True) и контравариантного (с contravariant=True) типа. Полезно при работе с коллекциями или функциями.

from typing import Generic, TypeVar, List

T_co = TypeVar('T_co', covariant=True)  # ковариантный
T_contra = TypeVar('T_contra', contravariant=True)  # контравариантный

class Container(Generic[T_co]):
    def __init__(self, value: T_co) -> None:
        self._value = value
    def get_value(self) -> T_co:
        return self._value

# Container[int] является подтипом Container[float], так как int -> float ковариантен

class Handler(Generic[T_contra]):
    def handle(self, event: T_contra) -> None:
        pass

# Handler[float] является подтипом Handler[int], так как float -> int контравариантен (функция от float может принимать int)

Рекурсивные типы (например, для дерева)

Использование ForwardRef или строковых аннотаций для ссылки на себя.

from typing import List, Optional, ForwardRef

TreeNode = ForwardRef('TreeNode')  # или from __future__ import annotations

class TreeNode:
    def __init__(self, value: int, children: Optional[List['TreeNode']] = None) -> None:
        self.value = value
        self.children = children or []

# Mypy может потребовать from __future__ import annotations для отложенной оценки

Combining typing with dataclasses and frozen

from dataclasses import dataclass
from typing import List

@dataclass(frozen=True)
class Point:
    x: float
    y: float

@dataclass
class Line:
    start: Point
    end: Point
    points: List[Point] = None

line = Line(Point(0,0), Point(1,1))
print(line)

Line(start=Point(x=0.0, y=0.0), end=Point(x=1.0, y=1.0), points=None)