Skip to content

Метаклассы в Python metaclasses ​

До сих пор мы работали по стандартной схеме: класс — это «чертеж», а объект — это экземпляр, созданный по этому чертежу. Но задумывались ли вы когда-нибудь, а что такое сам класс в Python?

В Python действует абсолютное правило: всё является объектом. Это значит, что сам класс (например, ParcelBox) — это тоже объект, который лежит в оперативной памяти компьютера. А раз класс — это объект, у него тоже должен быть свой «чертеж». Чертежи, которые создают другие классы, называются метаклассами.

На этом уроке мы разберем, как устроен главный системный метакласс type, научимся писать собственные метаклассы для жесткого контроля архитектуры приложения и применим их для валидации структуры Почтовой Коробки еще до момента запуска основной программы.

1. Кто создает классы? Системный метакласс type ​

Если вызвать встроенную функцию type() у обычного объекта (например, строки или экземпляра коробки), Python вернет класс, по которому этот объект был создан. Но что произойдет, если вызвать type() у самого класса?

python
class ParcelBox: pass

box = ParcelBox()
print(type(box))        # Вывод: <class '__main__.ParcelBox'> (класс объекта)
print(type(ParcelBox))  # Вывод: <class 'type'> !!! (метакласс самого класса)
print(type(type))       # Вывод: <class 'type'> (type создал сам себя)

По умолчанию абсолютно все классы в Python создаются системным метаклассом type. Когда интерпретатор видит ключевое слово class MyClass:, он под капотом вызывает type(), передавая туда имя класса, список родителей и словарь с методами.

2. Написание кастомного метакласса для валидации архитектуры ​

Зачем переопределять метакласс? Метакласс перехватывает управление в момент компиляции (создания) самого класса, а не его объектов. Это позволяет устроить жесткую автоматическую проверку кода разработчиков.

Давайте напишем метакласс VerifiedParcelMeta. Он будет автоматически проверять структуру всех создаваемых классов почтовых коробок. Если разработчик напишет класс, имя которого начинается с маленькой буквы, или забудет добавить обязательное поле tracking_number, метакласс заблокирует запуск всей программы еще на этапе импорта модулей.

python
class VerifiedParcelMeta(type):
    """Кастомный метакласс для автоматической проверки структуры классов."""

    def __new__(cls, name: str, bases: tuple, dct: dict) -> type:
        """Метод вызывается, когда Python только считывает код нового класса.

        Args:
            name (str): Имя создаваемого класса.
            bases (tuple): Кортеж родительских классов.
            dct (dict): Словарь всех атрибутов и методов внутри класса.
        """
        print(f"[МЕТАКЛАСС] Сканируем архитектуру нового класса: '{name}'")

        # 1. Проверяем соглашение PEP 8: имя класса должно быть в CamelCase
        if not name[0].isupper():
            raise NameError(f"Критическая ошибка: Имя класса '{name}' должно начинаться с заглавной буквы!")

        # 2. Проверяем наличие обязательного метода инициализации __init__
        if "__init__" not in dct:
            raise AttributeError(f"Критическая ошибка: В классе '{name}' обязан быть конструктор __init__!")

        # Если все проверки пройдены, создаем и возвращаем готовый класс в систему
        return super().__new__(cls, name, bases, dct)


# --- Подключаем метакласс через специальный параметр metaclass ---
class ParcelBox(metaclass=VerifiedParcelMeta):
    """Правильный класс. Успешно пройдет проверку метакласса."""
    def __init__(self, tracking_number: str) -> None:
        self.tracking_number: str = tracking_number


# === Имитация ошибки разработчика ===
try:
    # Попробуем создать класс с нарушением правил PEP 8 (с маленькой буквы)
    class faultyBox(metaclass=VerifiedParcelMeta):
        def __init__(self) -> None: pass
except NameError as e:
    print(f"\n[ЗАЩИТА МЕТАКЛАССА] Сборка программы заблокирована: {e}")

