Python之经典类VS新式类和Supper

简介: Python之经典类VS新式类和Supper

问题:

把下面代码用python2 和python3都执行一下

  1. #_*_coding:utf-8_*_

  2. classA:
  3.    def__init__(self):
  4.        self.n = 'A'

  5. classB(A):
  6.    # def __init__(self):
  7.    #     self.n = 'B'
  8.    pass

  9. classC(A):
  10.    def__init__(self):
  11.        self.n = 'C'

  12. classD(B,C):
  13.    # def __init__(self):
  14.    #     self.n = 'D'
  15.    pass
  16. obj = D()

  17. print(obj.n)


输出结果


  1. D:\Python\python\python-2.7.13\Python27\python2.exe
  2. A
  3. D:\Python\python\python-3.6.1\Python36-64\python.exe
  4. C


  • 原因:
  1. classical vs new style:

  2. 经典类:深度优先
  3. 新式类:广度优先
  1. 1)首先,他们写法不一样:
  2. classA:
  3.    pass

  4. classB(object):
  5.    pass
  6. 2)在多继承中,新式类采用广度优先搜索,而旧式类是采用深度优先搜索。
  7. 3)新式类更符合OOP编程思想,统一了python中的类型机制。


  • 分析:


从Python2.2开始,Python 引入了 new style class(新式类)

   

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

  1. 新式类对象可以直接通过__class__属性获取自身类型:type
  2. 继承搜索的顺序发生了改变,经典类多继承属性搜索顺序: 先深入继承树左侧,再返回,开始找右侧;新式类多继承属性搜索顺序:
  3. 先水平搜索,然后再向上移动;
  4. 新式类增加了__slots__内置属性, 可以把实例属性的种类锁定到__slots__规定的范围之中;
  5. 新式类增加了__getattribute__方法;



  • 举例说明
  • 新式类对象可以直接通过__class__属性获取自身类型:type;

  1. # -*- coding:utf-8 -*-

  2. classE:
  3.    # 经典类
  4.    pass

  5. classE1(object):
  6.    # 新式类
  7.    pass

  8. e = E()
  9. print("经典类")
  10. print(e)
  11. print(type(e))
  12. print(e.__class__)

  13. print("新式类")
  14. e1 = E1()
  15. print(e1)
  16. print(type(e1))
  17. print(e1.__class__)


输出结果:


  • pyhon2.7

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


  • pyhon3.6


  1. 经典类
  2. <__main__.E object at 0x000000000267B7F0>
  3. <class'__main__.E'>
  4. <class'__main__.E'>
  5. 新式类
  6. <__main__.E1 object at 0x000000000267B3C8>
  7. <class'__main__.E1'>
  8. <class'__main__.E1'>


  • Python 2.x中默认都是经典类,只有显式继承了object才是新式类
  • Python 3.x中默认都是新式类,不必显式的继承object
  • E1是定义的新式类。那么输输出e1的时候,不论是type(e1),还是e1.__class__都是输出的<class '__main__.E1'>。



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

  1. # -*- coding:utf-8 -*-
  2. classA(object):
  3.    """
  4. 新式类
  5.    作为所有类的基类
  6.    """
  7.    deffoo(self):
  8.        print("class A")
  9. class A1():
  10.    """
  11. 经典类
  12.    作为所有类的基类
  13.    """
  14.    deffoo(self):
  15.        print("class A1")


  16. classC(A):
  17.    pass


  18. classC1(A1):
  19.    pass

  20. classD(A):
  21.    deffoo(self):
  22.        print("class D")


  23. classD1(A1):
  24.    deffoo(self):
  25.        print("class D1")


  26. classE(C, D):
  27.    pass

  28. classE1(C1, D1):
  29.    pass

  30. e = E()
  31. e.foo()

  32. e1 = E1()
  33. e1.foo()


  • pyhon2.7
  1. classD
  2. classA1


  • pyhon3.6

  1. classD
  2. classD1


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

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


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

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


  1. # -*- coding:utf-8 -*-
  2. classA(object):
  3.    __slots__ = ('name', 'age')

  4. classA1():
  5.    __slots__ = ('name', 'age')

  6. a1 = A1()
  7. a = A()

  8. a1.name1 = "a1"
  9. a.name1 = "a"
  • pyhon2.7

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


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

