Классы, наследование и методы / функции в 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. наследуют каждый из AuxOps, CoreOps и DerOps в con_fun (наследует ли они автоматически 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() относятся к базовому классу или далее к его дереву наследования.