Метаклассы в Python: как управлять созданием классов и наследованием

# Создание класса динамически
MyClass = type('MyClass', (object,), {'attribute': 42, 'method': lambda self: self.attribute})

# Эквивалентно
class MyClass(object):
attribute = 42
def method(self):
return self.attribute

# 1. Явное указание через атрибут metaclass
class MyClass(metaclass=MyMetaClass):
pass

# 2. Наследование от класса, у которого уже есть метакласс
class BaseClass(metaclass=MyMetaClass):
pass

class DerivedClass(BaseClass): # Унаследует метакласс от BaseClass
pass

# Демонстрация создания класса с помощью type()
Employee = type(
'Employee', # имя класса
(object,), # кортеж с базовыми классами
{ # словарь с атрибутами и методами
'salary': 0,
'get_salary': lambda self: self.salary
}
)

# Создание экземпляра
e = Employee()
e.salary = 5000
print(e.get_salary()) # Выведет: 5000

class MyMetaclass(type):
def __new__(mcs, name, bases, attrs):
# Модификация атрибутов перед созданием класса
attrs['added_by_metaclass'] = 'This attribute was added by the metaclass'
return super().__new__(mcs, name, bases, attrs)

# Использование метакласса
class MyClass(metaclass=MyMetaclass):
pass

print(MyClass.added_by_metaclass) # Выведет: This attribute was added by the metaclass

class RegisteredMeta(type):
registry = {}

def __new__(mcs, name, bases, attrs):
cls = super().__new__(mcs, name, bases, attrs)
# Не регистрируем абстрактные базовые классы
if attrs.get('__abstract__', False) is not True:
mcs.registry[name] = cls
return cls

@classmethod
def get_registry(mcs):
return dict(mcs.registry)

# Базовый класс с метаклассом
class Plugin(metaclass=RegisteredMeta):
__abstract__ = True # Этот класс не будет зарегистрирован

# Конкретные классы автоматически регистрируются
class AudioPlugin(Plugin):
__abstract__ = False

class VideoPlugin(Plugin):
pass # По умолчанию __abstract__ отсутствует, класс будет зарегистрирован

print(RegisteredMeta.get_registry()) # Выведет: {'AudioPlugin': <class 'AudioPlugin'>, 'VideoPlugin': <class 'VideoPlugin'>}

class RequiredAttributesMeta(type):
def __new__(mcs, name, bases, attrs):
# Пропускаем базовый класс
if name == 'BaseModel':
return super().__new__(mcs, name, bases, attrs)

# Проверяем наличие требуемых атрибутов
required_attrs = getattr(attrs.get('Meta', None), 'required', [])
for attr in required_attrs:
if attr not in attrs:
raise TypeError(f"Класс {name} должен определять атрибут '{attr}'")

return super().__new__(mcs, name, bases, attrs)

class BaseModel(metaclass=RequiredAttributesMeta):
pass

# Этот класс определен корректно
class User(BaseModel):
name = "default"

class Meta:
required = ['name']

# А этот вызовет ошибку при определении
try:
class Product(BaseModel):
class Meta:
required = ['price', 'name']
except TypeError as e:
print(e) # Выведет: Класс Product должен определять атрибут 'price'

class PluginMeta(type):
plugins = {}

def __new__(mcs, name, bases, attrs):
cls = super().__new__(mcs, name, bases, attrs)
# Регистрируем только подклассы, не базовый класс
if name != 'Plugin':
plugin_type = attrs.get('plugin_type', 'default')
mcs.plugins.setdefault(plugin_type, []).append(cls)
return cls

class Plugin(metaclass=PluginMeta):
@classmethod
def get_plugins(cls, plugin_type=None):
if plugin_type:
return PluginMeta.plugins.get(plugin_type, [])
return PluginMeta.plugins

class TextProcessor(Plugin):
plugin_type = 'text'

class ImageProcessor(Plugin):
plugin_type = 'image'

