Python元编程（2）：深入动态与抽象

最新推荐文章于 2026-04-22 17:08:49 发布

原创最新推荐文章于 2026-04-22 17:08:49 发布 · 740 阅读

6 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

收录于

python

在上一篇基础教程中，我们学习了Python元编程的核心概念和基础操作，如type动态生成类、元类（Metaclass）、动态属性与方法等。在本篇中，我们将更进一步，探索元编程的深层应用，包括类装饰器、动态代码生成、行为修改以及实际案例分析。

一、高阶类装饰器

类装饰器可以动态修改类的行为，是元编程的重要工具。

1. 为类添加新功能

示例代码：

def add_repr(cls):
    def __repr__(self):
        return f"{cls.__name__}({', '.join(f'{k}={v}' for k, v in self.__dict__.items())})"
    cls.__repr__ = __repr__
    return cls

@add_repr
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

p = Point(3, 4)
print(p)  # 输出：Point(x=3, y=4)

分析：

类装饰器接收一个类，修改其__repr__方法。
自动为类提供一个友好的字符串表示，减少重复代码。

2. 为类添加行为日志

示例代码：

def log_methods(cls):
    for attr_name, attr_value in cls.__dict__.items():
        if callable(attr_value):
            original_method = attr_value

            def logged_method(*args, **kwargs):
                print(f"Calling method: {attr_name}")
                return original_method(*args, **kwargs)

            setattr(cls, attr_name, logged_method)
    return cls

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

    def subtract(self, a, b):
        return a - b

calc = Calculator()
print(calc.add(2, 3))  # 输出方法调用日志和结果

二、动态代码生成与执行

Python的动态特性允许直接生成和执行代码，提供极高的灵活性。

1. 动态创建函数：`exec`

示例代码：

def create_function(name, operation):
    func_code = f"""
def {name}(a, b):
    return a {operation} b
"""
    exec(func_code, globals())
    return eval(name)

# 动态创建函数
add = create_function('add', '+')
print(add(3, 5))  # 输出：8

分析：

使用exec动态创建函数代码并运行。
eval将生成的函数名转化为可调用对象。

2. 动态修改方法：猴子补丁

猴子补丁（Monkey Patching）用于在运行时修改或扩展现有类的功能。

示例代码：

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

# 动态添加新方法
def log_warning(self, message):
    print(f"WARNING: {message}")

Logger.log_warning = log_warning

logger = Logger()
logger.log_warning("This is a warning!")  # 输出：WARNING: This is a warning!

三、深入元类操作

元类不仅可以创建类，还能实现动态注册、接口检查和属性验证。

1. 动态注册类

动态注册机制可以用来构建插件系统或扩展框架。

示例代码：

class RegistryMeta(type):
    registry = {}

    def __new__(cls, name, bases, dct):
        new_class = super().__new__(cls, name, bases, dct)
        cls.registry[name] = new_class
        return new_class

class PluginBase(metaclass=RegistryMeta):
    pass

class PluginA(PluginBase):
    pass

class PluginB(PluginBase):
    pass

print(RegistryMeta.registry)  # 输出已注册的插件类

2. 接口检查

通过元类强制类遵循某种接口。

示例代码：

class InterfaceMeta(type):
    def __new__(cls, name, bases, dct):
        if 'run' not in dct:
            raise TypeError(f"Class {name} must implement 'run' method")
        return super().__new__(cls, name, bases, dct)

class Base(metaclass=InterfaceMeta):
    def run(self):
        pass

class Derived(Base):
    pass

# 如果 Derived 未实现 `run`，将抛出 TypeError

四、元编程的实际案例

1. ORM模型的字段校验与动态SQL生成

通过元类实现字段校验，并自动生成SQL语句。

示例代码：

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

class ModelMeta(type):
    def __new__(cls, name, bases, dct):
        fields = {k: v for k, v in dct.items() if isinstance(v, Field)}
        dct['_fields'] = fields
        return super().__new__(cls, name, bases, dct)

class Model(metaclass=ModelMeta):
    def save(self):
        fields = ', '.join(self._fields.keys())
        values = ', '.join(f"'{getattr(self, k)}'" for k in self._fields.keys())
        sql = f"INSERT INTO {self.__class__.__name__.lower()} ({fields}) VALUES ({values})"
        print(f"Executing SQL: {sql}")

class User(Model):
    name = Field('name', str)
    age = Field('age', int)

user = User()
user.name = "Alice"
user.age = 30
user.save()

结果：

Executing SQL: INSERT INTO user (name, age) VALUES ('Alice', '30')

2. 动态生成API路由

通过元类动态为类生成API路由。

示例代码：

class ApiMeta(type):
    def __new__(cls, name, bases, dct):
        routes = {}
        for attr_name, attr_value in dct.items():
            if hasattr(attr_value, "_route"):
                routes[attr_value._route] = attr_value
        dct['_routes'] = routes
        return super().__new__(cls, name, bases, dct)

def route(path):
    def decorator(func):
        func._route = path
        return func
    return decorator

class Api(metaclass=ApiMeta):
    @route("/hello")
    def hello(self):
        return "Hello, world!"

    @route("/goodbye")
    def goodbye(self):
        return "Goodbye, world!"

api = Api()
print(api._routes)  # 输出路由映射