devbox
Guff_9hys
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【Python】super() 函数丨MRO丨钻石继承_python super mro

作者：Guff_9hys | 2024-07-18 12:04:48

赞

踩

python super mro

主要整理自：
https://www.runoob.com/python/python-func-super.html
https://blog.csdn.net/come_from_pluto
https://blog.csdn.net/yangjiajia123456?type=blog

1 super()函数 描述

  • super() 函数是用于调用父类(超类)的一个方法。

  • super() 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。

1.1 MRO

1.1.1 MRO 概念

  • MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。
    在这里插入图片描述

1.1.2 人工计算MRO

下面，以如下代码为例，人工计算MRO（并不是C3算法的逻辑，只是为了算出MRO）：

class F:
    pass
class E:
    pass
class D:
    pass
class B(D,E):
    pass
class C(D,F):
    pass
class A(B,C):
    pass

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
'
运行

  1. 画继承顺序图

    原则：遇到多继承则按代码中继承列表的顺序从左往右写。如果有多个子类继承了同一个父类，那么这个父类则放在它能够出现的所有位置中最左的位置（注意：如下图中那样，D既可以放在B的左上方，又可以放在C的左上方，这种情况下，我们选择放在B的左上方，因为这样D在其所在层更加靠左），然后让这些子类指向它，就像下图中类D那样。
    在这里插入图片描述
    P.S.
    A先继承B，后继承C。所以B在C的左边。
    B继承了D和E，C继承了D和F。B和C都继承了D，D写在哪里呢？
    答案是：D要写在B的左上角。

    P.P.S.
    在python中，任何类默认都是继承自object类的，所以让最上层的D、E、F指向object。当然，你也可以选择在画图的时候将A，B，C等等所有类都画一个指向object的箭头，但随着以下方法的进行，其实这两种画法结果是一样的。

  2. 计算MRO表

    需遵循图里面的广度优先原则进行遍历（广度优先原则：优先遍历左边的）：

    首先寻找整个图中入度为0的，也就是A，那么A也就成为MRO中的第一个。

    然后我们去掉图中的A节点以及与A相关的连线，再寻找入度为0的点，这时有B和C两个节点，我们选择最左边的点即B。选完左边的B点后，再选右边的C点，这样B和C也就跟着进入了MRO序列，现在MRO序列为{A,B,C}。（注意每次层次遍历一定要把那一层选完才能选下一层，不能在没有选C之前跳到选E）

    然后去掉B和C以及与它们相关的连线，这时候入度为0的也就是D、E、F了，依次选择，使D、E、F进入MRO序列。

    最后也就使得object进入MRO序列。

    以上的MRO序列也就是{A,B,C,D,E,F,object}

    P.S. 什么是出度与入度？
    在有向图中，箭头是具有方向的，从一个顶点指向另一个顶点，这样一来，每个顶点被指向的箭头个数，就是它的入度。从这个顶点指出去的箭头个数，就是它的出度

1.1.3 怎么查阅某个类的MRO表

使用 类名.mro()可以查阅其MRO表：

  • 1

在这里插入图片描述

1.2 重复调用（钻石继承）

如果子类继承自两个单独的超类，而那两个超类又继承自同一个公共基类，那么就构成了钻石继承体系。这种继承体系很像竖立的菱形，也称作菱形继承。

经典的菱形继承案例，B、C继承A，然后D继承B、C：
在这里插入图片描述

2 super()函数 语法

super(type[, object-or-type])

  • 1

参数：

  • type – 类。
  • object-or-type – 类，一般是 self

Python 3 可以直接使用 super().xxx 代替 super(Class, self).xxx:

# python 2.x
class A(object):   # Python2.x 记得继承 object
    def add(self, x):
         y = x+1
         print(y)
class B(A):
    def add(self, x):
        super(B, self).add(x)
b = B()
b.add(2)  # 3

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
'
运行
# python 3.x
class A:
     def add(self, x):
         y = x+1
         print(y)
class B(A):
    def add(self, x):
        super().add(x)
b = B()
b.add(2)  # 3

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
'
运行

3 super()函数 实例

例1

class A:
    def __init__(self):
        print("Enter A")
        print(self)     # this will print <__main__.D object at 0x...>
        print("Leave A")


class B(A):
    def __init__(self):
        print("Enter B")
        print(self)     # this will print <__main__.D object at 0x...>
        super(B, self).__init__()
        print("Leave B")


class C(A):
    def __init__(self):
        print("Enter C")
        print(self)     # this will print <__main__.D object at 0x...>
        super(C, self).__init__()
        print("Leave C")


class D(B, C):
    def __init__(self):
        print("Enter D")
        print(self)     # this will print <__main__.D object at 0x...>
        super(D, self).__init__()
        print("Leave D")


d = D()

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
'
运行

运行结果：

Enter D
<__main__.D object at 0x7fdb02618490>
Enter B
<__main__.D object at 0x7fdb02618490>
Enter C
<__main__.D object at 0x7fdb02618490>
Enter A
<__main__.D object at 0x7fdb02618490>
Leave A
Leave C
Leave B
Leave D

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

1.创建 D 类的对象 d 时，自动调用 D 类的初始化方法 init()，此时的 self 指向 D 类创建的实例对象 d；

2.MRO：D->B->C->A

D.mro()
# [__main__.D, __main__.B, __main__.C, __main__.A, object]

  • 1
  • 2

3.在调用到 B 时，首先输出 “Enter B”，但是运行到父类 A 的初始化方法时不立即调用，反而时转向广度优先级高的 C 类，因为 A 类对于 B 类来说是深度遍历。

P.S.
super(). _init_()这个功能，应该是去调用父类的构造方法。
到了super(D, self)._init_()语句，D的父类是B和C，先调用B类的构造方法。先打印一个"Enter B"，然后打印self。
到了super(B, self)._init_()，为了避免重复引用，先不执行，按照MRO的顺序去继续找—>找到C类。
同样，打印一个"Enter C"，然后打印self。
到了super(C, self)._init_()，也还是先不执行，跑去A类。
A没有调用其他的构造方法，打印"Enter A"，打印self，然后打印"Leave A"。
回到C类，打印"Leave C"。
回到B类，打印"Leave B"。
回到D类，打印"Leave D"。

P.P.S
可以理解为：在多继承里面，查找顺序是MRO，但是真正完成各个构造方法（_init_）的顺序却是MRO的相反顺序。如这个例子里面，MRO是D、B、C、A，但完成顺序是"Leave A"、“Leave C”、“Leave B”、“Leave D”。

下面的例子可以更具体地感受一下这个逻辑：

例2

class Base:
    def __init__(self, value):
        self.value = value
 
 
class One(Base):
    def __init__(self, value):
        Base.__init__(self, value)
        self.value *= 2
 
 
class Two(Base):
    def __init__(self, value):
        Base.__init__(self, value)
        self.value += 3
 
 
class Ways(One, Two):
    def __init__(self, value):
        One.__init__(self, value)
        Two.__init__(self, value)
 
foo = Ways(5)
print(foo.value)
 
8

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
'
运行

我们认为它会输出13，但结果却是8，因为在调用第二个超类时，即Two.init，它会再次调用Base.init，从而导致self.value重新变成5。

解决这个问题的方式是使用super方法，根据方法解析顺序(MRO)以标准化的流程来安排超类之间的初始化顺序，它也能够保证钻石顶部的公共基类的__init__方法只运行一次。

于是加入super()，修改为：

class Base:
    def __init__(self, value):
        self.value = value
 
 
class One(Base):
    def __init__(self, value):
        super(One, self).__init__(value)
        self.value *= 2
 
 
class Two(Base):
    def __init__(self, value):
        super(Two, self).__init__(value)
        self.value += 3
 
 
class Ways(One, Two):
    def __init__(self, value):
        super(Ways, self).__init__(value)
 
foo = Ways(5)
print(foo.value)
 
16

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
'
运行

这是怎么回事？为何和我们设想的刚好相反。应该先运行One.init，然后运行Two.init。但实际却不一样，程序的运行会与Ways的MRO顺序保持一致。调用Ways(5)时，它会调用One.init，One.__init__又调用Two.init，Two.__init__在调用Base.init。到达了钻石继承的顶端，所有的初始化方法会按照与刚才那些__init__相反的顺序完成。

再次进行修改：

class Base:
    def __init__(self, value):
        self.value = value
 
 
class One(Base):
    def __init__(self, value):
        super(One, self).__init__(value * 2)
 
 
class Two(Base):
    def __init__(self, value):
        super(Two, self).__init__(value + 3)
 
 
class Ways(One, Two):
    def __init__(self, value):
        super(Ways, self).__init__(value)
 
foo = Ways(5)
print(foo.value)
 
13

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
'
运行

这样做问题就解决了。

例3

再感受一下：

class A():
    def __init__(self):
        print('enter A')
        print('leave A')


class B(A):
    def __init__(self):
        print('enter B')
        super().__init__()
        print('leave B')


class C(A):
    def __init__(self):
        print('enter C')
        super().__init__()
        print('leave C')


class D(B, C):
    def __init__(self):
        print('enter D')
        super().__init__()
        print('leave D')


d = D()

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
'
运行

执行结果是：

enter D
enter B
enter C
enter A
leave A
leave C
leave B
leave D

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

例4

class FooParent(object):
    def __init__(self):
        self.parent = 'I\'m the parent.'
        print ('Parent')
    
    def bar(self,message):
        print ("%s from Parent" % message)
 
class FooChild(FooParent):
    def __init__(self):
        # super(FooChild,self) 首先找到 FooChild 的父类（就是类 FooParent），然后把类 FooChild 的对象转换为类 FooParent 的对象
        super(FooChild,self).__init__()    
        print ('Child')
        
    def bar(self,message):
        super(FooChild, self).bar(message)
        print ('Child bar fuction')
        print (self.parent)
 
if __name__ == '__main__':
    fooChild = FooChild()
    fooChild.bar('HelloWorld')

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
'
运行

执行结果：

Parent
Child
HelloWorld from Parent
Child bar fuction
I'm the parent.

  • 1
  • 2
  • 3
  • 4
  • 5

例5

没有继承父类的构造方法，没有继承父类的实例属性：

class Bird:
    def __init__(self):
          self.hungry = True
    def eat(self):
          if self.hungry:
               print ('Ahahahah')
          else:
               print ('No thanks!')

class SongBird(Bird):
     def __init__(self):
          self.sound = 'Squawk'
     def sing(self):
          print (self.sound)

sb = SongBird()
sb.sing()    # 能正常输出
sb.eat()     # 报错，因为 songgird 中没有 hungry 特性

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

解决这个问题的办法有两种：

1、调用未绑定的超类构造方法（多用于旧版 python 阵营）

class Bird:
    def __init__(self):
          self.hungry = True
    def eat(self):
          if self.hungry:
               print ('Ahahahah')
          else:
               print ('No thanks!')

class SongBird(Bird):
     def __init__(self):
          Bird.__init__(self)
          self.sound = 'Squawk'
     def sing(self):
          print (self.sound)

sb = SongBird()
sb.sing()   
sb.eat()     

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
'
运行

原理：在调用了一个实例的方法时，该方法的self参数会自动绑定到实例上（称为绑定方法）；如果直接调用类的方法（比如Bird.init），那么就没有实例会被绑定，可以自由提供需要的self参数（未绑定方法）。

2、使用super函数（只在新式类中有用）

class Bird:
    def __init__(self):
          self.hungry = True
    def eat(self):
          if self.hungry:
               print ('Ahahahah')
          else:
               print ('No thanks!')

class SongBird(Bird):
     def __init__(self):
          super(SongBird,self).__init__()
          self.sound = 'Squawk'
     def sing(self):
          print(self.sound)

sb = SongBird()
sb.sing() 
sb.eat()  

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
'
运行

原理：它会查找所有的超类，以及超类的超类，直到找到所需的特性为止。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Guff_9hys/article/detail/845562
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号