当然有捷径！不用手动重写每个基类方法就能给它们批量挂上装饰器，我给你分享几个Python里常用的靠谱方案：

方案1：类装饰器（最直观易读） #

类装饰器可以在不改动原类结构的前提下，动态给子类继承的基类方法加上装饰器。核心思路是遍历基类的方法列表，然后在子类中重新绑定经过装饰器包装的版本。

举个完整的例子：
首先定义你要用的装饰器：

def log_decorator(func):
    def wrapper(*args, **kwargs):
        print(f"[LOG] 开始执行方法: {func.__name__}")
        result = func(*args, **kwargs)
        print(f"[LOG] 方法 {func.__name__} 执行结束")
        return result
    return wrapper

然后定义你的基类：

class BaseService:
    def fetch_data(self):
        print("从数据库获取数据")
    
    def process_data(self):
        print("处理数据逻辑")

接下来写一个通用的类装饰器，用来批量处理基类方法：

def decorate_base_methods(target_base, decorator):
    def wrapper(sub_cls):
        # 遍历基类的所有方法（排除__init__这类特殊方法）
        for method_name in dir(target_base):
            method = getattr(target_base, method_name)
            if callable(method) and not method_name.startswith("__"):
                # 给子类绑定包装后的方法
                decorated_method = decorator(getattr(sub_cls, method_name))
                setattr(sub_cls, method_name, decorated_method)
        return sub_cls
    return wrapper

最后用装饰器修饰你的子类：

@decorate_base_methods(BaseService, log_decorator)
class MyService(BaseService):
    # 完全不用重写任何基类方法！
    pass

测试一下效果：

service = MyService()
service.fetch_data()
# 输出：
# [LOG] 开始执行方法: fetch_data
# 从数据库获取数据
# [LOG] 方法 fetch_data 执行结束

这个方案的好处是代码清晰易懂，不需要理解元类的复杂逻辑，还能灵活指定要处理的基类和装饰器。

方案2：元类（更底层的类创建控制） #

如果你需要更底层的类创建逻辑控制，可以用元类。元类会在类被创建的瞬间自动执行，我们可以在这里批量修改基类方法的绑定。

示例代码：

class DecorateMeta(type):
    def __new__(cls, name, bases, attrs):
        # 假设第一个基类是我们要处理的目标基类
        target_base = bases[0]
        used_decorator = log_decorator  # 复用之前的装饰器
        
        # 遍历基类方法并包装
        for method_name in dir(target_base):
            method = getattr(target_base, method_name)
            if callable(method) and not method_name.startswith("__"):
                # 如果子类没有重写这个方法，就包装基类的方法
                if method_name not in attrs:
                    attrs[method_name] = used_decorator(method)
        
        return super().__new__(cls, name, bases, attrs)

# 用元类创建子类
class MyService(BaseService, metaclass=DecorateMeta):
    pass

测试效果和类装饰器完全一致，但元类是Python中创建类的"工厂"，适合需要全局控制类创建逻辑的场景。

方案3：__getattribute__动态拦截（运行时包装） #

如果不想在类创建时修改方法，而是在实例调用方法时动态包装，可以用__getattribute__方法。这个方法会拦截所有实例属性的访问，我们可以在这里对目标方法进行动态装饰。

示例：

class MyService(BaseService):
    def __getattribute__(self, name):
        attr = super().__getattribute__(name)
        # 判断是不是基类的方法，且不是特殊方法
        if name in dir(BaseService) and callable(attr) and not name.startswith("__"):
            return log_decorator(attr)
        return attr

这个方案的特点是每次调用方法都会重新包装一次，适合需要动态调整装饰逻辑的场景，但性能会略低于前两种（不过大多数业务场景下可以忽略这个差异）。

内容的提问来源于stack exchange，提问作者a bsss