Как декораторы классов в Python изменяют поведение программы

@my_decorator
class MyClass:
def __init__(self, value):
self.value = value

class MyClass:
def __init__(self, value):
self.value = value

MyClass = my_decorator(MyClass)

def simple_decorator(cls):
# Выполняем модификацию класса
cls.new_attribute = "I was added by a decorator"
return cls

@simple_decorator
class Example:
pass

print(Example.new_attribute) # Выведет: "I was added by a decorator"

def parametrized_decorator(param):
def decorator(cls):
cls.decorator_param = param
return cls
return decorator

@parametrized_decorator("Some value")
class ParametrizedExample:
pass

print(ParametrizedExample.decorator_param) # Выведет: "Some value"

def wrap_class(cls):
class Wrapper:
def __init__(self, *args, **kwargs):
self.wrapped = cls(*args, **kwargs)

def __getattr__(self, name):
return getattr(self.wrapped, name)

return Wrapper

@wrap_class
class MyClass:
def __init__(self, value):
self.value = value

def get_value(self):
return self.value

# Теперь при создании экземпляра MyClass
# фактически создается экземпляр Wrapper
obj = MyClass(42)
print(obj.get_value()) # Выведет: 42

def preserve_metadata(cls):
def decorator(wrapped_cls):
wrapped_cls.__name__ = cls.__name__
wrapped_cls.__doc__ = cls.__doc__
wrapped_cls.__module__ = cls.__module__
return wrapped_cls
return decorator

def singleton(cls):
"""Декоратор, превращающий класс в синглтон."""
instances = {}

def get_instance(*args, **kwargs):
if cls not in instances:
instances[cls] = cls(*args, **kwargs)
return instances[cls]

return get_instance

@singleton
class ConfigManager:
def __init__(self):
self.settings = {}

def set(self, key, value):
self.settings[key] = value

def get(self, key, default=None):
return self.settings.get(key, default)

# Все вызовы создают один и тот же экземпляр
config1 = ConfigManager()
config2 = ConfigManager()
config1.set('debug', True)

print(config2.get('debug')) # Выведет: True
print(config1 is config2) # Выведет: True

class Registry:
classes = {}

@classmethod
def register(cls, registered_class):
cls.classes[registered_class.__name__] = registered_class
return registered_class

@classmethod
def get_class(cls, name):
return cls.classes.get(name)

@Registry.register
class Plugin1:
pass

@Registry.register
class Plugin2:
pass

# Позже где-то в коде
plugin_class = Registry.get_class("Plugin1")
instance = plugin_class()

def validate_attributes(cls):
original_init = cls.__init__

def new_init(self, *args, **kwargs):
original_init(self, *args, **kwargs)

for attr, attr_type in getattr(cls, '__annotations__', {}).items():
if hasattr(self, attr):
value = getattr(self, attr)
if not isinstance(value, attr_type):
raise TypeError(f"Attribute {attr} must be of type {attr_type.__name__}")

cls.__init__ = new_init
return cls

@validate_attributes
class Person:
name: str
age: int

def __init__(self, name, age):
self.name = name
self.age = age

# Это работает
person = Person("John", 30)

# Это вызовет TypeError
try:
person_error = Person("Alice", "not an integer")
except TypeError as e:
print(e) # Выведет: Attribute age must be of type int

class CountInstances:
def __init__(self):
self.count = 0

def __call__(self, cls):
original_init = cls.__init__

def new_init(self_instance, *args, **kwargs):
original_init(self_instance, *args, **kwargs)
self.count += 1
self_instance.instance_number = self.count

cls.__init__ = new_init
return cls

counter = CountInstances()

@counter
class A:
pass

@counter
class B:
pass

a1, a2 = A(), A()
b1 = B()

print(a1.instance_number) # 1
print(a2.instance_number) # 2
print(b1.instance_number) # 3
print(counter.count) # 3

