Python 中的类、继承和方法/函数

Question

目前，我的项目结构如下：

main.py
-------

class main_fun(object):
    def __init__(self, <parameters>):


ops.py
------

class ops_fun(main_fun):
    def __init__(self):
        super(ops_fun, self).__init__(<parameters>)

它基本上翻译成以下内容：

                              ------------------
                              main_fun (main.py)
                              ------------------
                                      |
                                      |
                               ----------------
                               ops_fun (ops.py)
                               ----------------

我想将以上内容拆分/重组为以下内容：

                              ------------------
                              main_fun (main.py)
                              ------------------
                            /         |          \
                           /          |           \
        ----------------     ----------------      ----------------
        AuxOps (aops.py) === CoreOps (cops.py) === DerOps (dops.py)
        ----------------     ----------------      ----------------
                           \          |           /
                            \         |          /
                              ------------------
                              con_fun (contf.py)
                              ------------------

这基本上意味着我想要：

1. 将类main_fun中的所有方法/函数和变量继承到AuxOps、CoreOps、DerOps和con_fun中的每一个。
2. 在AuxOps、CoreOps 和DerOps 中实现了不同的方法/功能，应该在彼此的类中继承。即AuxOps应该继承CoreOps和DerOps中的每个方法，DerOps应该继承CoreOps和AuxOps中的每个方法。
3. 在con_fun 中继承AuxOps、CoreOps 和DerOps（继承这些会自动继承main_fun，因为它是它们的父级吗？）。

我怎样才能实现上述目标？

Answer 1

Python允许多重继承，所以你可以直接

class Parent ...

class ChildA(Parent) ...
class ChildB(Parent)...

class Grandchild(ChildA, ChildB)...

子继承其所有父方法。这导致Grandchild 将通过双亲继承Parent 类的方法的问题。默认情况下，当被要求调用该方法时，python 会首先查看最左边的父类。

更多细节请查看钻石问题和python的方法解析顺序。

Answer 2

一个自以为是的答案。我建议使用基类和插件来编写。通用类的多重继承可能是一个非常痛苦的调试。

class AuxPlugin( object):
    def auxMethod1( self, ...)

    ...

class CorePlugin( object)
    def coreMethod1( self, ...)
    ...

class DerPlugin( object)
    def derMethod1( self, ...)
    ...

class AuxOps( AuxPlugin, Main_Fun):  # better, call Main_Fun Base_whatever
    pass
class CoreOps( CorePlugin, Main_Fun):  
    pass
class DerOps( DerPlugin, Main_Fun): 
    pass
class ConFun( AuxPlugin, CorePlugin, DerPlugin, Main_Fun ):
    pass
# and possible
# class CoreDerOps( CorePlugin, DerPlugin, Main_Fun):
#    pass
# etc. Mix'n'match.

“规则”是：

1. 插件总是继承自object，除了定义普通方法外不做任何事情。
2. 在继承基类的类中，插件都位于单个基类的左侧
3. 插件应该有自己独特的方法集，不与其他兼容插件重叠（但如果重叠，最左边的插件胜出）
4. 如果你违反了这些规则，你会在以后忘记你的时候后悔，或者其他一些可怜的草皮会诅咒你并破坏你的业力。

您可以在多个层次上重复这种模式：

class FooFun( FooPlugin, ConFun):  
   # gets all of ConFun's plug-in methods, its base class, and added FooPlugin's methods

向下一层，允许使用插件方法拦截和扩充从较低级别继承的方法，在适当的情况下调用super().name()。

关键是找出什么是指什么是容易的。如果它在插件中，则无需担心超类。对super() 的任何调用都指向基类，或者更进一步地指向它的继承树。