Что такое явная типизация?

Явная типизация в Python

Явная типизация (explicit typing) — это аннотирование типов переменных, параметров функций и возвращаемых значений прямо в коде. В Python это реализовано через type hints (подсказки типов), которые помогают разработчикам и инструментам лучше понимать код.

История и эволюция

Пython долгое время был динамически типизированным языком. Type hints были добавлены в Python 3.5 (PEP 484), что позволило добавить явную типизацию без изменения поведения кода во время выполнения.

Базовая синтаксис

# Аннотирование переменной
x: int = 5
name: str = "Alice"
is_active: bool = True

# Аннотирование параметров функции
def greet(name: str) -> str:
    return f"Hello, {name}!"

# Несколько параметров
def add(a: int, b: int) -> int:
    return a + b

# Без инициализации (только аннотация)
age: int  # Переменная ещё не присвоена

Сложные типы

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

# Коллекции
numbers: List[int] = [1, 2, 3, 4]
user_data: Dict[str, str] = {"name": "Alice", "email": "alice@example.com"}
coordinates: Tuple[float, float] = (10.5, 20.3)

# Optional - может быть None
def find_user(user_id: int) -> Optional[str]:
    if user_id == 1:
        return "Alice"
    return None  # Разрешено вернуть None

# Union - несколько возможных типов
def process_value(value: Union[int, str]) -> str:
    if isinstance(value, int):
        return str(value * 2)
    return value.upper()

# Списки переменной длины
from typing import Set, Deque
valid_ids: Set[int] = {1, 2, 3, 4, 5}

Функции и классы

from typing import Callable

# Аннотирование функций как параметров
def execute_operation(func: Callable[[int, int], int], a: int, b: int) -> int:
    return func(a, b)

def multiply(x: int, y: int) -> int:
    return x * y

result = execute_operation(multiply, 5, 3)  # 15

# Классы
class User:
    def __init__(self, name: str, age: int) -> None:
        self.name: str = name
        self.age: int = age
    
    def get_info(self) -> str:
        return f"{self.name} is {self.age} years old"
    
    def birthday(self) -> None:  # None - функция ничего не возвращает
        self.age += 1

Типы в Python 3.10+ (современный синтаксис)

# Вместо Union используем |
value: int | str = 42
value = "hello"  # Оба типа разрешены

# Вместо Optional используем | None
result: str | None = None

# Более читаемо для коллекций
users: list[dict[str, int]] = [
    {"id": 1, "age": 25},
    {"id": 2, "age": 30}
]

Generics (обобщённые типы)

from typing import TypeVar, Generic

# TypeVar - переменная типа
T = TypeVar('T')  # Может быть любым типом

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

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

# Функция, работающая с любым типом
def first(items: list[T]) -> T:
    return items[0]

num = first([1, 2, 3])  # T = int
text = first(["a", "b"])  # T = str

Протоколы (Protocols)

from typing import Protocol

# Определяем структуру без наследования
class Drawable(Protocol):
    def draw(self) -> str:
        ...

class Circle:
    def draw(self) -> str:
        return "Drawing circle"

class Square:
    def draw(self) -> str:
        return "Drawing square"

# Обе функции работают благодаря протоколу
def render(shape: Drawable) -> None:
    print(shape.draw())

render(Circle())  # Работает, хотя Circle не наследует Drawable
render(Square())  # Работает благодаря структурной типизации

Проверка типов в runtime

# Python НЕ проверяет типы автоматически во время выполнения
def add(a: int, b: int) -> int:
    return a + b

# Это работает, несмотря на аннотацию int
result = add("5", "10")  # Возвращает "510", без ошибки!
print(result)  # "510"

# Для проверки нужны специальные инструменты
# 1. Type checkers (mypy, pyright, pyre)
# 2. Runtime проверка (typeguard, pydantic)

Инструменты для проверки типов

1. mypy (самый популярный)

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

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

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

# script.py
def greet(name: str) -> str:
    return f"Hello, {name}!"

greet(42)  # mypy: Argument 1 to "greet" has incompatible type "int"

2. Pydantic (валидация + типизация)

from pydantic import BaseModel
from typing import Optional

class User(BaseModel):
    name: str
    age: int
    email: Optional[str] = None

# Автоматическая валидация и преобразование типов
user = User(name="Alice", age=30)  # ✓ OK
user = User(name="Alice", age="30")  # ✓ OK, преобразует в int
user = User(name="Alice", age="not a number")  # ✗ ValidationError

# JSON сериализация
print(user.model_dump_json())
# {"name": "Alice", "age": 30, "email": null}

Преимущества явной типизации

# 1. Самодокументирование
def process_order(order_id: int, customer_id: int) -> dict[str, any]:
    # Сразу ясно, что принимает и возвращает
    pass

# 2. IDE поддержка (автодополнение)
user: User = get_user(1)
user.  # IDE подскажет доступные методы

# 3. Ранее обнаружение ошибок
# Mypy найдёт ошибки до запуска кода
value: int = "not an int"  # Type error!

# 4. Рефакторинг
# При изменении типа IDE найдёт все места, требующие обновления

# 5. Читаемость кода
def send_email(to: str, subject: str, body: str) -> bool:
    # Ясно, что функция принимает строки и возвращает bool
    pass

Практические примеры

from dataclasses import dataclass
from typing import Optional, List
from datetime import datetime

@dataclass
class Post:
    id: int
    title: str
    content: str
    author_id: int
    created_at: datetime
    updated_at: Optional[datetime] = None
    tags: List[str] = None

    def __post_init__(self):
        if self.tags is None:
            self.tags = []

def get_recent_posts(days: int = 7) -> List[Post]:
    # Функция возвращает список постов
    posts: List[Post] = []
    # ... логика получения постов
    return posts

def find_post_by_id(post_id: int) -> Optional[Post]:
    # Может вернуть пост или None
    pass

# Использование
recent = get_recent_posts(days=30)
for post in recent:
    print(f"{post.title} by {post.author_id}")

specific_post = find_post_by_id(42)
if specific_post:
    print(specific_post.content)

Когда использовать явную типизацию

Рекомендуется использовать:

• В производственном коде
• В библиотеках и фреймворках
• На уровне публичного API
• В функциях с сложной логикой

Может быть опционально:

• В скриптах и прототипах
• В коротких функциях (один-два параметра)
• В локальных переменных внутри функций

Итоги

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