关于oop：Python：多级继承


Python: multi level inheritance

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

因此存在如下代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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()，但这有两个层次。我通过以下步骤解决了这个问题：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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()，但我必须做至少2件我认为丑陋的事情。

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

第二个问题是，为了使用Bar()中的重写函数，我必须将Fighters中的所有代码复制到myFighters中。Fighters和myFighters完全相同，只是Fighters使用的Foo称为Bar()，myFighters使用的Foo称为myBar()。有人对解决这两个问题有什么建议吗？或者我应该庆幸我找到了一个解决办法，继续我的生活…

在进行一些代码清理以生成可运行的示例之后：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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")

。

实例化原始战斗机：

1
2
f1 = Fighters()
f1.foo_bar_func()

它从原始的bar类调用方法：

1
2
3
4
5
fighters init
foo init
making bar
bar init
bar bar_func

。

现在我们可以将战士分为myfighters子类和mybar子类。重写foo类的foo-func is myfighters，该类具有对mybar的构造函数调用，它执行您希望的操作，而不复制方法：

1
2
3
4
5
6
7
8
class MyFighters(Fighters):
        def foo_func(self):
                print("making mybar")
                self.x = MyBar()

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

。

当我们创建新的战斗机时：

1
2
f2 = MyFighters()
f2.foo_bar_func()

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

1
2
3
4
5
fighters init
foo init
making mybar
bar init
mybar bar_func

。

显然，这只起作用，因为创建bar对象的方法对于子类和替换来说是微不足道的。一般来说，情况并非如此，因为它可能直接在in it中完成，而不是调用一个方法来完成。所以原始类的设计是允许这个例子运行的。

类上定义的所有方法都将实例作为第一个参数。本公约称该实例为self，并将其称为：

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

第二，如果不需要覆盖父类的方法，只需将其去掉：

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

    def func_1(self):
        ...

号

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

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

另请参见本例和classes上的官方python文档。