python中的多继承（经典类和新式类）

python和C++一样，支持多继承。概念虽然容易，但是困难的工作是如果子类调用一个自身没有定义的属性，它是按照何种顺序去到父类寻找呢，尤其是众多父类中有多个都包含该同名属性。

1. class P1 #(object): 
2.    def foo(self):           
3.        print 'p1-foo' 
4.  
5. class P2 #(object): 
6.    def foo(self): 
7.        print 'p2-foo' 
8.    def bar(self): 
9.        print 'p2-bar' 
10.  
11. class C1 (P1,P2): 
12.    pass  
13.  
14. class C2 (P1,P2): 
15.    def bar(self): 
16.        print 'C2-bar'   
17.  
18. class D(C1,C2): 
19.    pass 
20.   

对经典类和新式类来说，属性的查找顺序是不同的。现在我们分别看一下经典类和新式类两种不同的表现

1、经典类

1. d=D() 
2. d.foo() # 输出 p1-foo 
3. d.bar() # 输出 p2-bar 

实例d调用foo()时，搜索顺序是 D => C1 => P1

实例d调用bar()时，搜索顺序是 D => C1 => P1 => P2

换句话说，经典类的搜索方式是按照“从左至右，深度优先”的方式去查找属性。d先查找自身是否有foo方法，没有则查找最近的父类C1里是否有该方法，如果没有则继续向上查找，直到在P1中找到该方法，查找结束。

2、新式类

使用新式类要去掉第一段代码中的注释

1. d=D() 
2. d.foo() # 输出 p1-foo 
3. d.bar() # 输出 c2-bar 

实例d调用foo()时，搜索顺序是 D => C1 => C2 => P1

实例d调用bar()时，搜索顺序是 D => C1 => C2

可以看出，新式类的搜索方式是采用“广度优先”的方式去查找属性。

在python3中类已经添加（object）

出处：https://www.cnblogs.com/linyawen/archive/2012/04/25/2469538.html

补充：

从Python2.2开始，Python 引入了 new style class（新式类）

新式类跟经典类的差别主要是以下几点:

1. 新式类对象可以直接通过__class__属性获取自身类型:type

[python]  view plain  copy

1. # -*- coding:utf-8 -*-    
2.   
3. class E:    
4. #经典类  
5.     pass  
6.       
7. class E1(object):    
8. #新式类  
9.     pass  
10.        
11. e = E()  
12. print "经典类"  
13. print e  
14. print type(e)  
15. print e.__class__  
16.   
17. print "新式类"  
18. e1 = E1()  
19. print e1  
20. print e1.__class__  
21. print type(e1)  

[python]  view plain  copy

1. 经典类  
2. <__main__.E instance at 0x0000000002250B08>  
3. <type 'instance'>  
4. __main__.E  
5.   
6. 新式类  
7. <__main__.E1 object at 0x0000000002248710>  
8. <class '__main__.E1'>  
9. <class '__main__.E1'>  

我使用的是python 2.7。

E1是定义的新式类。那么输输出e1的时候，不论是type(e1)，还是e1.__class__都是输出的<class '__main__.E1'>。

2. 继承搜索的顺序发生了改变,经典类多继承属性搜索顺序: 先深入继承树左侧，再返回，开始找右侧;新式类多继承属性搜索顺序: 先水平搜索，然后再向上移动

[python]  view plain  copy

1. # -*- coding:utf-8 -*-    
2. class A(object):    
3.     """ 
4.     新式类 
5.     作为所有类的基类 
6.     """  
7.     def foo(self):    
8.         print "class A"   
9.           
10. class A1():    
11.     """ 
12.     经典类 
13.     作为所有类的基类 
14.     """  
15.     def foo(self):    
16.         print "class A1"    
17.           
18. class C(A):    
19.     pass  
20.       
21. class C1(A1):    
22.     pass  
23.       
24. class D(A):    
25.     def foo(self):    
26.         print "class D"    
27.       
28. class D1(A1):    
29.     def foo(self):    
30.         print "class D1"    
31.           
32.     
33.     
34. class E(C, D):    
35.     pass  
36.       
37. class E1(C1, D1):    
38.     pass  
39.   
40. e = E()  
41. e.foo()  
42.     
43.   
44. e1 = E1()  
45. e1.foo()  

输出

[python]  view plain  copy

1. class D  
2. class A1  

因为A新式类,对于继承A类都是新式类，首先要查找类E中是否有foo()，如果没有则按顺序查找C->D->A。它是一种广度优先查找方式。

因为A1经典类,对于继承A1类都是经典类，首先要查找类E1中是否有foo()，如果没有则按顺序查找C1->A1->D1。它是一种深度优先查找方式。

3. 新式类增加了__slots__内置属性, 可以把实例属性的种类锁定到__slots__规定的范围之中。

比如只允许对A实例添加name和age属性:

[python]  view plain  copy

1. # -*- coding:utf-8 -*-    
2.   
3. class A(object):    
4.     __slots__ = ('name', 'age')   
5.   
6. class A1():    
7.     __slots__ = ('name', 'age')   
8.       
9. a1 = A1()  
10. a = A()  
11.   
12. a1.name1 = "a1"  
13. a.name1 = "a"  

A是新式类添加了__slots__ 属性,所以只允许添加 name age

A1经典类__slots__ 属性没用，

[python]  view plain  copy

1. Traceback (most recent call last):  
2.   File "t.py", line 13, in <module>  
3.     a.name1 = "a"  
4. AttributeError: 'A' object has no attribute 'name1'  

所以a.name是会出错的

通常每一个实例都会有一个__dict__属性，用来记录实例中所有的属性和方法，也是通过这个字典，可以让实例绑定任意的属性

而__slots__属性作用就是，当类C有比较少的变量，而且拥有__slots__属性时，

类C的实例 就没有__dict__属性，而是把变量的值存在一个固定的地方。如果试图访问一个__slots__中没有

的属性，实例就会报错。这样操作有什么好处呢？__slots__属性虽然令实例失去了绑定任意属性的便利，

但是因为每一个实例没有__dict__属性，却能有效节省每一个实例的内存消耗，有利于生成小而精

干的实例。

4. 新式类增加了__getattribute__方法

[python]  view plain  copy

1. class A(object):    
2.     def __getattribute__(self, *args, **kwargs):    
3.         print "A.__getattribute__"  
4.           
5.       
6. class A1():    
7.     def __getattribute__(self, *args, **kwargs):    
8.         print "A1.__getattribute__"  
9.           
10.       
11. a1 = A1()  
12. a = A()  
13.   
14. a.test  
15. print "========="  
16. a1.test  

[python]  view plain  copy

1. A.__getattribute__  
2. =========  
3. Traceback (most recent call last):  
4.   File "t.py", line 18, in <module>  
5.     a1.test  
6. AttributeError: A1 instance has no attribute 'test'  

可以看出A是新式类，每次通过实例访问属性，都会经过__getattribute__函数,

A1不会调用__getattribute__所以出错了

Python 2.x中默认都是经典类，只有显式继承了object才是新式类

Python 3.x中默认都是新式类，不必显式的继承object

出处：https://blog.csdn.net/u010066807/article/details/46896835