Какие знаешь способы проверки типа данных в Python?

Способы проверки типа данных в Python

Проверка типов — важная часть написания надежного кода на Python. Рассмотрю основные подходы от базовых до продвинутых.

1. Функция type()

Самый простой способ — получить тип объекта напрямую.

# Базовое использование
value = 42
print(type(value))  # <class 'int'>
print(type(value) == int)  # True

# Сравнение типов
if type(value) is int:
    print("Это целое число")

# Со строками
name = "Alice"
print(type(name))  # <class 'str'>
print(type(name).__name__)  # 'str'

Минусы: не работает с наследованием и типом None.

2. isinstance() — правильный способ

Это рекомендуемый способ для проверки типов. Работает с наследованием и множественными типами.

value = 42

# Проверка одного типа
if isinstance(value, int):
    print("Целое число")

# Проверка нескольких типов
if isinstance(value, (int, float)):
    print("Число (целое или дробное)")

# С наследованием
class Animal:
    pass

class Dog(Animal):
    pass

dog = Dog()
print(isinstance(dog, Dog))     # True
print(isinstance(dog, Animal))  # True - работает с наследованием!

# None - особый случай
value = None
print(isinstance(value, type(None)))  # True
print(value is None)  # Лучший способ проверить None

3. Type hints и статическая проверка

Python 3.5+ поддерживает type hints для документирования и статической проверки.

from typing import Union, Optional, List, Dict

# Простые типы
def greet(name: str) -> str:
    return f"Hello, {name}"

# Несколько типов
def process_data(value: Union[int, float]) -> None:
    print(value)

# Опциональный параметр
def get_user(user_id: Optional[int] = None) -> dict:
    if user_id is None:
        return {}
    return {"id": user_id}

# Коллекции
def sum_numbers(numbers: List[int]) -> int:
    return sum(numbers)

def get_config() -> Dict[str, str]:
    return {"host": "localhost", "port": "5432"}

# Пользовательские типы
class User:
    pass

def create_user(name: str) -> User:
    return User()

Важно: type hints не проверяются во время выполнения! Это только для документации и IDE.

4. Утилиты для проверки типов

Для проверки во время выполнения нужны специальные библиотеки.

# pydantic — популярная библиотека для валидации
from pydantic import BaseModel

class User(BaseModel):
    name: str
    age: int

# Автоматическая проверка типов
user = User(name="Alice", age=30)  # OK
user = User(name="Bob", age="thirty")  # Ошибка: возьмет int('thirty')

# С опциями
class Product(BaseModel):
    id: int
    name: str
    price: float = 0.0  # Значение по умолчанию
    in_stock: bool = True

product = Product(id=1, name="Book", price=9.99)

5. typing.get_type_hints()

Получить type hints программно.

from typing import get_type_hints

def process(x: int, y: str) -> bool:
    return True

hints = get_type_hints(process)
print(hints)
# {'x': <class 'int'>, 'y': <class 'str'>, 'return': <class 'bool'>}

6. Проверка во время выполнения

Для серьезной валидации используй обработку исключений или функции проверки.

# Базовая проверка
def divide(a, b):
    if not isinstance(a, (int, float)):
        raise TypeError(f"a должно быть числом, получено {type(a).__name__}")
    if not isinstance(b, (int, float)):
        raise TypeError(f"b должно быть числом, получено {type(b).__name__}")
    if b == 0:
        raise ValueError("b не может быть нулем")
    return a / b

# Более изящный способ с декоратором
from functools import wraps

def validate_types(**type_checks):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            # Проверяем типы параметров
            for arg_name, arg_type in type_checks.items():
                if arg_name in kwargs:
                    if not isinstance(kwargs[arg_name], arg_type):
                        raise TypeError(f"{arg_name} должен быть {arg_type}")
            return func(*args, **kwargs)
        return wrapper
    return decorator

@validate_types(name=str, age=int)
def create_user(name, age):
    return {"name": name, "age": age}

create_user("Alice", 30)  # OK
create_user("Bob", "thirty")  # Ошибка!

7. Проверка с protocol (структурная типизация)

Проверка по интерфейсу, а не по типу.

from typing import Protocol

class Drawable(Protocol):
    """Что-то, что можно рисовать"""
    def draw(self) -> None:
        ...

class Circle:
    def draw(self) -> None:
        print("Рисую окружность")

class Square:
    def draw(self) -> None:
        print("Рисую квадрат")

def render(shape: Drawable):
    shape.draw()  # Работает с Circle, Square и любым другим с методом draw()

render(Circle())  # OK
render(Square())  # OK

8. Специальные проверки

# Проверка на None
value = None
if value is None:
    print("Это None")

# Проверка на callable
from collections.abc import Callable
func = lambda x: x * 2
if callable(func):
    print("Это функция")

# Проверка на итерируемое
from collections.abc import Iterable
data = [1, 2, 3]
if isinstance(data, Iterable):
    print("Это итерируемое")

# Проверка на класс
import inspect
if inspect.isclass(str):
    print("Это класс")

if inspect.isfunction(lambda: None):
    print("Это функция")

Сравнение подходов

Лучшие практики

1. Используй isinstance(), а не type()

# ❌ Плохо
if type(obj) == MyClass:
    pass

# ✅ Хорошо
if isinstance(obj, MyClass):
    pass

2. Type hints везде

# ✅ Всегда добавляй type hints
def calculate(x: int, y: int) -> int:
    return x + y

3. Проверяй None явно

# ✅ Правильно
if value is None:
    pass

# ❌ Неправильно
if not value:  # Может быть 0, пустая строка и т.д.
    pass

4. Используй правильные инструменты для валидации

• Простая проверка: isinstance()
• Валидация данных: Pydantic
• Статическая проверка: mypy, pyright

Этот многоуровневый подход обеспечивает надежность и документированность кода.