Python 如何定义只更改父类的新子类？

我有以下简化的类结构

class A（）：
def foo（self）：
self.bar（）
def bar（自）：
打印（“条”）
B（A）类：
def bar（自）：
打印（“B条”）
C（A）类：
def bar（自）：
打印（“C条”）

现在我还有一个修改版的

<代码>类ModA（）： def foo（self）： 打印（“hi”） self.bar（） 我现在还需要一个附加版本的B和C，它们将

ModA

作为父类，而不是

a

ModB类（ModA）：
def bar（自）：
打印（“B条”）
ModC类（ModA）：
def bar（自）：
打印（“C条”）

---

我如何定义

ModB

和

ModC

而不复制它们的整个定义，除了定义父级的第一行之外？

如果不知道您的“细微变化”可能是什么，就不可能回答，但一般来说，请查看多重继承-

类ModB（ModA，B）：

可能是您需要的

ModB类（ModA，B）：
通过

>>b=ModB（）
>>>b.foo（）
你好
B酒吧

根据您的玩具示例，这里有一种方法

class FooBase:
    def foo(self):
        self.bar()
class FooMod:
    def foo(self):
        print("hi")
        self.bar()

class A(FooBase):
    def bar(self):
        print("A bar")

class B(FooBase):
    def bar(self):
        print("B bar")

class C(FooBase):
    def bar(self):
        print("C bar")

class ModA(FooMod,A):
    pass
class ModB(FooMod,B):
    pass
class ModC(FooMod,C):
    pass

class BadModA(A,FooMod):
    pass

for thing in [A,B,C,ModA,ModB,ModC,BadModA]:
    thing = thing()
    print(thing.foo())
    print('**********')

您必须注意如何排序基类，注意

BadModA

不起作用，因为它在

FooBase

中找到

foo

方法，然后再查看

FooMod

。您可以在他们的方法解析顺序中看到这一点

In [15]: ModA.__mro__
Out[15]: [__main__.ModA, __main__.FooMod, __main__.A, __main__.FooBase, object]

In [16]: BadModA.__mro__
Out[16]: (__main__.BadModA, __main__.A, __main__.FooBase, __main__.FooMod, object)

虽然这样做有效，但似乎你可能会给自己带来麻烦。你必须始终记住使用哪个顺序-也许有人会评论

---

这是另一种方法，它把结构变平了一点，五个碱基，然后你把它们混合起来

class FooBase:
    def foo(self):
        self.bar()
class FooMod:
    def foo(self):
        print("hi")
        self.bar()

class Abar:
    def bar(self):
        print("A bar")
class Bbar:
    def bar(self):
        print("B bar")
class Cbar():
    def bar(self):
        print("C bar")

class A(FooBase,Abar):
    pass
class B(FooBase,Bbar):
    pass
class C(FooBase,Cbar):
    pass

class ModA(FooMod,Abar):
    pass
class ModB(FooMod,Bbar):
    pass
class ModC(FooMod,Cbar):
    pass

---

你想复制

B

和

C

？在不知道你的“细微变化”可能是什么的情况下回答是不可能的，但一般来说，看看多重继承-

类ModB（ModA，B）：

可能是你需要的。

ModB

可以从

ModA

和

B

继承，但你需要得到正确的顺序，

ModB（ModA，B）

或

ModB（B，ModA）

，因此mro将执行您需要的操作，但如前所述，无法确定。听起来好像越来越复杂了——也许需要把它展平一点。如果你做了一个玩具的例子，你可以包括作为一个例子，这将是更容易的人作出反应。有什么共同的所有六类？也许那个东西需要是它自己的类，可以作为一个mixin类使用，还有其他的公共项可以放在另一个类中吗@Błotosmętek这确实是我所需要的。我举了一个简单的例子。正如@wwii提到的，我担心需要哪种订单，以及它是否能够处理我的情况，例如

class ModB（ModA，B）

将再次使用基本

A.bar

而不是

B.bar

，但制作MWE向我表明，您的订单仍然调用

B.bar

。请随便把它作为答案，我会接受的。不可能在答案里面写上答案——有点似是而非