一文详解python多继承的3C算法

心态决定输赢

python多继承的3C算法

有很多地方都说python多继承的继承顺序，是按照深度遍历的方式，其实python多继承顺序的算法，不是严格意义上的深度遍历，而是基于深度遍历基础上优化出一种叫3C算法

python多继承的深度遍历

1. class C:
   
2.     def run(self):
   
3.         print("这个是C类的方法");
   
4.     pass;
   
5. 
   
6. class A(C):
   
7.     # def run(self):
   
8.     #     print("这个是A类的方法");
   
9.     pass;
   
10. 
    
11. 
    
12. class B:
    
13.     def run(self):
    
14.         print("这个是B类的方法");
    
15. 
    
16. 
    
17. 
    
18. class MainC(A,B):
    
19.     pass;
    
20.     # def run(self):
    
21.     #     print("这个是子类的方法");
    
22. 
    
23. 
    
24. m1 = MainC();
    
25. m1.run();
    
26. print(MainC.mro())

复制代码

这段代码输出的结果就是 这个是C类的方法 [<class 'main.MainC'>, <class 'main.A'>, <class 'main.C'>, <class 'main.B'>, <class 'object'>]
每个类如果没有继承其他类的话就默认继承object这个基类 这个是比较正常的多继承，然后是深度遍历的方式

重复继承的问题

基于上面改造一下

1. class C:
   
2.     def run(self):
   
3.         print("这个是C类的方法");
   
4.     pass;
   
5. 
   
6. class A(C):
   
7.     # def run(self):
   
8.     #     print("这个是A类的方法");
   
9.     pass;
   
10. 
    
11. 
    
12. class B(C):
    
13.     def run(self):
    
14.         print("这个是B类的方法");
    
15. 
    
16. 
    
17. 
    
18. class MainC(A,B):
    
19.     pass;
    
20.     # def run(self):
    
21.     #     print("这个是子类的方法");
    
22. 
    
23. 
    
24. m1 = MainC();
    
25. m1.run();
    
26. print(MainC.mro())

复制代码

这个继承顺序就有意思了，main继承A和B，A继承C，B也继承C，这就出现了重复继承的问题，那这种情况python是如何决定继承顺序的呢 输出结果：

1. 这个是B类的方法
   
2. [<class '__main__.MainC'>, <class '__main__.A'>, <class '__main__.B'>, <class '__main__.C'>, <class 'object'>]

复制代码

这个结果就出乎意料了，因为按照深度遍历的方式的话，也应该继承C再继承B，但是却不是这样的 这个是因为python对于重复继承的处理，按照这个继承方式的话继承顺序是这样的 mianC先继承A，然后到查看C的情况，发现C同时被A和B继承了，然后就先不处理，接着继承B，然后看C的时候发现，没有其他的继承了，就接着继承C

更加复杂的继承

1. class F:
   
2.     def run(self):
   
3.         print("这个是F类的方法");
   
4.     pass;
   
5. 
   
6. class G:
   
7.     def run(self):
   
8.         print("这个是G类的方法");
   
9.     pass;
   
10. 
    
11. class E(F,G):
    
12.     def run(self):
    
13.         print("这个是E类的方法");
    
14.     pass;
    
15. 
    
16. class C(E):
    
17.     def run(self):
    
18.         print("这个是C类的方法");
    
19.     pass;
    
20. class D(E):
    
21.     def run(self):
    
22.         print("这个是D类的方法");
    
23. 
    
24. class A(C):
    
25.     # def run(self):
    
26.     #     print("这个是A类的方法");
    
27.     pass;
    
28. 
    
29. class B(D):
    
30.     def run(self):
    
31.         print("这个是B类的方法");
    
32. 
    
33. class MainC(A,B):
    
34.     pass;
    
35.     # def run(self):
    
36.     #     print("这个是子类的方法");
    
37. 
    
38. 
    
39. m1 = MainC();
    
40. m1.run();
    
41. print(MainC.mro())

复制代码

继承顺序：

1. [<class '__main__.MainC'>, <class '__main__.A'>, <class '__main__.C'>, <class '__main__.B'>, <class '__main__.D'>, <class '__main__.E'>, <class '__main__.F'>, <class '__main__.G'>, <class 'object'>]

复制代码

这个就是跟复杂的多继承了，但是只要用到上面说的逻辑去推理就知道继承顺序了 mainc先继承A，然后看C，没有被重复继承，就继承C，再看E，E被重复继承了，先不处理，再从上面开始看，看B，没有被重复继承，再看D也没有被重复继承，直接继承，再看E，也没有其他的再继承了就可以直接继承，然后再看F，没有重复继承，就继承，再到G
这个就是实际上python多继承顺序的算法，如果单纯说是深度遍历，其实是不对的

注意

尽量不要用多继承，尽量不要用多继承，尽量不要用多继承。 用多继承会让你的程序变得复杂又难读，产生的bug也难查
到此这篇关于一文详解python多继承的3C算法的文章就介绍到这了,更多相关python 3C算法内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

来源:https://www.jb51.net/python/3235325ea.htm
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！