Как Type hinting влияет на производительность?

Type Hinting и производительность: мифы и реальность

Это один из самых частых вопросов при интервью. Коротко: type hints НЕ влияют на production-производительность, но косвенно влияют через инструменты статического анализа. Разберёмся подробно.

1. Type hints в runtime НЕ выполняются

import time
from typing import List

def without_hints(numbers):
    return sum(numbers)

def with_hints(numbers: List[int]) -> int:
    return sum(numbers)

data = list(range(1_000_000))

# Бенчмарк
start = time.perf_counter()
for _ in range(1000):
    without_hints(data)
time_without = time.perf_counter() - start

start = time.perf_counter()
for _ in range(1000):
    with_hints(data)
time_with = time.perf_counter() - start

print(f"Without hints: {time_without:.4f}s")
print(f"With hints:    {time_with:.4f}s")
print(f"Difference:    {abs(time_with - time_without) / time_without * 100:.2f}%")

Type hints полностью игнорируются интерпретатором Python при выполнении кода. Они существуют только в AST и в __annotations__.

2. Как Python обрабатывает типы

def greet(name: str, age: int) -> str:
    return f"Hello, {name} (age {age})"

print(greet.__annotations__)
# {name: str, age: int, return: str}

# Но интерпретатор НЕ проверяет типы
print(greet(123, "not_an_int"))  # Works fine!
# Hello, 123 (age not_an_int)

Типы — это просто аннотации для инструментов, не для runtime.

3. Косвенное влияние на производительность

Оптимизация через type checker

Тип-чекер может выявить баги, которые замедляют код:

# Неправильно: repeated list concat O(n²)
result = []
for item in items:
    result = result + [item]  # МЕДЛЕННО!

# Правильно: append O(n)
result = []
for item in items:
    result.append(item)  # БЫСТРО!

Правильные типы помогают вам думать яснее и писать оптимальный код.

4. Реальное влияние: инструменты и разработка

from typing import Dict, List

class DataProcessor:
    def __init__(self, data: List[Dict[str, int]]):
        self.data = data
        self._cache: Dict[str, int] = {}
    
    def process(self, key: str) -> int:
        if key in self._cache:
            return self._cache[key]
        
        result = sum(item.get(key, 0) for item in self.data)
        self._cache[key] = result
        return result

Это быстро благодаря правильной логике (кэширование), а не благодаря типам.

5. Когда type hints нужны

# Публичное API
def create_user(name: str, email: str, age: int) -> dict:
    pass

# Сложные функции
def calculate_metrics(
    data: List[tuple],
    weights: Dict[str, float],
    threshold: float = 0.5
) -> dict:
    pass

6. Runtime type checking замедляет код

from typeguard import typechecked

@typechecked
def check_types(x: int, y: str) -> str:
    # Проверяет типы в runtime - медленнее на 5-50%
    return f"{x}{y}"

def no_check(x: int, y: str) -> str:
    # Type hints без проверки - быстро
    return f"{x}{y}"

7. Best practices для производительности

# Правильно: type hints как аннотации
from typing import List, Dict, Optional

def get_user_preferences(user_id: int) -> Optional[Dict[str, str]]:
    pass

# Неправильно: runtime type checking везде
@typechecked  # Замедляет!
def get_user_preferences(user_id: int) -> Optional[Dict[str, str]]:
    pass

# Компромисс: selective checks только в development
if DEBUG:
    @typechecked
    def get_user_preferences(user_id: int) -> Optional[Dict[str, str]]:
        pass

Итоговый вывод

• Type hints в коде: Нулевое влияние на runtime
• Mypy/Pyright анализ: Косвенное положительное (выявляет баги)
• Runtime type checking: Отрицательное (5-50% медленнее)
• IDE подсказки: Положительное (пишешь правильнее)

Type hints — это про правильность и читаемость, а не про скорость. Используй их всегда, но не включай runtime проверки без необходимости.