A1经典类__slots__ 属性没用,

所以a.name是会出错的


  • pyhon3.6

  1. Traceback (most recent call last):
  2.  File "test.py", line 11, in <module>
  3.    a1.name1 = "a1"
  4. AttributeError: 'A1'object has no attribute 'name1'


在python3.x中,

A和

A1都是新式类

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

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

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

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

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

  7. 干的实例。



  • 新式类增加了__getattribute__方法;

  1. classA(object):
  2.    def__getattribute__(self, *args, **kwargs):
  3.        print("A.__getattribute__")


  4. classA1():
  5.    def__getattribute__(self, *args, **kwargs):
  6.        print("A1.__getattribute__")

  7. a1 = A1()
  8. a = A()

  9. a.test
  10. print("=========")
  11. a1.test


  • pyhon2.7

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


  • pyhon3.6

  1. A.__getattribute__
  2. =========
  3. A1.__getattribute__

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

A1不会调用__getattribute__所以出错了


总之


  1. Python 2.x中默认都是经典类,只有显式继承了object才是新式类
  2. Python 3.x中默认都是新式类,不必显式的继承object


super()


  1. super(self,C).func()    #调用的并不是其父类C的func,而是C在MRO中的下一个类的func,
  2. 不能再经典类中使用
  3. 开始一直以为在多重继承的情况下选择执行某个父类的方法,网上有不少也是这么说的(被误导了)。
  4.  
  5. 经典类的MRO(基类搜索顺序)算法是深度优先。
    新式类的MRO算法是C3算法。


  1. classA(object):
  2.    def__init__(self):
  3.        print"A"

  4. classB(object):
  5.    def__init__(self):
  6.        print ("B")

  7. classC(object):
  8.    def__init__(self):
  9.        print ("C")

  10. classD(A, B, C):
  11.    def__init__(self):
  12.        super(D, self).__init__()
  13.        super(A, self).__init__()
  14.        super(B, self).__init__()
  15.        super(C, self).__init__()

  16. X = D()


输出结果:

  1. A
  2. B
  3. C

会发现:

  1. super(D,self).__init__()  

执行的是A.__init__()


  1. super(A,self).__init__()  

执行的是B.__init__()


  1. super(B,self).__init__()  

执行的是C.__init__()


  1. super(C,self).__init__()  

执行的是Object.__init__()


这是因为mro(D)为:[ D, A, B, C, Object]




目录
相关文章
|
3月前
|
索引 Python
python-类属性操作
【10月更文挑战第11天】 python类属性操作列举
32 1
|
3月前
|
Java C++ Python
Python基础---类
【10月更文挑战第10天】Python类的定义
30 2
|
3月前
|
设计模式 开发者 Python
Python类里引用其他类
Python类里引用其他类
32 4
|
3月前
|
设计模式 开发者 Python
Python 类中引用其他类的实现详解
Python 类中引用其他类的实现详解
65 1
|
3月前
|
JSON 缓存 API
在 Python 中使用公共类处理接口请求的响应结果
在 Python 中使用公共类处理接口请求的响应结果
39 1
|
3月前
|
机器人 关系型数据库 Python
【Python篇】Python 类和对象:详细讲解(下篇)
【Python篇】Pyt hon 类和对象:详细讲解(下篇)
37 2
|
3月前
|
算法 Python
【Python篇】Python 类和对象:详细讲解(中篇)
【Python篇】Python 类和对象:详细讲解(中篇)
46 2
|
3月前
|
存储 C++ Python
【Python篇】Python 类和对象:详细讲解(上篇)
【Python篇】Python 类和对象:详细讲解(上篇)
59 2
|
4月前
|
前端开发 Python
Python编程的面向对象有哪些(二)
Python编程的面向对象(二)—类的多态
30 7
|
4月前
|
IDE Java 开发工具
Python类与面向对象
Python类与面向对象