Question

我无法找到有效的Python继承问题解决方案。

因此存在如下代码：

class Foo( object ):
        def __init__():
                self.some_vars
        def foo_func():
                x = Bar()
        def foo_bar_func()
                x += 1

class Fighters( Foo ):
        def __init__():
                Foo.__init__()
        def func1():
                Foo.some_attribute
        def func2():
                Foo.someother_func()

class Bar():
        def bar_func():
                #some stuff here

问题在于我需要覆盖Bar.bar_func()但这有两个层次。我通过以下方式解决了这个问题：

class Foo( Foo ):
        def __init__():
                Foo.__init__()
        def foo_func():          #Overridden method
                x = myBar()   

class myFighters( Foo ):
        def __init__():
                Foo.__init__()
        def func1():
                Foo.some_attribute
        def func2():
                Foo.someother_func()

class myBar():
        def bar_func():      #the function that I actually need to change
                #my sweet code here

实际上唯一不同的是myBar.bar_func()，但我必须至少做两件我觉得难看的事情。

一个是我必须创建一个继承自class Foo的{{1}}。这似乎是一件奇怪的事情，并没有让事情变得非常清楚。我这样做是为了避免将Foo中的每个引用从myFighters重命名为Foo。

第二个是我必须将myFoo中的所有代码复制到Fighters，其唯一目的是在myFighters中使用重写函数。 Bar()和Fighters完全相同，只是myFighters使用调用Fighters的{{1}}而Foo使用Bar()调用myFighters。有没有人有任何建议来解决这两个问题？或者我应该感恩，我找到了解决方案并继续我的生活......

Answer 1

类上定义的所有方法都将实例作为第一个参数。惯例是调用实例self并将其引用为：

class Foo(object):
    def __init__(self):
        self.x = 1

其次，如果您不需要覆盖父类的方法，只需将其删除：

class Fighters(Foo):
    # __init__ would be here, but I leave it out to inherit the method

    def func_1(self):
        ...

最后，如果您想引用父母行为，请使用super()：

class MyFighters(Fighters):
    def __init__(self):
         super(MyFighters, self).__init__()
         self.y = 2

另请参阅this example和the official Python docs on classes。

Answer 2

在进行一些代码清理后，制作一个可运行的示例：

class Foo( object ):
        def __init__(self):
                print("foo init")
                self.foo_func()
        def foo_func(self):
                print("making bar")
                self.x = Bar()
        def foo_bar_func(self):
                self.x.bar_func()

class Fighters( Foo ):
        def __init__(self):
                print("fighters init")
                Foo.__init__(self)
        def func1(self):
                Foo.some_attribute
        def func2(self):
                Foo.someother_func()

class Bar(object):
        def __init__(self):
                print("bar init")
        def bar_func(self):
                #some stuff here
                print("bar bar_func")

实例化原始战斗机：

f1 = Fighters()
f1.foo_bar_func()

并从原始的bar类中调用该方法：

fighters init
foo init
making bar
bar init
bar bar_func

现在我们可以使用MyFar将Fighters子类化为子类，使用MyBar将其子化。使用对MyBar的构造函数调用覆盖Foo类的foo_func是MyFighters，它可以执行您想要的操作而不复制方法：

class MyFighters(Fighters):
        def foo_func(self):
                print("making mybar")
                self.x = MyBar()

class MyBar(Bar):
        def bar_func(self):
                print("mybar bar_func")

当我们创造一个新的战斗机时：

f2 = MyFighters()
f2.foo_bar_func()

我们看到它从新的bar类调用该方法：

fighters init
foo init
making mybar
bar init
mybar bar_func

显然这只有效，因为创建Bar对象的方法对于子类和替换是微不足道的。通常情况并非如此，因为它可能直接在 init 中完成，而不是调用方法来完成它。因此，原始类的设计是允许此示例运行的原因。

Python：多级继承

2 个答案: