需求分析
在类继承中,存在这么一种情况:
class Human(object):
def Move(self):
print("我会走路...")
class Man(Human):
def Move(self):
print("我会跑步...")
man().Move()
输出:
我会跑步...
人先会走路再会跑步的。如果你想调用Man().Move()
时输出以下要怎么做?
我会走路...
我会跑步...
这时,其实便需要调用父类Human
的Move()方法了。我们知道,在子类中,会覆父类的同名方法。即子类Man
里的Move()
方法将父类Human
中的同名方法Move()
覆盖了。要想同时使得两个方法都奏效,可以在子类中主动调用父类中的Move()方法。其实很简单,在类Man中加点东西就行了,如下:
class Human(object):
def Move(self):
print("我会走路...")
class Man(Human):
def Move(self):
Human.Move(self)
print("我会跑步...")
Man().Move()
output:
我会走路...
我会跑步...
代码中的Human.Move(self)
便是在子类Man中主动跟调用父类的方法。我来解释一下这句代码:
- Human.Move(self)中Human是类,由类直接调用Move方法,这是未绑定的调用。
- Human.Move(self)中的self其实是Man的一个实例Man(),一个个类的实例化是这样的
m=Man()
,其中,m和Man()都是类Man的实例。
但是,这种方法有一个弊端。比如,如果父类Human
吃饱没事干给自己换个名字叫GoodHuman
,那么麻烦就来了,你不仅要把Man(Human)
改为Man(GoodHuman)
,还要把Human.Move(self)
改为GoodHuman.Move(self)
。
当然,这里的例子改起来是没什么可怕。但万一在一些项目里像Human.Move(self)
这类型的方法很多的话,你要一个一个改?
有没有什么办法,使得在父类更改名称时,子类只要改类似Man(Human)
一处就好?
super()出场
super()的作用是:在类的继承中,如果重定义某个方法,该方法会覆盖父类的同名方法,但有时,我们希望能同时实现父类的功能,这时,我们就需要调用父类的方法了,可通过使用 super 来实现。
调用super()地常用格式是:
class C(B):
def meth(self, arg):
super(C, self).meth(arg)
现在,只要将代码改为以下,就不怕父类名称地变化了。(输出结果和上述一样)
class Human(object):
def Move(self):
print("我会走路...")
class Man(Human):
def Move(self):
super(Man, self).Move()
print("我会跑步...")
稍微深入
上面地例子很简单,因为类Man继承地父类已有一个。当继承关系变复杂时,(比如同时继承很多个类,继承的类又继承其他类等等...),便要知道super()是怎么处理继承顺序了。
看这个例子:
class Base(object):
def __init__(self):
print("enter Base")
print("leave Base")
class A(Base):
def __init__(self):
print("enter A")
super(A, self).__init__()
print("leave A")
class B(Base):
def __init__(self):
print("enter B")
super(B, self).__init__()
print("leave B")
class C(A, B):
def __init__(self):
print("enter C")
super(C, self).__init__()
print("leave C")
按照前面的思路。我们意淫的输出应该是:
enter C
enter A
enter Base
leave Base
leave A
enter B
enter Base
leave Base
leave B
leave C
但实际输出却是:
enter C
enter A
enter B
enter Base
leave Base
leave B
leave A
leave C
我在这里提一个疑问:
**enter A
的下一句为什么不是enter Base
而是enter B
么? **
揭开super的面纱
其实,对于你定义的每一个类,Python 会用方法解析顺序(Method Resolution Order, MRO)计算出一个列表,它代表了类继承的顺序,我们可以使用下面的方式获得某个类的 MRO 列表:
>>>print(C.mro())
[<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class '__main__.Base'>, <class 'object'>]
[Finished in 0.2s]
一个类的 MRO 列表就是合并所有父类的 MRO 列表,并遵循以下三条原则:
- 子类永远在父类前面;
- 如果有多个父类,会根据它们在列表中的顺序被检查;
- 如果对下一个类存在两个合法的选择,选择第一个父类.
我们查看super函数的代码:
ef super(cls, inst):
mro = inst.__class__.mro()
return mro[mro.index(cls) + 1]
其中,cls 代表类,inst 代表实例,上面的代码做了两件事:
- 获取 inst 的 MRO 列表;
- 查找 cls 在当前 MRO 列表中的 index, 并返回它的下一个类,即 mro[index + 1]。
当你使用 super(cls, inst) 时,Python 会在 inst 的 MRO 列表上搜索 cls 的下一个类。
现在我们来通过一步步追踪来回答上面提出的答案:
做法很简单:
1, 修改一下代码:
class Base(object):
def __init__(self):
print("enter Base")
print("leave Base")
print(self)
class A(Base):
def __init__(self):
print("enter A")
print(self)
super(A, self).__init__()
print("leave A")
class B(Base):
def __init__(self):
print("enter B")
print(self)
super(B, self).__init__()
print("leave B")
class C(A, B):
def __init__(self):
print("enter C")
print(self)
super(C, self).__init__()
print("leave C")
c = C()
print(hex(id(c)))
看输出:
enter C
<__main__.C object at 0x000001C614CAB7F0>
enter A
<__main__.C object at 0x000001C614CAB7F0>
enter B
<__main__.C object at 0x000001C614CAB7F0>
enter Base
leave Base
<__main__.C object at 0x000001C614CAB7F0>
leave B
leave A
leave C
0x1c614cab7f0
在这里塞了这么多代码,就为了说明两件事:
- 在A,B,C,Base这四个类中,self都是
<__main__.C object at 0x000001C614CAB7F0>
这个对象。 -
<__main__.C object at 0x000001C614CAB7F0>
是类C的实例c(c的id输出是0x1c614cab7f0
,说明它们是同样的东西)。实例c也就是整个过程的发起者。
到了这里,就可以回答问题了:
首先看类C的__init__方法:
super(C, self).__init__()
这里的 self 是当前 C 的实例,self.__class__.mro()
结果是:
[__main__.C, __main__.A, __main__.B, __main__.Base, object]
可以看到,C 的下一个类是 A,于是,跳到了 A 的 __init__
,这时会打印出 enter A,并执行下面一行代码:
super(A, self).__init__()
注意,这里的 self 也是当前 C 的实例,MRO 列表跟上面是一样的,搜索 A 在 MRO 中的下一个类,发现是 B,于是,跳到了 B 的__init__
,这时会打印出enter B,而不是enter Base。
总结
super和父类没有实质性的关联。通过上面分析。我们知道super函数是根据self
以及该self对应的方法解析顺序mro
来工作的。
再强调一下,self是一个实例对象,在这里就是实例c(上面代码有一句c=C()),整个过程的发起者。
版权:保留所有权,转载请注明出处!