super,__init__--看一个简单程序的结果

_Erics

1. class A(object):
   
2.     def __init__(self):
   
3.         print "A"
   
4.         super(A, self).__init__()
   
5.     def p(self):
   
6.         print "AA"
   
7. 
   
8. class B(object):
   
9.     def __init__(self):
   
10.         print "B"
    
11.         super(B, self).__init__()
    
12.     def p(self):
    
13.         print "BB"
    
14. 
    
15. class C(A,B):
    
16.     def __init__(self):
    
17.         print "C"
    
18.         A.__init__(self)
    
19.         B.__init__(self)
    
20.         
    
21.     def p(self):
    
22.         print "CC"
    
23.         A.p(self)
    
24.         B.p(self)
    
25. 
    
26. if __name__ == '__main__':
    
27.     c = C()
    
28.     c.p()

复制代码

大家看看上面这个程序的输出结果是什么

luffy.deng

expert python上的例子,继承时不要混合使用super和classic calls.
这里有篇文章分析了具体原因 http://blog.csdn.net/JohnsonGuo/archive/2006/01/20/585193.aspx

luffy.deng

你可能很奇怪为什么c.p()没有问题，事实上问题是发生在super(A, self).func()的时候的，改成这样B类的p()也会被调用两次。
输出
C
A
B
B
CC
AA
BB
BB

1. #!/usr/bin/python
   
2. class D(object):
   
3.     def p(self):
   
4.         pass
   
5. class A(D):
   
6.     def __init__(self):
   
7.         print "A"
   
8.         super(A, self).__init__()
   
9.     def p(self):
   
10.         print "AA"
    
11.         super(A, self).p()
    
12. 
    
13. 
    
14. class B(D):
    
15.     def __init__(self):
    
16.         print "B"
    
17.         super(B, self).__init__()
    
18.     def p(self):
    
19.         print "BB"
    
20. 
    
21. 
    
22. class C(A,B):
    
23.     def __init__(self):
    
24.         print "C"
    
25.         A.__init__(self)
    
26.         B.__init__(self)
    
27.         
    
28.     def p(self):
    
29.         print "CC"
    
30.         A.p(self)
    
31.         B.p(self)
    
32. 
    
33. 
    
34. if __name__ == '__main__':
    
35.     c = C()
    
36.     c.p()

复制代码

_Erics

多谢LS.
基本上搞清楚了，在用super进行函数名解析的时候，以MRO作为解析顺序，并且总是选择MRO中的"next-method"进行调用。
以上面的程序为例子，类C的MRO为 [C,A,B,object], C的初始化函数在调用A.__init__(self)时，调用了函数super(A,self).__init__()。
在调用super(A,self).__init__()时，实际上调用了类B的__init__函数,故此时的打印结果为CAB.接着C的初始化函数调用了B.__init__(self),
它将打印一个B，然后调用super(B,self).__init__()函数。由于在MRO中，B的下一个解析类是object,因此，在调用super(B,self).__init__()时
相当于调用了object的初始化函数。
导致最终的输出结果为CABB。有兴趣，可以参考这篇文章Python's Super Considered Harmful(http://fuhm.net/super-harmful/).