[已解决]类的继承

lyjlyj

1. class A(object):
   
2.     def go(self):
   
3.         print "go A go!"
   
4. 
   
5. class B(A):
   
6.     def go(self):
   
7.         super(B, self).go()
   
8.         print "go B go!"
   
9. 
   
10. class C(A):
    
11.     def go(self):
    
12.         super(C, self).go()
    
13.         print "go C go!"
    
14. 
    
15. class D(B,C):
    
16.     def go(self):
    
17.         super(D, self).go()
    
18.         print "go D go!"
    
19. d = D()
    
20. d.go()

复制代码

结果：
go A go!
go C go!
go B go!
go D go!


解释一下这个结果是什么情况

最佳答案

月排行榜 / 总排行榜

冬雪雪冬

2018-2-28 08:45:15

lyjlyj 发表于 2018-2-28 08:41
不是先找b吗，b找到了，为什么还会找c

具体的运行逻辑我也不清楚，但从实际运行的结果看到B后，先挂在super().go()处，再去运行C，等都运行完毕后，再从B的挂起处进行运行。
说起来菱形继承会带来很大的困惑，如果掌握不好，还是尽量少用为好。

跳转到最佳答案楼层

冬雪雪冬

参见小甲鱼的帖子：http://bbs.fishc.com/thread-48759-1-2.html
我的理解：
执行：D.__mro__得到运行次序为

1. >>> D.__mro__
   
2. (<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)

复制代码

即先运行D，由于D是继承了B和C所以再运行B，并在执行super时先挂起，再运行D，再调用A。此时输出go A go!，返回执行go C go!，再返回至B，按说应该再调用A，但A已经在D中调用一次了，就不再调用了，输出go B go!，再返回D，输出go D go!。
稍微改一下程序，输出结果看的更清楚了。

1. class A(object):
   
2.     def go(self):
   
3.         print ("go A go!")
   
4. 
   
5. class B(A):
   
6.     def go(self):
   
7.         print('B')
   
8.         super().go()
   
9.         print ("go B go!")
   
10. 
    
11. class C(A):
    
12.     def go(self):
    
13.         super().go()
    
14.         print( "go C go!")
    
15. 
    
16. class D(B,C):
    
17.     def go(self):
    
18.         super().go()
    
19.         print ("go D go!")
    
20. d = D()
    
21. d.go()

复制代码

1. B
   
2. go A go!
   
3. go C go!
   
4. go B go!
   
5. go D go!

复制代码

南城顾她

D 继承了B继承了C B又继承了A  就是说D直接继承了B.C间接继承了A 所有B.C.A中的公有属性D都继承了

lyjlyj

冬雪雪冬 发表于 2018-2-27 20:31
参见小甲鱼的帖子：http://bbs.fishc.com/thread-48759-1-2.html
我的理解：
执行：D.__mro__得到运行次 ...

不是先找b吗，b找到了，为什么还会找c

冬雪雪冬

lyjlyj 发表于 2018-2-28 08:41
不是先找b吗，b找到了，为什么还会找c

具体的运行逻辑我也不清楚，但从实际运行的结果看到B后，先挂在super().go()处，再去运行C，等都运行完毕后，再从B的挂起处进行运行。
说起来菱形继承会带来很大的困惑，如果掌握不好，还是尽量少用为好。