Зачем нужен Typing?

Typing в Python

Typing — это модуль для добавления статической типизации к Python коду. Это критически важный инструмент для написания надёжного, поддерживаемого и масштабируемого кода.

Почему Typing необходим:

1. Python динамически типизирован — это может привести к ошибкам

# БЕЗ typing — ошибка выявляется только при выполнении
def calculate_total(prices):
    return sum(prices)

calculate_total([1, 2, 3])        # Работает
calculate_total("hello")          # TypeError только в runtime!
calculate_total([1, "two", 3])    # TypeError только в runtime!

# С typing — ошибка видна ДО выполнения кода
from typing import List

def calculate_total(prices: List[float]) -> float:
    return sum(prices)

calculate_total([1, 2, 3])        # OK
calculate_total("hello")          # Ошибка типа при проверке mypy/pyright
calculate_total([1, "two", 3])    # Ошибка типа при проверке

Основные типы в Typing:

Примитивные типы:

from typing import List, Dict, Tuple, Set, Optional, Union

name: str = "John"
age: int = 30
salary: float = 5000.50
is_active: bool = True

# Коллекции
users: List[str] = ["Alice", "Bob"]
scores: Dict[str, int] = {"Alice": 100, "Bob": 95}
point: Tuple[int, int] = (10, 20)
unique_ids: Set[int] = {1, 2, 3}

# Опциональные значения (может быть None)
empty_value: Optional[str] = None
user_id: Optional[int] = 123

# Несколько типов (Union)
result: Union[int, str] = "success"
result = 42  # Оба варианта допустимы

Типизация функций:

from typing import List, Dict, Optional, Callable

# Простая функция
def greet(name: str, age: int) -> str:
    return f"Hello {name}, you are {age} years old"

# Функция, возвращающая несколько значений
def get_user_info(user_id: int) -> Tuple[str, int, bool]:
    return "John", 30, True

# Опциональный параметр
def find_user(username: str, include_deleted: bool = False) -> Optional[Dict]:
    if include_deleted:
        return {"name": "John", "deleted": True}
    return None

# Функция как параметр
def apply_operation(x: int, y: int, op: Callable[[int, int], int]) -> int:
    return op(x, y)

add = lambda a, b: a + b
result = apply_operation(5, 3, add)  # 8

Типизация классов:

from typing import List, Optional
from dataclasses import dataclass

class User:
    def __init__(self, id: int, name: str, email: str):
        self.id: int = id
        self.name: str = name
        self.email: str = email
    
    def get_id(self) -> int:
        return self.id
    
    @classmethod
    def from_dict(cls, data: Dict[str, str]) -> 'User':
        return cls(
            id=int(data['id']),
            name=data['name'],
            email=data['email']
        )

# Dataclass (более современный подход)
@dataclass
class UserData:
    id: int
    name: str
    email: str
    is_active: bool = True

user = UserData(id=1, name="Alice", email="alice@example.com")

Дженерики (Generics):

from typing import TypeVar, Generic, List

# TypeVar — переменная типа
T = TypeVar('T')

class Container(Generic[T]):
    def __init__(self, item: T):
        self.item = item
    
    def get(self) -> T:
        return self.item

# Использование
int_container: Container[int] = Container(42)
str_container: Container[str] = Container("hello")

print(int_container.get())  # 42 (тип int)
print(str_container.get())  # "hello" (тип str)

# Функция с дженериком
def get_first(items: List[T]) -> T:
    return items[0]

first_int = get_first([1, 2, 3])        # type: int
first_str = get_first(["a", "b"])      # type: str

Проверка типов (Type Checking):

MyPy — самый популярный type checker:

# Установка
pip install mypy

# Проверка файла
mypy myfile.py

# Проверка всего проекта
mypy .

Пример ошибок, которые MyPy находит:

# error: Argument 1 to "greet" has incompatible type "int"; expected "str"
greet(123)

# error: Unsupported operand types for + ("str" and "int")
result: str = "hello" + 42

# error: "str" has no attribute "count"
total = sum("hello")

pyright (от Microsoft) — ещё лучше:

pip install pyright
pyright .  # Более строгая проверка

Практический пример — API сервер:

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import List, Optional
from datetime import datetime

app = FastAPI()

# Типизированные модели данных
class PostCreate(BaseModel):
    title: str
    content: str
    tags: List[str]

class PostResponse(BaseModel):
    id: int
    title: str
    content: str
    created_at: datetime
    author_id: int

class PostUpdate(BaseModel):
    title: Optional[str] = None
    content: Optional[str] = None

# Типизированные endpoints
@app.get("/posts", response_model=List[PostResponse])
async def list_posts(
    skip: int = 0,
    limit: int = 10
) -> List[PostResponse]:
    posts = get_posts_from_db(skip, limit)
    return posts

@app.post("/posts", response_model=PostResponse)
async def create_post(post: PostCreate) -> PostResponse:
    new_post = save_post_to_db(post)
    return new_post

@app.get("/posts/{post_id}", response_model=Optional[PostResponse])
async def get_post(post_id: int) -> Optional[PostResponse]:
    post = find_post_in_db(post_id)
    if not post:
        raise HTTPException(status_code=404, detail="Post not found")
    return post

Преимущества Typing:

1. Раннее выявление ошибок

# Без typing: ошибка в production
# С typing: ошибка перед commit
def process_user(user: User) -> str:
    return user.name  # OK

process_user({"name": "John"})  # TypeError — не User

2. Лучшая документация

# Без typing — неясно, что функция делает
def calculate(a, b, c):
    return a + b * c

# С typing — функция самодокументируется
def calculate(a: float, b: float, c: float) -> float:
    return a + b * c

3. Лучшая поддержка IDE

user = User(id=1, name="John")
user.  # IDE покажет все методы и атрибуты
       # И их типы параметров!

4. Упрощение рефакторинга

# Если изменить тип параметра, type checker
# сразу скажет все места, которые нужно обновить
def get_user(user_id: str) -> User:  # Было: int, стало: str
    # Все функции, которые передают int, подсветятся
    pass

5. Готовность к масштабированию

# В малом проекте typing может казаться лишним
# В проекте на 100k строк кода typing спасает от ошибок

Конфигурация для строгой типизации:

pyproject.toml / mypy.ini:

[mypy]
python_version = 3.10
warn_return_any = True
warn_unused_configs = True
disallow_untyped_defs = True        # Требовать типы для всех функций
disallow_incomplete_defs = True     # Не позволять Any
check_untyped_defs = True           # Проверять функции без типов
no_implicit_optional = True         # Запретить неявные Optional
warn_unused_ignores = True          # Ошибка, если # type: ignore не нужна

Когда нельзя обойтись без typing:

• Больших проектов (>10k строк кода)
• Командной разработки — everyone benefit
• API и библиотеки — пользователи должны знать типы
• Data Science — типизация помогает избежать ошибок в обработке данных
• Production код — ошибки типов очень дорогие

Best Practices:

# ✅ Всегда типизируй функции
def process(data: List[str]) -> Dict[str, int]:
    return {item: len(item) for item in data}

# ❌ Избегай Any
def process(data: Any) -> Any:  # Это как не типизировать
    pass

# ✅ Используй Union вместо Any
from typing import Union
def process(data: Union[str, int]) -> str:
    return str(data)

# ✅ Используй Protocol для duck typing
from typing import Protocol

class Drawable(Protocol):
    def draw(self) -> None: ...

def render(obj: Drawable) -> None:
    obj.draw()

Вывод: Typing в Python — это не просто опциональная фишка, а инвестиция в качество и надёжность кода. На современных проектах typing используется везде, и это становится стандартом индустрии.