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

def say_hello(self):
return f"Hello, my name is {self.name}"

# Создаем объект
john = Person("John")

# Определяем новый метод
def sing(self, song):
return f"{self.name} is singing {song}"

# Добавляем метод к экземпляру
import types
john.sing = types.MethodType(sing, john)

# Теперь можем использовать новый метод
print(john.sing("Jingle Bells")) # John is singing Jingle Bells

instance.new_method = types.MethodType(function, instance)

import types

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

def process(self):
return [x * 2 for x in self.data]

# Создаем экземпляр
processor = DataProcessor([1, 2, 3, 4, 5])

# Определяем новые функции
def filter_even(self):
return [x for x in self.data if x % 2 == 0]

def get_sum(self):
return sum(self.data)

# Добавляем функции как методы к экземпляру
processor.filter_even = types.MethodType(filter_even, processor)
processor.get_sum = types.MethodType(get_sum, processor)

# Используем новые методы
print(processor.process()) # [2, 4, 6, 8, 10]
print(processor.filter_even()) # [2, 4]
print(processor.get_sum()) # 15

# Добавление метода на уровне класса
DataProcessor.filter_even = filter_even
DataProcessor.get_sum = get_sum

# Создаем новый экземпляр
new_processor = DataProcessor([10, 15, 20, 25])

# Новые методы уже доступны
print(new_processor.filter_even()) # [10, 20]

class Calculator:
def add(self, a, b):
return a + b

# Создание экземпляра
calc = Calculator()

# Добавление метода через прямое присваивание
def multiply(self, a, b):
return a * b

calc.multiply = multiply

# Использование (требует явной передачи self)
print(calc.multiply(calc, 5, 3)) # 15

def divide(self, a, b):
if b == 0:
raise ValueError("Division by zero")
return a / b

# Добавление с помощью setattr + types.MethodType
setattr(calc, 'divide', types.MethodType(divide, calc))

# Использование
print(calc.divide(10, 2)) # 5.0

class MathMixin:
def square(self, x):
return x * x

def power(self, base, exponent):
return base ** exponent

class EnhancedCalculator(Calculator, MathMixin):
pass

# Создаём объект с расширенной функциональностью
enhanced_calc = EnhancedCalculator()
print(enhanced_calc.add(2, 3)) # 5
print(enhanced_calc.square(4)) # 16
print(enhanced_calc.power(2, 3)) # 8

def add_geometry_methods(cls):
def area(self, radius):
return 3.14 * radius * radius

def circumference(self, radius):
return 2 * 3.14 * radius

cls.area = area
cls.circumference = circumference

return cls

@add_geometry_methods
class Circle:
pass

# Использование
circle = Circle()
print(circle.area(5)) # 78.5
print(circle.circumference(5)) # 31.4

class ExtendedMeta(type):
def __new__(mcs, name, bases, attributes):
# Добавляем новые методы в класс
attributes['get_info'] = lambda self: f"Instance of {name}"
attributes['version'] = '1.0'

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

class Product(metaclass=ExtendedMeta):
def __init__(self, name, price):
self.name = name
self.price = price

# Все экземпляры Product автоматически получают метод get_info
product = Product("Laptop", 1000)
print(product.get_info()) # "Instance of Product"
print(Product.version) # "1.0"

def add_tracking(cls):
original_init = cls.__init__

def __init__(self, *args, **kwargs):
self.created_at = datetime.now()
self.accessed_count = 0
original_init(self, *args, **kwargs)

def get_age(self):
return (datetime.now() – self.created_at).total_seconds()

def track_access(method):
def wrapper(self, *args, **kwargs):
self.accessed_count += 1
return method(self, *args, **kwargs)
return wrapper

# Заменяем __init__
cls.__init__ = __init__

# Добавляем новый метод
cls.get_age = get_age

# Модифицируем существующие методы
for name, method in list(cls.__dict__.items()):
if callable(method) and not name.startswith('__'):
setattr(cls, name, track_access(method))

return cls

@add_tracking
class User:
def __init__(self, name):
self.name = name

def greet(self):
return f"Hello, {self.name}!"

# Использование
user = User("Alice")
print(user.greet()) # Hello, Alice!
print(user.accessed_count) # 1
print(user.get_age()) # количество секунд с момента создания

def create_model(name, fields):
"""Создает класс модели с динамическими методами для каждого поля"""

attrs = {'__init__': lambda self, **kwargs: setattr(self, '_data', kwargs)}

# Создаем геттеры и сеттеры для каждого поля
for field in fields:
# Геттер
getter_name = f'get_{field}'
getter = lambda self, field=field: self._data.get(field)
attrs[getter_name] = getter

# Сеттер
setter_name = f'set_{field}'
setter = lambda self, value, field=field: self._data.update({field: value})
attrs[setter_name] = setter

# Добавляем метод to_dict
attrs['to_dict'] = lambda self: self._data.copy()

# Создаем класс
return type(name, (), attrs)

# Использование
Person = create_model('Person', ['name', 'age', 'email'])
john = Person(name='John', age=30, email='john@example.com')

print(john.get_name()) # John
john.set_age(31)
print(john.to_dict()) # {'name': 'John', 'age': 31, 'email': 'john@example.com'}

class ServiceProxy:
"""Прокси для удаленного сервиса, динамически создающий методы API"""

def __init__(self, base_url, endpoints):
self.base_url = base_url

# Динамически создаем методы для каждой конечной точки
for endpoint, method in endpoints.items():
def make_request(self, data=None, endpoint=endpoint, method=method):
url = f"{self.base_url}/{endpoint}"
# В реальном коде здесь был бы запрос к API
return f"Making {method} request to {url} with data: {data}"

# Добавляем метод к экземпляру
setattr(self, endpoint, types.MethodType(make_request, self))

# Использование
api = ServiceProxy(
"https://api.example.com",
{
"users": "GET",
"create_user": "POST",
"update_user": "PUT",
"delete_user": "DELETE"
}
)

print(api.users()) # Making GET request to https://api.example.com/users with data: None
print(api.create_user({"name": "Alice"})) # Making POST request...

class User:
def __init__(self, id, name, email):
self.id = id
self.name = name
self.email = email

def save(self):
# Логика сохранения в БД
print(f"Saving user {self.name} to database")

# Создаем функции для различных форматов экспорта
def to_json(self):
import json
return json.dumps({
"id": self.id,
"name": self.name,
"email": self.email
})

def to_xml(self):
return f"""
<user>
<id>{self.id}</id>
<name>{self.name}</name>
<email>{self.email}</email>
</user>
"""

def to_csv(self):
return f"{self.id},{self.name},{self.email}"

# Функция для добавления экспортных возможностей
def add_export_methods(instance, formats=None):
all_formats = {
'json': to_json,
'xml': to_xml,
'csv': to_csv
}

formats = formats or all_formats.keys()

for fmt in formats:
if fmt in all_formats:
method_name = f"to_{fmt}"
setattr(instance, method_name, 
types.MethodType(all_formats[fmt], instance))

return instance

# Использование
user = User(1, "John Doe", "john@example.com")
user = add_export_methods(user, ['json', 'csv'])

print(user.to_json())
print(user.to_csv())
# Если попытаться вызвать user.to_xml(), будет ошибка, т.к. метод не добавлен

class DatabaseService:
def query(self, sql):
return f"Executing SQL: {sql}"

class LoggingService:
def log(self, message):
print(f"LOG: {message}")

class NotificationService:
def send(self, user, message):
print(f"NOTIFICATION to {user}: {message}")

class UserService:
def __init__(self, user_id):
self.user_id = user_id

# Создаем функцию для инъекции зависимостей
def inject_dependencies(instance, dependencies):
for name, service in dependencies.items():
# Создаем метод, который дает доступ к сервису
def get_service(self, service=service):
return service

