问题:
把下面代码用python2 和python3都执行一下
#_*_coding:utf-8_*_
classA:
def__init__(self):
self.n = 'A'
classB(A):
# def __init__(self):
# self.n = 'B'
pass
classC(A):
def__init__(self):
self.n = 'C'
classD(B,C):
# def __init__(self):
# self.n = 'D'
pass
obj = D()
print(obj.n)
输出结果
D:\Python\python\python-2.7.13\Python27\python2.exe
A
D:\Python\python\python-3.6.1\Python36-64\python.exe
C
- 原因:
classical vs new style:
经典类:深度优先
新式类:广度优先
1)首先,他们写法不一样:
classA:
pass
classB(object):
pass
2)在多继承中,新式类采用广度优先搜索,而旧式类是采用深度优先搜索。
3)新式类更符合OOP编程思想,统一了python中的类型机制。
- 分析:
从Python2.2开始,Python 引入了 new style class(新式类)
新式类跟经典类的差别主要是以下几点:
新式类对象可以直接通过__class__属性获取自身类型:type;
继承搜索的顺序发生了改变,经典类多继承属性搜索顺序: 先深入继承树左侧,再返回,开始找右侧;新式类多继承属性搜索顺序:
先水平搜索,然后再向上移动;
新式类增加了__slots__内置属性, 可以把实例属性的种类锁定到__slots__规定的范围之中;
新式类增加了__getattribute__方法;
- 举例说明
- 新式类对象可以直接通过__class__属性获取自身类型:type;
# -*- coding:utf-8 -*-
classE:
# 经典类
pass
classE1(object):
# 新式类
pass
e = E()
print("经典类")
print(e)
print(type(e))
print(e.__class__)
print("新式类")
e1 = E1()
print(e1)
print(type(e1))
print(e1.__class__)
输出结果:
- pyhon2.7
经典类
<__main__.E instance at 0x0000000002ABF148>
<type'instance'>
__main__.E
新式类
<__main__.E1 object at 0x0000000002AB65C0>
<class'__main__.E1'>
<class'__main__.E1'>
- pyhon3.6
经典类
<__main__.E object at 0x000000000267B7F0>
<class'__main__.E'>
<class'__main__.E'>
新式类
<__main__.E1 object at 0x000000000267B3C8>
<class'__main__.E1'>
<class'__main__.E1'>
- Python 2.x中默认都是经典类,只有显式继承了object才是新式类
- Python 3.x中默认都是新式类,不必显式的继承object
- E1是定义的新式类。那么输输出e1的时候,不论是type(e1),还是e1.__class__都是输出的<class '__main__.E1'>。
- 继承搜索的顺序发生了改变,经典类多继承属性搜索顺序:先深入继承树左侧,再返回,开始找右侧;新式类多继承属性搜索顺序: 先水平搜索,然后再向上移动;
# -*- coding:utf-8 -*-
classA(object):
"""
新式类
作为所有类的基类
"""
deffoo(self):
print("class A")
- class A1():
"""
经典类
作为所有类的基类
"""
deffoo(self):
print("class A1")
classC(A):
pass
classC1(A1):
pass
classD(A):
deffoo(self):
print("class D")
classD1(A1):
deffoo(self):
print("class D1")
classE(C, D):
pass
classE1(C1, D1):
pass
e = E()
e.foo()
e1 = E1()
e1.foo()
- pyhon2.7
classD
classA1
- pyhon3.6
classD
classD1
因为A新式类,对于继承A类都是新式类,首先要查找类E中是否有foo(),如果没有则按顺序查找C->D->A。它是一种广度优先查找方式。
因为A1经典类,对于继承A1类都是经典类,首先要查找类E1中是否有foo(),如果没有则按顺序查找C1->A1->D1。它是一种深度优先查找方式。
- 新式类增加了__slots__内置属性, 可以把实例属性的种类锁定到__slots__规定的范围之中;
比如只允许对A实例添加name和age属性:
# -*- coding:utf-8 -*-
classA(object):
__slots__ = ('name', 'age')
classA1():
__slots__ = ('name', 'age')
a1 = A1()
a = A()
a1.name1 = "a1"
a.name1 = "a"
- pyhon2.7
Traceback (most recent call last):
File "test.py", line 12, in <module>
a.name1 = "a"
AttributeError: 'A'object has no attribute 'name1'
A是新式类添加了__slots__ 属性,所以只允许添加 name age
A1经典类__slots__ 属性没用,
所以a.name是会出错的
- pyhon3.6
Traceback (most recent call last):
File "test.py", line 11, in <module>
a1.name1 = "a1"
AttributeError: 'A1'object has no attribute 'name1'
在python3.x中,
A和
A1都是新式类
通常每一个实例都会有一个__dict__属性,用来记录实例中所有的属性和方法,也是通过这个字典,可以让实例绑定任意的属性
而__slots__属性作用就是,当类C有比较少的变量,而且拥有__slots__属性时,
类C的实例 就没有__dict__属性,而是把变量的值存在一个固定的地方。如果试图访问一个__slots__中没有
的属性,实例就会报错。
这样操作有什么好处呢?__slots__属性虽然令实例失去了绑定任意属性的便利,
但是因为每一个实例没有__dict__属性,却能有效节省每一个实例的内存消耗,有利于生成小而精
干的实例。
- 新式类增加了__getattribute__方法;
classA(object):
def__getattribute__(self, *args, **kwargs):
print("A.__getattribute__")
classA1():
def__getattribute__(self, *args, **kwargs):
print("A1.__getattribute__")
a1 = A1()
a = A()
a.test
print("=========")
a1.test
- pyhon2.7
A.__getattribute__
Traceback (most recent call last):
=========
File "test.py", line 15, in <module>
a1.test
AttributeError: A1 instance has no attribute 'test'
- pyhon3.6
A.__getattribute__
=========
A1.__getattribute__
可以看出A是新式类,每次通过实例访问属性,都会经过__getattribute__函数,
A1不会调用__getattribute__所以出错了
总之
Python 2.x中默认都是经典类,只有显式继承了object才是新式类
Python 3.x中默认都是新式类,不必显式的继承object
super()
super(self,C).func() #调用的并不是其父类C的func,而是C在MRO中的下一个类的func,
不能再经典类中使用
开始一直以为在多重继承的情况下选择执行某个父类的方法,网上有不少也是这么说的(被误导了)。
经典类的MRO(基类搜索顺序)算法是深度优先。
新式类的MRO算法是C3算法。
classA(object):
def__init__(self):
print"A"
classB(object):
def__init__(self):
print ("B")
classC(object):
def__init__(self):
print ("C")
classD(A, B, C):
def__init__(self):
super(D, self).__init__()
super(A, self).__init__()
super(B, self).__init__()
super(C, self).__init__()
X = D()
输出结果:
A
B
C
会发现:
super(D,self).__init__()
执行的是A.__init__()
super(A,self).__init__()
执行的是B.__init__()
super(B,self).__init__()
执行的是C.__init__()
super(C,self).__init__()
执行的是Object.__init__()
这是因为mro(D)为:[ D, A, B, C, Object]