class VideoProcessor(Plugin):
plugin_type = 'video'

# Получение всех плагинов определенного типа
print([p.__name__ for p in Plugin.get_plugins('text')]) # Выведет: ['TextProcessor']

class UpperAttributesMeta(type):
def __new__(mcs, name, bases, attrs):
# Преобразуем строковые атрибуты в верхний регистр
uppercase_attrs = {
key: value.upper() if isinstance(value, str) else value
for key, value in attrs.items()
}
return super().__new__(mcs, name, bases, uppercase_attrs)

class UpperStrings(metaclass=UpperAttributesMeta):
greeting = "hello, world"
number = 42

print(UpperStrings.greeting) # Выведет: HELLO, WORLD
print(UpperStrings.number) # Выведет: 42 (не изменилось, так как не строка)

class Field:
def __init__(self, field_type, required=False):
self.field_type = field_type
self.required = required

class ModelMeta(type):
def __new__(mcs, name, bases, attrs):
# Пропускаем базовый класс
if name == 'Model':
return super().__new__(mcs, name, bases, attrs)

# Собираем все поля
fields = {}
for key, value in list(attrs.items()):
if isinstance(value, Field):
fields[key] = value

# Добавляем информацию о полях как атрибут класса
attrs['_fields'] = fields

# Создаем метод валидации
def validate(self, data):
errors = {}
for field_name, field in self._fields.items():
if field_name not in data and field.required:
errors[field_name] = 'Это поле обязательно'
return errors

attrs['validate'] = validate

return super().__new__(mcs, name, bases, attrs)

class Model(metaclass=ModelMeta):
pass

class User(Model):
name = Field(str, required=True)
email = Field(str, required=True)
age = Field(int, required=False)

# Использование
user_data = {'name': 'John'}
u = User()
print(u.validate(user_data)) # Выведет: {'email': 'Это поле обязательно'}

class SingletonMeta(type):
_instances = {}

def __call__(cls, *args, **kwargs):
if cls not in cls._instances:
cls._instances[cls] = super().__call__(*args, **kwargs)
return cls._instances[cls]

class DatabaseConnection(metaclass=SingletonMeta):
def __init__(self, connection_string):
self.connection_string = connection_string
print(f"Подключение к {connection_string} установлено")

# Создаем два "экземпляра", но получаем один и тот же объект
db1 = DatabaseConnection("postgresql://localhost:5432/mydb")
db2 = DatabaseConnection("postgresql://localhost:5432/mydb") # Сообщение о подключении не появится снова

print(db1 is db2) # Выведет: True

def combine_metaclasses(meta1, meta2):
"""Функция для комбинирования двух метаклассов"""
class CombinedMeta(meta1, meta2):
def __new__(mcs, name, bases, attrs):
# Вызываем __new__ обоих родителей
attrs = meta2.__new__(meta2, name, bases, attrs)
return meta1.__new__(meta1, name, bases, attrs)
return CombinedMeta

class ValidatorMeta(type):
def __new__(mcs, name, bases, attrs):
# Проверяем наличие метода validate
if 'validate' not in attrs and name != 'BaseValidator':
raise TypeError(f"Класс {name} должен определять метод 'validate'")
return super().__new__(mcs, name, bases, attrs)

class LoggerMeta(type):
def __new__(mcs, name, bases, attrs):
# Добавляем логирование ко всем методам
for attr_name, attr_value in attrs.items():
if callable(attr_value) and not attr_name.startswith('__'):
attrs[attr_name] = mcs.add_logging(attr_value)
return super().__new__(mcs, name, bases, attrs)

@staticmethod
def add_logging(method):
def wrapper(*args, **kwargs):
print(f"Вызов метода {method.__name__}")
result = method(*args, **kwargs)
print(f"Метод {method.__name__} завершился")
return result
return wrapper

# Комбинируем метаклассы
CombinedMeta = combine_metaclasses(ValidatorMeta, LoggerMeta)

