如何重构Python代码避免因函数签名差异重写父类main方法？

假设存在父类P，其main方法实现了核心功能，该方法会调用外部模块的parent_function(x, y)。示例代码如下：

from my_module import parent_function

class P:
    def main():
        # 执行前置逻辑
        x = P.calc_x()
        y = P.calc_y()
        z = P.calc_z()

        # 调用核心函数
        parent_function(x,y)
        
        # 执行后续逻辑

现有子类C，唯一区别是需要调用child_function(x,y,z)而非parent_function，但为了适配不同的函数签名，不得不重写整个main方法，仅修改其中一行代码：

from my_module import child_function

class C(P):
    def main():
        # 执行前置逻辑
        x = P.calc_x()
        y = P.calc_y()
        z = P.calc_z()

        # 调用核心函数
        child_function(x,y,z)

        # 执行后续逻辑

这违反了DRY原则，需要重构代码避免重写整个main方法。

已有两个初步思路，但存在不足：

• 将parent_function、child_function改为P/C的方法，把z设为实例变量使两者签名一致，但z作为实例变量逻辑不合理。
• 将(x,y,z)存入字典，修改parent/child_function的签名以接受**kwargs，让parent_function忽略未使用的参数。

方案1：提取核心调用逻辑为类方法（推荐） #

把main中的核心函数调用逻辑抽离为独立的类方法，父类和子类分别实现这个方法，main仅保留公共逻辑：

from my_module import parent_function, child_function

class P:
    @classmethod
    def main(cls):
        # 公共前置逻辑
        x = cls.calc_x()
        y = cls.calc_y()
        z = cls.calc_z()

        # 调用子类可重写的核心方法
        cls._call_target_function(x, y, z)
        
        # 公共后续逻辑

    @classmethod
    def _call_target_function(cls, x, y, z):
        parent_function(x, y)

class C(P):
    @classmethod
    def _call_target_function(cls, x, y, z):
        child_function(x, y, z)

这样main方法完全无需重写，子类仅需实现_call_target_function这一小部分逻辑，既符合DRY原则，又无需修改外部函数签名，也不会引入不合理的实例变量。

方案2：为外部函数添加适配层（无需修改外部函数） #

如果无法修改外部函数的签名，可以在类中添加一层适配逻辑：

from my_module import parent_function, child_function

class P:
    @classmethod
    def main(cls):
        x = cls.calc_x()
        y = cls.calc_y()
        z = cls.calc_z()

        # 通过统一入口调用目标函数
        cls._get_target_function()(x, y, z)
        
        # 公共后续逻辑

    @classmethod
    def _get_target_function(cls):
        # 返回适配后的函数，自动忽略不需要的z参数
        return lambda x, y, z: parent_function(x, y)

class C(P):
    @classmethod
    def _get_target_function(cls):
        # 子类直接返回目标函数，参数完全匹配
        return child_function

父类通过lambda创建适配器，屏蔽z参数；子类直接返回child_function，同样无需重写main方法。

对原有思路的优化 #

• 针对思路1：无需将z设为实例变量，直接在抽离的类方法中传递z参数即可，也就是方案1的实现方式，既保持了方法调用的一致性，又避免了不合理的实例变量设计。
• 针对思路2：若允许修改外部函数签名，让parent_function接受**kwargs是可行的；但如果外部函数属于第三方库无法修改，方案2的适配层方式更实用。

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