Чек-лист готовности темы ​

Перед тем как перейти к выполнению практических упражнений, убедитесь, что вы:

  • [ ] Твердо усвоили: кастомный метакласс всегда обязан наследоваться от встроенного базового метакласса type (class MyMeta(type):).
  • [ ] Понимаете разницу: __new__ внутри обычного класса создает объект, а __new__ внутри метакласса создает новый класс.
  • [ ] Знаете три обязательных аргумента метода __new__ у метакласса: name (строка с именем), bases (родители) и dct (пространство имен методов и атрибутов класса).

Проверьте себя ​

❓В Python что представляет собой сам класс?
❓Что вернёт `type(ParcelBox)`, если ParcelBox — класс?
❓Кто по умолчанию создаёт все классы в Python?
❓Главная особенность метакласса — что он перехватывает?
❓Какие три аргумента принимает `__new__` внутри метакласса?
❓Что проверяет метакласс `VerifiedParcelMeta` из примера урока?

Практические упражнения для Production-кода ​

Выполните эти 5 практических заданий, чтобы освоить инструменты метапрограммирования, научиться контролировать качество кода на этапе компиляции и реализовывать продвинутые архитектурные паттерны.

Упражнение 1: Метакласс запрета наследования (FinalMeta) ​

В некоторых языках программирования (например, Java) есть ключевое слово final, которое запрещает наследоваться от конкретного класса. В Python такого ключевого слова нет, но его логику можно легко реализовать с помощью метаклассов.

Задание:

  1. Создайте метакласс FinalMeta(type).
  2. В методе __new__ проверяйте аргумент bases (родители). Если длина кортежа bases больше нуля, это значит, что кто-то пытается наследоваться от нашего финального класса. В таком случае выбрасывайте TypeError("Наследование от этого класса строго запрещено!").
  3. Создайте класс SecurePostVault(metaclass=FinalMeta), защищающий главный сейф.
  4. Попробуйте создать дочерний класс HackedVault(SecurePostVault) и убедитесь, что Python заблокирует сборку программы.

Упражнение 2: Автоматическое добавление префикса ко всем методам (PrefixMeta) ​

Метаклассы могут не только проверять, но и динамически изменять содержимое класса (модифицировать словарь dct) прямо во время его создания.

Задание: Создайте метакласс PrefixMeta:

  1. Метод __new__ должен пройтись по словарю dct.
  2. Если ключ является методом (проверьте, что имя функции не начинается на дандер __), переименуйте этот ключ, добавив к нему префикс post_ (например, метод deliver должен превратиться в post_deliver).
  3. Подключите метакласс к классу CourierService со стандартным методом send_package(). Убедитесь, что теперь у объектов этого класса метод вызывается только под именем obj.post_package().

Упражнение 3: Паттерн Singleton на уровне метакласса (SingletonMeta) ​

Ранее мы реализовывали паттерн Одиночка (Singleton) через переопределение метода __new__ внутри самого класса. Однако в крупных проектах гораздо профессиональнее написать один общий метакласс SingletonMeta, который можно будет вешать на любой класс в системе, мгновенно делая его синглтоном без дублирования кода.

Задание: Создайте метакласс SingletonMeta(type):

  1. Внутри метакласса в методе __init__ создайте скрытый атрибут для хранения экземпляра: self._instance = None.
  2. Переопределите метод __call__(self, *args, **kwargs). Метод __call__ у метакласса срабатывает тогда, когда пользователь вызывает основной класс для создания объекта: obj = MyClass().
  3. Внутри __call__ проверяйте: если self._instance равен None, создайте объект через super().__call__(*args, **kwargs) и сохраните его. Если уже создан — просто возвращайте сохраненный экземпляр.
  4. Проверьте работу на классе CentralDatabase.

Упражнение 4: Метакласс принудительного написания документации (DocVerifyMeta) ​