def add_greeting(cls):
cls.greet = lambda self: f"Hello, I am {self.__class__.__name__}"
return cls

def add_farewell(cls):
cls.farewell = lambda self: f"Goodbye from {self.__class__.__name__}"
return cls

@add_greeting
@add_farewell
class Person:
def __init__(self, name):
self.name = name

person = Person("Alice")
print(person.greet()) # "Hello, I am Person"
print(person.farewell()) # "Goodbye from Person"

class LoggerMetaclass(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.log_calls(attr_value, attr_name)
return super().__new__(mcs, name, bases, attrs)

@staticmethod
def log_calls(method, method_name):
def wrapper(self, *args, **kwargs):
print(f"Calling {method_name} with args: {args}, kwargs: {kwargs}")
result = method(self, *args, **kwargs)
print(f"{method_name} returned {result}")
return result
return wrapper

def immutable(cls):
original_setattr = cls.__setattr__

def __setattr__(self, key, value):
if hasattr(self, key):
raise AttributeError(f"Cannot modify immutable attribute {key}")
original_setattr(self, key, value)

cls.__setattr__ = __setattr__
return cls

@immutable
class Logger(metaclass=LoggerMetaclass):
def __init__(self, name):
self.name = name

def process(self, data):
return data.upper()

logger = Logger("app")
logger.process("test") # Логгирует вызов и возврат
try:
logger.name = "new_name" # Вызывает AttributeError
except AttributeError as e:
print(e)

def rest_api(base_url):
def decorator(cls):
if hasattr(cls, 'endpoints'):
for endpoint, methods in cls.endpoints.items():
for method, details in methods.items():
handler_name = f"{method}_{endpoint}"

def create_handler(m, ep, func_name):
def handler(self, *args, **kwargs):
url = f"{base_url}/{ep}"
print(f"Making {m.upper()} request to {url}")
# Здесь была бы реальная HTTP-логика
return f"Response from {func_name}"
return handler

setattr(cls, handler_name, create_handler(method, endpoint, details.get('name', handler_name)))

return cls
return decorator

@rest_api("https://api.example.com/v1")
class UserService:
endpoints = {
'users': {
'get': {'name': 'get_users'},
'post': {'name': 'create_user'}
},
'users/{id}': {
'get': {'name': 'get_user'},
'delete': {'name': 'delete_user'}
}
}

service = UserService()
print(service.get_users()) # "Making GET request to https://api.example.com/v1/users"
print(service.create_user()) # "Making POST request to https://api.example.com/v1/users"

def memoize_methods(cls):
"""Декоратор класса, добавляющий мемоизацию всех методов."""
original_methods = {}

for name, method in cls.__dict__.items():
if callable(method) and not name.startswith('__'):
original_methods[name] = method

def create_memoized(method_name, original_method):
cache = {}

def memoized(self, *args, **kwargs):
key = str(args) + str(sorted(kwargs.items()))
if key not in cache:
cache[key] = original_method(self, *args, **kwargs)
return cache[key]

return memoized

for name, method in original_methods.items():
setattr(cls, name, create_memoized(name, method))

return cls

@memoize_methods
class MathOperations:
def factorial(self, n):
print(f"Computing factorial for {n}")
if n <= 1:
return 1
return n * self.factorial(n – 1)

def fibonacci(self, n):
print(f"Computing fibonacci for {n}")
if n <= 1:
return n
return self.fibonacci(n – 1) + self.fibonacci(n – 2)

math = MathOperations()
print(math.factorial(5)) # Выполняет вычисления
print(math.factorial(5)) # Использует кэш, без вычислений
print(math.fibonacci(6)) # Здесь особенно заметно преимущество, так как избегается экспоненциальное количество рекурсивных вызовов.

def lazy_properties(cls):
"""Превращает все методы с именами, начинающимися с 'compute_', в ленивые свойства."""
for name, method in list(cls.__dict__.items()):
if callable(method) and name.startswith('compute_'):
property_name = name[8:] # Убираем 'compute_'

def create_property(method_name, compute_method):
private_name = f"_{method_name}"

def getter(self):
if not hasattr(self, private_name):
setattr(self, private_name, compute_method(self))
return getattr(self, private_name)

return property(getter)

setattr(cls, property_name, create_property(property_name, method))
delattr(cls, name)

return cls

@lazy_properties
class DataProcessor:
def __init__(self, data):
self.data = data

def compute_stats(self):
print("Computing statistics...")
# В реальном коде здесь было бы тяжелое вычисление
return {"mean": sum(self.data) / len(self.data), "max": max(self.data)}

def compute_normalized(self):
print("Normalizing data...")
max_value = max(self.data)
return [x / max_value for x in self.data]

processor = DataProcessor([1, 5, 3, 9, 2])
# Вычисления не выполняются при создании объекта
print("Object created")

# Вычисляется только при первом доступе
print(processor.stats) # Выведет: Computing statistics... затем результат
print(processor.stats) # Повторный доступ не вызывает пересчета

# Другие ленивые свойства вычисляются независимо
print(processor.normalized) # Выведет: Normalizing data... затем результат

def use_slots(cls):
"""Добавляет __slots__ к классу на основе аннотаций типов."""
annotations = getattr(cls, '__annotations__', {})
cls.__slots__ = tuple(annotations.keys())

# Удаляем __dict__ из базовых классов, чтобы не конфликтовал со __slots__
original_new = cls.__new__

def __new__(cls, *args, **kwargs):
for base in cls.__mro__[1:]: # Исключаем сам класс
if hasattr(base, '__dict__') and not hasattr(base, '__slots__'):
base.__slots__ = ()
return original_new(cls, *args, **kwargs)

cls.__new__ = classmethod(__new__)
return cls

@use_slots
class Point:
x: float
y: float

def __init__(self, x, y):
self.x = x
self.y = y

def distance(self, other):
return ((self.x – other.x) ** 2 + (self.y – other.y) ** 2) ** 0.5

# Создание множества точек будет использовать значительно меньше памяти
points = [Point(i, i) for i in range(1000000)]

import time
import functools

def profile_methods(cls):
"""Декоратор, добавляющий профилирование всех публичных методов класса."""
method_stats = {}

for name, method in cls.__dict__.items():
if callable(method) and not name.startswith('_'):
@functools.wraps(method)
def profiled_method(self, *args, method=method, method_name=name, **kwargs):
start = time.time()
result = method(self, *args, **kwargs)
elapsed = time.time() – start

if method_name not in method_stats:
method_stats[method_name] = {"calls": 0, "total_time": 0, "avg_time": 0}

stats = method_stats[method_name]
stats["calls"] += 1
stats["total_time"] += elapsed
stats["avg_time"] = stats["total_time"] / stats["calls"]

return result

setattr(cls, name, profiled_method)

def get_profile_stats(self):
return method_stats

cls.get_profile_stats = get_profile_stats
return cls

@profile_methods
class SortingAlgorithms:
def bubble_sort(self, arr):
n = len(arr)
arr = arr.copy()
for i in range(n):
for j in range(0, n – i – 1):
if arr[j] > arr[j + 1]:
arr[j], arr[j + 1] = arr[j + 1], arr[j]
return arr

def insertion_sort(self, arr):
arr = arr.copy()
for i in range(1, len(arr)):
key = arr[i]
j = i – 1
while j >= 0 and key < arr[j]:
arr[j + 1] = arr[j]
j -= 1
arr[j + 1] = key
return arr

sorter = SortingAlgorithms()
data = list(range(1000))
data.reverse()

sorter.bubble_sort(data)
sorter.insertion_sort(data)
sorter.bubble_sort(data[:500]) # Тест на меньшем наборе данных

print(sorter.get_profile_stats()) # Выводит статистику по времени выполнения методов