新式类与经典类的比较

新式类与经典类的区别：

首先：

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

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

即：新式类都从object继承，经典类不需要

其次：

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

------继承搜索的顺序发生了改变

                经典类多继承属性搜索顺序: 先深入继承树左侧，再返回，开始找右侧 —— 即 经典类深度优先

                新式类多继承属性搜索顺序: 先水平搜索，然后再向上移动               —— 即 新式类广度优先

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

------新式类增加了__getattribute__方法

------新式类相同父类只执行一次构造函数，经典类重复执行多次。

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

#-*- coding:utf-8 -*-
#
class E1(object):
    pass

print('new_style class')
e1 = E1()
print(e1)
print(e1.__class__)
print(type(e1))

'''
new_style class
<__main__.E1 object at 0x7f76acfc2320>
<class '__main__.E1'>
<class '__main__.E1'>

'''

# -*- coding:utf-8 -*-
#

class E:
    pass

e = E() 
print('classic class')
print(e)
print(type(e))
print(e.__class__)

'''
classic class
<__main__.E instance at 0x7f31b429afc8>
<type 'instance'>
__main__.E

'''

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

 

2、经典类深度优先，新式类广度优先

#-*- coding:utf-8 -*-
#

class A(object):
    '''
    新式类，作为所有类的基类
    '''
    def foo(self):
        print('class A')

class A1:
    '''
    经典类，作为所有类的基类
    '''
    def foo(self):
        print('class A1')

class C(A):
    pass

class C1(A1):
    pass

class D(A):
    def foo(self):
        print('class D')

class D1(A1):
    def foo(self):
        print('class D1')

class E(C, D):
    pass

class E1(C1, D1):
    pass


e = E()
e.foo()
e1 = E1()
e1.foo()

'''
class D
class A1
'''

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

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

 

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

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author: antcolonies

class A(object):
    __slots__ = ('name', 'age')

class A1:
    __slots__ = ('name', 'age')


a = A()
a1 = A1()

a.name1 = 'a'
a1.name1 = 'a1'

'''
Traceback (most recent call last):
  File "E:/python14_workspace/s14/day06/py_1.py", line 15, in <module>
    a.name1 = 'a'
AttributeError: 'A' object has no attribute 'name1'
'''

A是新式类添加了__slots__ 属性,所以只允许添加 ‘name’ 和 ‘age’ 两种属性

A1经典类__slots__ 属性不起作用。

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

而__slots__属性作用就是，当一个类C有比较少的变量，而且拥有__slots__属性时，类C的实例就没有__dict__属性，而是把变量的值存在一个固定的地方。如果试图访问一个__slots__中没有的属性，实例就会报错。这样操作有什么好处呢？__slots__属性虽然令实例失去了绑定任意属性的便利，但是因为每一个实例没有__dict__属性，却能有效节省每一个实例的内存消耗，有利于生成小而精干的实例。

#-*- coding:utf-8 -*-
#

class A(object):
    __slots__ = ('name', 'age')

class A1:
    __slots__ = ('name', 'age')


a = A()
a1 = A1()

# a.name1 = 'a'
a1.name1 = 'a1'
a1.name = 'Tom'
a1.age = '23'
a.name = 'Tim'
a.age = '22'
print(a1.__dict__)
print(a.__slots__)
print(a.name, a.age)
print(a.__dict__)

'''
{'age': '23', 'name': 'Tom', 'name1': 'a1'}
('name', 'age')
('Tim', '22')
Traceback (most recent call last):
  File "py_4.py", line 21, in <module>
      print(a.__dict__)
AttributeError: 'A' object has no attribute '__dict__'
'''

 

4、新式类增加了__getattribute__方法

#-*- coding:utf-8 -*-
#

class A(object):
    def __getattribute__(self, *args, **kwargs):
        print('A.__getattribute__')

class A1: 
    def __getattribute__(self, *args, **kwargs):
        print('A1.__getattribute__')


a = A() 
a1 = A1()

a.test
print('============')
a1.test

'''
A.__getattribute__
============
Traceback (most recent call last):
  File "py_5.py", line 18, in <module>
      a1.test
AttributeError: A1 instance has no attribute 'test'
'''

可以看出A是新式类，每次通过实例访问属性，都会经过__getattribute__函数，A1不会调用__getattribute__所以出错了。

 

5、新式类相同父类只执行一次构造函数，经典类重复执行多次。

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author: antcolonies

class A:
    def __init__(self):
        print('a', end='')

class B(A):
    def __init__(self):
        A().__init__()
        print('b', end='')

class C(A):
    def __init__(self):
        A().__init__()
        print('c', end='')

class D(B, C):
    def __init__(self):
        B().__init__()
        C().__init__()
        print('d', end='')

class E(D, A):
    def __init__(self):
        D().__init__()
        A().__init__()
        print('e', end='')

d = D()
print('')
e = E()

'''
aabaabaacaacd
aabaabaacaacdaabaabaacaacdaae
'''

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author: antcolonies

class A(object):
    def __init__(self):
        print('a', end='')

class B(A):
    def __init__(self):
        super(B,self).__init__()
        print('b', end='')

class C(A):
    def __init__(self):
        super(C, self).__init__()
        print('c', end='')

class D(B, C):
    def __init__(self):
        super(D, self).__init__()
        print('d', end='')

class E(D, A):
    def __init__(self):
        super(E, self).__init__()
        print('e', end='')

d = D()
print('')
e = E()

'''
acbd
acbde
'''