# Добавляем к экземпляру
method_name = f"get_{name}"
setattr(instance, method_name, types.MethodType(get_service, instance))

return instance

# Использование
user_service = UserService(42)
dependencies = {
'db': DatabaseService(),
'logger': LoggingService(),
'notifications': NotificationService()
}

user_service = inject_dependencies(user_service, dependencies)

# Теперь у объекта есть методы для доступа к зависимостям
db = user_service.get_db()
logger = user_service.get_logger()

print(db.query("SELECT * FROM users"))
logger.log("User service initialized")

import time
import functools

def add_profiling(obj):
# Получаем все методы объекта
methods = [name for name, attr in obj.__class__.__dict__.items() 
if callable(attr) and not name.startswith('__')]

# Создаем метод для получения статистики
def get_profiling_stats(self):
return getattr(self, '_profiling_stats', {})

# Добавляем метод к экземпляру
obj.get_profiling_stats = types.MethodType(get_profiling_stats, obj)

# Инициализируем словарь для статистики
setattr(obj, '_profiling_stats', {})

# Оборачиваем каждый метод в профилировщик
for method_name in methods:
original_method = getattr(obj, method_name)

@functools.wraps(original_method)
def profiled_method(self, *args, method=original_method, name=method_name, **kwargs):
start_time = time.time()
result = method(self, *args, **kwargs)
execution_time = time.time() – start_time

# Обновляем статистику
stats = self._profiling_stats.get(name, {'calls': 0, 'total_time': 0})
stats['calls'] += 1
stats['total_time'] += execution_time
stats['avg_time'] = stats['total_time'] / stats['calls']
self._profiling_stats[name] = stats

return result

# Заменяем метод на профилируемую версию
setattr(obj, method_name, types.MethodType(profiled_method, obj))

return obj

# Использование
class Calculator:
def add(self, a, b):
time.sleep(0.1) # Имитация работы
return a + b

def multiply(self, a, b):
time.sleep(0.2) # Имитация работы
return a * b

# Создаем экземпляр и профилируем его
calc = Calculator()
calc = add_profiling(calc)

# Выполняем некоторые операции
calc.add(5, 3)
calc.add(10, 20)
calc.multiply(4, 5)

# Получаем статистику
print(calc.get_profiling_stats())
# Выводит статистику о времени выполнения каждого метода

# Старый API
class LegacyUser:
def __init__(self, user_id, full_name, mail):
self.user_id = user_id
self.full_name = full_name
self.mail = mail

def get_user_id(self):
return self.user_id

def get_full_name(self):
return self.full_name

def get_mail(self):
return self.mail

# Новый ожидаемый интерфейс
class NewUserInterface:
def get_id(self):
pass

def get_name(self):
pass

def get_email(self):
pass

def full_info(self):
pass

# Функции для адаптации
def get_id(self):
return self.get_user_id()

def get_name(self):
return self.get_full_name()

def get_email(self):
return self.get_mail()

def full_info(self):
return {
'id': self.get_id(),
'name': self.get_name(),
'email': self.get_email()
}

# Функция-адаптер
def adapt_legacy_user(legacy_user):
# Добавляем новые методы
legacy_user.get_id = types.MethodType(get_id, legacy_user)
legacy_user.get_name = types.MethodType(get_name, legacy_user)
legacy_user.get_email = types.MethodType(get_email, legacy_user)
legacy_user.full_info = types.MethodType(full_info, legacy_user)

return legacy_user

# Использование
old_user = LegacyUser(1, "John Smith", "john@example.com")
adapted_user = adapt_legacy_user(old_user)

# Теперь можно использовать с новым интерфейсом
print(adapted_user.get_id()) # 1
print(adapted_user.get_name()) # John Smith
print(adapted_user.full_info()) # {'id': 1, 'name': 'John Smith', 'email': 'john@example.com'}