Практическое руководство по типам объектов в Python

Расширенные примеры работы с типами объектов

Данный раздел содержит нетривиальные сценарии, демонстрирующие гибкость системы типов Python.

Пример 1: Создание собственного метакласса для перехвата создания классов

Метакласс позволяет контролировать процесс создания класса. В примере ниже метакласс автоматически добавляет проверку типа для атрибутов.

class TypedMeta(type):
    def __new__(cls, name, bases, dct):
        for attr, value in dct.items():
            if not attr.startswith('_') and callable(value):
                dct[attr] = cls._make_checked(value)
        return super().__new__(cls, name, bases, dct)

    @staticmethod
    def _make_checked(func):
        import functools
        @functools.wraps(func)
        def wrapper(self, *args, **kwargs):
            # проверка типов аргументов
            return func(self, *args, **kwargs)
        return wrapper

class MyClass(metaclass=TypedMeta):
    def method(self, x: int, y: str):
        return x, y

obj = MyClass()
print(type(obj).__name__)  # MyClass
print(obj.method(10, 'hi'))  # (10, 'hi')

Пример 2: Проверка generic типов с помощью __orig_class__

Начиная с Python 3.7, generic-классы (например, List[int]) хранят информацию о параметризации в атрибуте __orig_class__ (доступен в методе __init_subclass__ или при явном обращении).

from typing import List, TypeVar, Generic

T = TypeVar('T')
class MyList(Generic[T]):
    def __init__(self):
        pass

ml = MyList[int]()
print(type(ml).__origin__)  # <class 'MyList'>
# Получить параметр типа можно через __orig_bases__ (Python 3.8+)
# или используя get_type_hints на классе, если есть аннотации.

(В зависимости от версии Python, вывод может отличаться. В Python 3.12+ можно использовать type[MyList[int]]).

Пример 3: Структурная типизация с помощью typing.Protocol

Протоколы позволяют проверять наличие методов без явного наследования (утиная типизация на уровне типов).

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(obj: Drawable) -> str:
    return obj.draw()

print(render(Circle()))  # Drawing circle
print(render(Square()))  # Drawing square
# isinstance(Circle(), Drawable) - также работает, если используется @runtime_checkable

Drawing circle
Drawing square

Пример 4: Проверка на наличие атрибутов с hasattr() и getattr()

Иногда вместо проверки типа логичнее проверить, есть ли у объекта нужный атрибут или метод. Это основа динамической диспетчеризации.

class Duck:
    def quack(self):
        return "Quack!"

class Person:
    def quack(self):
        return "Imitating duck"

def make_it_quack(thing):
    if hasattr(thing, 'quack'):
        return thing.quack()
    else:
        return "Can't quack"

print(make_it_quack(Duck()))    # Quack!
print(make_it_quack(Person()))  # Imitating duck
print(make_it_quack(42))        # Can't quack

Quack!
Imitating duck
Can't quack

Пример 5: Использование inspect.signature для проверки аргументов функции

Модуль inspect позволяет анализировать сигнатуру функций, включая аннотации типов. Это может применяться при написании декораторов, проверяющих типы.

import inspect

def checked(func):
    sig = inspect.signature(func)
    def wrapper(*args, **kwargs):
        bound = sig.bind(*args, **kwargs)
        for name, value in bound.arguments.items():
            param = sig.parameters[name]
            if param.annotation is not param.empty:
                if not isinstance(value, param.annotation):
                    raise TypeError(f"Argument {name} must be {param.annotation}")
        return func(*args, **kwargs)
    return wrapper

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

print(add(2, 3))  # 5
# print(add(2.5, 3))  # TypeError: Argument a must be <class 'int'>

5

Пример 6: Проверка типов через typing.get_type_hints с учётом переменных класса

Функция get_type_hints может разрешать строковые аннотации и вычислять типы из аннотаций базовых классов.

from typing import get_type_hints

class Base:
    x: int

class Child(Base):
    y: str

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

{'y': <class 'str'>, 'x': <class 'int'>}