Для поддержания высоких стандартов кодовой базы (Production-ready) все публичные классы и их методы обязаны содержать строки документации (docstrings). Напишем автоматический контролирующий метакласс.

Задание: Создайте метакласс StrictDocMeta:

  1. В методе __new__ проверьте, есть ли строка документации у самого класса: if not dct.get("__doc__"): raise AttributeError.
  2. Пройдитесь по словарю dct и для всех регулярных методов (имена без __) проверьте наличие их собственного __doc__. Если документация отсутствует, выбрасывайте ImportError("Каждый метод обязан содержать строку документации!").
  3. Протестируйте защиту на классе DocumentedParcel.

Упражнение 5: Запрет на использование изменяемых атрибутов класса (NoMutableClassAttributesMeta) ​

Мы подробно изучали, какую колоссальную опасность для архитектуры представляют изменяемые атрибуты класса (например, списки или словари, объявленные прямо в теле класса). Давайте напишем метакласс, который навсегда искоренит эту ошибку в вашем проекте, запретив программистам объявлять такие переменные.

Задание: Создайте метакласс AntiTrapMeta(type):

  1. В методе __new__ проанализируйте все свойства в словаре dct.
  2. Если значением любого свойства является объект типа list, dict или set, метакласс должен выбросить исключение TypeError("Критическая ошибка безопасности! Изменяемые атрибуты класса запрещены. Перенесите их внутрь __init__.").
  3. Убедитесь, что этот метакласс успешно защищает структуру проекта на этапе импорта.

Решения для самопроверки ​

Посмотреть решение Упражнения 1 (FinalMeta)
python
class FinalMeta(type):
    def __new__(cls, name, bases, dct):
        if len(bases) > 0:
            raise TypeError(f"Наследование от класса '{bases[0].__name__}' строго запрещено!")
        return super().__new__(cls, name, bases, dct)

class SecurePostVault(metaclass=FinalMeta):
    pass
Посмотреть решение Упражнения 2 (PrefixMeta)
python
class PrefixMeta(type):
    def __new__(cls, name, bases, dct):
        updated_dct = {}
        for key, value in dct.items():
            # Если это обычный метод, меняем ему имя
            if callable(value) and not key.startswith("__"):
                updated_dct[f"post_{key}"] = value
            else:
                updated_dct[key] = value
        return super().__new__(cls, name, bases, updated_dct)
Посмотреть решение Упражнения 3 (SingletonMeta)
python
class SingletonMeta(type):
    def __init__(cls, name, bases, dct):
        super().__init__(name, bases, dct)
        cls._instance = None

    def __call__(cls, *args, **kwargs):
        if cls._instance is None:
            # Вызов super().__call__ запускает стандартную цепочку __new__ и __init__ класса
            cls._instance = super().__call__(*args, **kwargs)
        return cls._instance
Посмотреть решение Упражнения 4 (DocVerifyMeta)
python
class StrictDocMeta(type):
    def __new__(cls, name, bases, dct):
        if not dct.get("__doc__"):
            raise ImportError(f"Класс '{name}' обязан содержать строку документации __doc__!")
        
        for key, value in dct.items():
            if callable(value) and not key.startswith("__"):
                if not value.__doc__:
                    raise ImportError(f"Метод '{key}' в классе '{name}' обязан быть задокументирован!")
                    
        return super().__new__(cls, name, bases, dct)
Посмотреть решение Упражнения 5 (NoMutableClassAttributesMeta)
python
class AntiTrapMeta(type):
    def __new__(cls, name, bases, dct):
        for key, value in dct.items():
            if isinstance(value, (list, dict, set)):
                raise TypeError(
                    f"Архитектурная ошибка в '{name}': атрибут '{key}' является изменяемым типом. "
                    "Объявление списков/словарей на уровне класса запрещено! Перенесите в __init__."
                )
        return super().__new__(cls, name, bases, dct)