Question

我的情况是我可以访问两个可以很好地协同工作的类。广泛修改他们的代码可能是不可能的，但也许可以实现小的改变。但是，我想对这两个类进行一些小扩展。这似乎是子类化的工作，从每个类派生并添加功能。但是我遇到了一个问题，因为一个基类会调用另一个基类，而不是我的派生类。

我们说我在模块中有两个A和B类＆base; classes.py＆＃39;。 B类有一个创建A类实例并使用它的方法，例如

＆＃39; base_classes.py＆＃39;

class A():
    def __init__(self):
        print('Class A being called')

class B():
    def __init__(self):
        self.do_thing()
    def do_thing(self):
        self.myA = A() # Here class A is explicitly named

所以我想将这两个子类化并扩展它们。我在一个单独的模块中这样做：

＆＃39; extensions.py＆＃39;

import base_classes

class DerivedA(base_classes.A):
    def __init__(self):
        super().__init__()
        print('Class DerivedA being called')

class DerivedB(base_classes.B):
    pass

db = DerivedB()

正如所料，输出只是

Class A being called

但是如何阻止我的B 的子类在方法do_thing(self)中创建A的基类实例，而是创建DerivedA的实例？

简单的方法是在DerivedB中覆盖do_thing(self)，以便它显式调用DerivedA，例如。

class DerivedB(base_classes.B):
    def do_thing(self):
        self.myA = DerivedA() # Here class DerivedA is explicitly named

对于这个小例子来说这很好，但是如果do_thing(self)长了100行并且包含许多A类对象怎么办？如果B中的大多数方法包含一些A对象怎么办？你必须基本上覆盖每个具有几乎完全复制的方法，这使得从一开始就从B派生毫无意义。在我的情况下，这几乎是问题，我认为必须有一种聪明的pythonic方法来解决这个问题。理想情况下，没有完全重写原始类。

有什么想法吗？

Answer 1

您可以更改B类的do_thing方法，并在参数中传递一个类：

class B():
    def __init__(self):
        self.do_thing()
    def do_thing(self, klass=A):
        self.myA = klass()

然后，derivedB do_thing方法可以使用DerivedA

调用它

class DerivedB(base_classes.B):
    def do_thing(self, klass=DerivedA):
        return super(DerivedB, self).do_thing(klass)

Python：在基类

1 个答案: