如何在Python中实现Ruby prepend方法的等价功能？

问题背景 #

正在将软件从Ruby迁移至Python，需要实现Ruby中prepend方法的等价效果：调用ProgramJobHandler.process_message时，先执行LibB中JobHandling.process_message的逻辑，再通过类似super的机制调用LibA中JobHandler.process_message的逻辑。

已知两个独立库的代码：

LibA - JobHandler类 #

class JobHandler:
    def __init__(self):
        print('JobHandler init constructor')

    def process_message(self, message):
        # 处理message的逻辑
        # ...
        # 最终发送消息
        send(message)

LibB - JobHandling类 #

class JobHandling:
    def __init__(self):
        print('JobHandling init constructor')

    def process_message(self, message):
        # 处理message的逻辑
        # ...

        # Ruby中用super调用父类方法
        ## super

当前自定义类：

from LibA.handlers.JobHandler import JobHandler
from LibB.handlers.JobHandling import JobHandling

class ProgramJobHandler(JobHandler):
    # Ruby中用prepend JobHandling实现前置调用
    ## prepend JobHandling

    def __init__(self):
        print('My program job handler constructor')

解决方案 #

Python没有直接对应Ruby prepend的语法，但可以通过以下几种Pythonic方式实现相同效果：

方法一：调整多重继承顺序（推荐） #

利用Python的方法解析顺序（MRO），将JobHandling作为ProgramJobHandler的直接父类，让其方法优先被调用，同时在JobHandling中用super()调用后续链中的方法。

步骤1：修改LibB的JobHandling类

将Ruby风格的super替换为Python的super()调用：

class JobHandling:
    def __init__(self):
        print('JobHandling init constructor')

    def process_message(self, message):
        # 处理message的逻辑
        # ...

        # 调用MRO链中的下一个process_message方法（即JobHandler的实现）
        super().process_message(message)

步骤2：修改ProgramJobHandler的继承结构

让ProgramJobHandler先继承JobHandling，再继承JobHandler：

from LibA.handlers.JobHandler import JobHandler
from LibB.handlers.JobHandling import JobHandling

class ProgramJobHandler(JobHandling, JobHandler):
    def __init__(self):
        print('My program job handler constructor')
        # 若需要执行JobHandling的初始化逻辑，添加以下代码
        # super().__init__()

此时调用ProgramJobHandler().process_message(msg)时，MRO顺序为ProgramJobHandler → JobHandling → JobHandler，会先执行JobHandling.process_message，再通过super()调用JobHandler.process_message，完全匹配Ruby prepend的效果。

方法二：动态包装方法（装饰器思路） #

如果不想修改继承结构，可以通过组合的方式，在ProgramJobHandler的process_message中先调用JobHandling的逻辑，再调用父类方法。

步骤1：调整LibB的JobHandling类

让process_message支持传入后续处理函数：

class JobHandling:
    def __init__(self):
        print('JobHandling init constructor')

    def process_message(self, message, next_handler=None):
        # 处理message的逻辑
        # ...

        # 执行后续处理逻辑
        if next_handler:
            next_handler(message)

步骤2：修改ProgramJobHandler的process_message方法

from LibA.handlers.JobHandler import JobHandler
from LibB.handlers.JobHandling import JobHandling

class ProgramJobHandler(JobHandler):
    def __init__(self):
        print('My program job handler constructor')
        self.job_handling = JobHandling()

    def process_message(self, message):
        # 先执行JobHandling的逻辑，再调用父类的process_message
        self.job_handling.process_message(message, super().process_message)

方法三：元类动态替换方法 #

通过元类在类创建阶段，自动将JobHandling的逻辑前置到process_message中，无需修改原有类的代码结构。

from LibA.handlers.JobHandler import JobHandler
from LibB.handlers.JobHandling import JobHandling

class PrependMeta(type):
    def __new__(cls, name, bases, attrs):
        # 获取JobHandler中的原始process_message方法
        original_process = bases[0].process_message
        # 初始化JobHandling实例
        job_handling = JobHandling()

        # 定义包装后的方法
        def wrapped_process(self, message):
            job_handling.process_message(message)
            original_process(self, message)

        # 替换类的process_message方法
        attrs['process_message'] = wrapped_process
        return super().__new__(cls, name, bases, attrs)

class ProgramJobHandler(JobHandler, metaclass=PrependMeta):
    def __init__(self):
        print('My program job handler constructor')

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