先看如下一段代码：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
class
A(
object
):
def
onTimer(
self
):
print
"A"
class
B(
object
):
def
onTimer(
self
):
print
"B"
class
C(A, B):
def
onTimer(
self
):
super
(C,
self
).onTimer()
print
"C"
c
=
C()
c.onTimer()
|
输出为：
|
1
2
3
4
|
'''
A
C
'''
|
代码是多重继承，希望调到所有的基类的同名函数，但是从输出来看，只有A、C的调用了。
之前总结过 关于Python中的super以及调用父类构造函数[Python]，对比上面的代码，在A和B中没有写super，但是也没法super了，因为A的父类是object，是没有onTimer函数的。
现在从Python源码来探究下super：
在工程中搜索super，会在 bltinmodule.c 中找到：
即super是Python的一种内置类型——PySuper_Type。
typeobject.c中PySuper_Type的定义：
其中包含superobject，在typeobject.c中superobject的定义：
其中包含3个指针。
再看PySuper_Type中指定的super_init：
代码中写 super(C, self) 的时候会做super_init操作，结合上面的代码，初步确定type就是前面的class C的类型，obj就是C的对象，obj_type就是C对象的类型。
如果是一个子类对象，那么type和obj_type是一致的，如果是一个父类中的super，那么type就是父类类型，obj_type还是具体子类的类型。
上面得到的super对象在调用onTimer的时候，会有一个super_getattro的逻辑，代码如下：
super_getattro的逻辑是：
先找到starttype，即具体子类的类型，上面就是C的实例c对应的类。
然后遍历starttype的mro，找到当前类型在mro中的位置，在找到的这个位置之后的那些类里面搜索要查找的名字（比如上面的onTimer）。
因此，可以确定super是通过最终子类的mro来确保继承体系上每个类里面的同名函数调用且只被调用一次的。
关于mro，Python文档说明如下：
PyObject* PyTypeObject.tp_mro
Tuple containing the expanded set of base types, starting with the type itself and ending with object, in Method Resolution Order.
This field is not inherited; it is calculated fresh by PyType_Ready().
了解了上面的一些细节，我们可以输出最开始那段代码各个类的mro来看看：
|
1
2
3
4
5
6
7
8
9
|
代码：
print
A.__mro__
print
B.__mro__
print
C.__mro__
结果如下：
(<
class
'__main__.A'
>, <
type
'object'
>)
(<
class
'__main__.B'
>, <
type
'object'
>)
(<
class
'__main__.C'
>, <
class
'__main__.A'
>, <
class
'__main__.B'
>, <
type
'object'
>)
|
在调用到A的onTimer之后，由于在A的onTimer中没有调用super的onTimer，调用链断掉。
按照上面的规则，我们可以试下这样：
|
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
26
27
28
29
|
代码：
class
A(
object
):
def
onTimer(
self
):
print
"A"
super
(A,
self
).onTimer()
class
B(
object
):
def
onTimer(
self
):
print
"B"
class
C(A, B):
def
onTimer(
self
):
print
"C"
super
(C,
self
).onTimer()
c
=
C()
c.onTimer()
print
A.__mro__
print
B.__mro__
print
C.__mro__
输出：
C
A
B
(<
class
'__main__.A'
>, <
type
'object'
>)
(<
class
'__main__.B'
>, <
type
'object'
>)
(<
class
'__main__.C'
>, <
class
'__main__.A'
>, <
class
'__main__.B'
>, <
type
'object'
>)
|
这样，A、B、C都调到了。
但是，A类明显存在问题的：
|
1
2
3
4
5
6
|
如果直接使用A类：
a
=
A()
a.onTimer()
就会出现错误：
AttributeError:
'super'
object
has no attribute
'onTimer'
|
为了解决这个问题，我们可以增加一个包含onTimer的最终父类，在它里面不再调用父类的onTimer，然后所有需要实现onTimer的子类都存在一个到该最终父类的继承关系。代码如下：
|
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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
|
代码：
class
T(
object
):
def
onTimer(
self
):
print
"T"
class
A(T):
def
onTimer(
self
):
print
"A"
super
(A,
self
).onTimer()
class
B(T):
pass
# def onTimer(self):
# print "B"
# super(B, self).onTimer()
class
C(T):
def
onTimer(
self
):
print
"C"
super
(C,
self
).onTimer()
class
F(
object
):
pass
class
G(F, T):
def
onTimer(
self
):
print
"G"
super
(G,
self
).onTimer()
class
D(A, B, C, G):
def
onTimer(
self
):
print
"D"
super
(D,
self
).onTimer()
class
E(D):
def
onTimer(
self
):
print
"E"
super
(E,
self
).onTimer()
e
=
E()
e.onTimer()
输出：
E
D
A
C
G
T
|
另外，朱斌用脚本实现的super：
|
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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
|
class
MySuperFunc(object):
def __init__(self,f,s):
super
(MySuperFunc,self).__init__()
self.f = f
self.s = s
def __call__(self,*params):
fp = [self.s]
for
p
in
params:
fp.append(p)
self.f(*fp)
class
MySuper(object):
def __init__(self,curType,obj):
super
(MySuper,self).__init__()
self.curType = curType
self.obj = obj
def __getattr__(self, name):
start = False
for
b
in
self.obj.__class__.__mro__:
if
not start:
if
b
is
self.curType:
start = True
else
:
f = getattr(b, name, None)
if
f
is
not None and callable(f):
return
MySuperFunc(f,self.obj)
class
MySuperFunc(object):
def __init__(self,f,s):
super
(MySuperFunc,self).__init__()
self.f = f
self.s = s
def __call__(self,*params):
fp = [self.s]
for
p
in
params:
fp.append(p)
self.f(*fp)
class
MySuper(object):
def __init__(self,curType,obj):
super
(MySuper,self).__init__()
self.curType = curType
self.obj = obj
def __getattr__(self, name):
start = False
for
b
in
self.obj.__class__.__mro__:
if
not start:
if
b
is
self.curType:
start = True
else
:
f = getattr(b, name, None)
if
f
is
not None and callable(f):
return
MySuperFunc(f,self.obj)
class
TimerObj(object):
def abc(self):
print
"T"
class
D(TimerObj):
def abc(self):
print
"D 1"
,self
MySuper(D,self).abc()
print
"D 2"
pass
class
A(D):
def abc(self):
print
"A 1"
,self
MySuper(A,self).abc()
print
"A 2"
pass
class
B(D):
def abc(self):
print
"B 1"
,self
MySuper(B,self).abc()
print
"B 2"
class
C(A,B):
def abc(self):
print
"C 1"
,self
MySuper(C,self).abc()
print
"C 2"
c = C()
c.abc()
|
559
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