class FormValidator(metaclass=CombinedMeta):
def validate(self, data):
return all(len(str(value)) > 0 for value in data.values())

def process(self, data):
if self.validate(data):
return "Данные валидны"
return "Данные невалидны"

# Тестируем
validator = FormValidator()
result = validator.process({"name": "John", "email": "john@example.com"})
# Выведет:
# Вызов метода validate
# Метод validate завершился
# Вызов метода process
# Метод process завершился
print(result)

class FieldDescriptor:
def __init__(self, field_name, field_type, default=None):
self.field_name = field_name
self.field_type = field_type
self.default = default
self.private_name = f"_{field_name}"

def __get__(self, instance, owner):
if instance is None:
return self
return getattr(instance, self.private_name, self.default)

def __set__(self, instance, value):
if not isinstance(value, self.field_type):
raise TypeError(f"Ожидался тип {self.field_type.__name__}, получен {type(value).__name__}")
setattr(instance, self.private_name, value)

class ModelMeta(type):
def __new__(mcs, name, bases, attrs):
# Обрабатываем поля и создаем дескрипторы
fields = {}
for key, value in list(attrs.items()):
if isinstance(value, tuple) and len(value) >= 1:
field_type = value[0]
default = value[1] if len(value) > 1 else None
fields[key] = value
# Заменяем определение поля на дескриптор
attrs[key] = FieldDescriptor(key, field_type, default)

# Сохраняем информацию о полях
attrs['_fields'] = fields

return super().__new__(mcs, name, bases, attrs)

class Model(metaclass=ModelMeta):
def __init__(self, **kwargs):
for key, value in kwargs.items():
if key in self._fields:
setattr(self, key, value)

class User(Model):
name = (str,)
age = (int, 0)
active = (bool, True)

# Использование
user = User(name="Alice", age=30)
print(user.name, user.age, user.active) # Выведет: Alice 30 True

try:
user.age = "тридцать" # Вызовет ошибку, так как ожидается int
except TypeError as e:
print(e) # Выведет: Ожидался тип int, получен str

class APIMeta(type):
def __new__(mcs, name, bases, attrs):
# Пропускаем базовый класс
if name == 'APIResource':
return super().__new__(mcs, name, bases, attrs)

# Получаем информацию о ресурсе
resource_name = attrs.get('resource', name.lower())

# Генерируем CRUD-методы
def list_resources(cls):
url = f"/api/{resource_name}/"
print(f"GET запрос к {url}")
return {"method": "list", "url": url}

def create_resource(cls, data):
url = f"/api/{resource_name}/"
print(f"POST запрос к {url} с данными {data}")
return {"method": "create", "url": url, "data": data}

def get_resource(cls, resource_id):
url = f"/api/{resource_name}/{resource_id}/"
print(f"GET запрос к {url}")
return {"method": "get", "url": url, "id": resource_id}

def update_resource(cls, resource_id, data):
url = f"/api/{resource_name}/{resource_id}/"
print(f"PUT запрос к {url} с данными {data}")
return {"method": "update", "url": url, "id": resource_id, "data": data}

def delete_resource(cls, resource_id):
url = f"/api/{resource_name}/{resource_id}/"
print(f"DELETE запрос к {url}")
return {"method": "delete", "url": url, "id": resource_id}

# Добавляем методы в класс
attrs['list'] = classmethod(list_resources)
attrs['create'] = classmethod(create_resource)
attrs['get'] = classmethod(get_resource)
attrs['update'] = classmethod(update_resource)
attrs['delete'] = classmethod(delete_resource)

return super().__new__(mcs, name, bases, attrs)

class APIResource(metaclass=APIMeta):
pass

class UserResource(APIResource):
resource = 'users'

# Использование
users = UserResource.list() # Выведет: GET запрос к /api/users/
user = UserResource.get(42) # Выведет: GET запрос к /api/users/42/