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

已于 2023-04-06 15:08:33 修改
阅读量1k 收藏 13
点赞数 1
分类专栏： Python入门 文章标签： python
于 2022-12-02 14:03:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Shi_Xueqing/article/details/128132656
版权

主要整理自：
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. 画继承顺序图

    原则：遇到多继承则按代码中继承列表的顺序从左往右写。如果有多个子类继承了同一个父类，那么这个父类则放在它能够出现的所有位置中最左的位置（注意：如下图中那样，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.2 重复调用（钻石继承）

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

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

2 super()函数 语法

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

参数：

  • 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

# 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

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()

运行结果：

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.创建 D 类的对象 d 时，自动调用 D 类的初始化方法 init()，此时的 self 指向 D 类创建的实例对象 d；

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

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

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

我们认为它会输出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

这是怎么回事？为何和我们设想的刚好相反。应该先运行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

这样做问题就解决了。

例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()

执行结果是：

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

例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')

执行结果：

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

例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、调用未绑定的超类构造方法（多用于旧版 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()

原理：在调用了一个实例的方法时，该方法的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()

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

_Greeeen_
关注
  • 1
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python MRO（方法解析顺序）
迹忆客
10-16 280
多重继承意味着单个子类可以继承多个类，并且子类将被授权访问属性和函数，除非它们不是该特定类的私有属性和函数。MRO 技术用于搜索正在执行的类的顺序。在这篇文章中，我们将学习Python MRO（方法解析顺序）。
java super()方法的作用
hitpter的专栏
09-25 2676
5.3. 编译器会自动插入super()调用：如果子类的构造方法没有显式地调用super()方法，编译器会在子类构造方法的第一行自动插入super()语句，以调用父类的无参构造方法。5.1. super()方法必须在子类的构造方法的第一行调用：在子类的构造方法中，如果需要调用父类的构造方法，必须使用super()方法，并且该语句必须放在子类构造方法的第一行。子类构造方法重载的作用是可以根据不同的情况选择不同的构造方法来初始化子类自己的成员变量，并调用父类的构造方法来初始化父类的成员变量和属性。
Python 的 super 函数， __mro__ 和多继承
最新发布
drin201312的博客
04-07 930
先说结论 —— super 函数在继承中的作用：返回 MRO 中的下一个 class 。
【Python基础】方法解析顺序MRO及Super的用法
qq_39057197的博客
08-05 85
如下：A,B还是一样，M同时继承C,D，根据局部优先顺序，C要求其子类先A后B，D要求其子类先B后A，M同时继承C,D，但C,D的局部优先顺序不一致，导致M无法计算出线性的MRO抛出异常。print的结果还是A，M只继承D，按照单调性，M的直接方法只能来自于父类iD，D的方法只能来自于父类C,B，按照局部优先顺序，D会先搜索父类C的say方法，最后发现父类C的say方法是Say A，所以M的say方法就是say A。，日常见到比较多的情况下如下：super()的形式，括号里的参数缺省。
super()方法详解
橙子味冰可乐的博客
08-12 261
python从小白到总裁完整教程目录。
super() 函数
清风拂面
10-22 429
class A(): def x(self): print('class A') super().x() print(self) class B(): def x(self): print('class B') print(self) class C(A,B): def x(self): print('class C') super().x() print.
Python多继承以及MRO顺序的使用
09-18
当我们通过`super()`函数调用方法时，Python会按照MRO顺序查找并执行方法。 以下是一些关于Python多继承和MRO顺序的关键点： 1. **单独调用父类的方法**： 在多继承中，可以通过直接指定父类名称和方法名来调用...
Python中super函数的用法
12-24
super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。 MRO 就是类的方法解析顺序表, 其实也就是...
Python中super函数用法实例分析
01-20
本文实例讲述了Python中super函数用法。分享给大家供大家参考，具体如下： 这是个高大上的函数,在python装13手册里面介绍过多使用可显得自己是高手 23333. 但其实他还是很重要的. 简单说, super函数是调用下一个父类...
python super()函数的基本使用
09-16
`super()`函数的主要目的是简化代码，避免直接引用父类名称，这样可以使代码更加灵活，减少硬编码，并有助于实现多继承场景下的方法解析顺序（MRO）。 在Python中，当我们创建一个子类并重写父类的方法时，有时需要...
Python高级编程之继承问题详解(super与mro)
01-20
本文实例讲述了Python高级编程之继承问题。分享给大家供大家参考，具体如下： 多继承问题 1.单独调用父类： 一个子类同时继承自多个父类，又称菱形继承、钻石继承。 使用父类名.init(self)方式调用父类时： 例： ...
super()用法
weixin_62574849的博客
04-03 938
#super()用法 ##1.super()可以调用父类的构造方法。 import java.util.*; //父类 public class Father { int id; //无参构造 public Father(){ System.out.println("调用父类的构造方法"); //有参构造 //public Father(int id){ // System.out.println("调用"+id); //} } //子类 class Son extends
python中的super函数及MRO
面向学姐编程
08-31 5943
super() 函数是用于调用父类(超类)的一个方法。 super是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。 MRO就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。 调用父类（超类）方法的两种方式：...
继承 super的讲解
xiaochen_从入门到实战
10-22 931
继承 super注意点 super调用父类的构造方法，必须在构造方法的第一个 super必须只能出现在子类的方法或者构造方法中 super和this 不能同时调用构造方法 对比this ​ 代表的对象不同 ​ this: 本身调用 用这个对象 ​ super: 代表父类对象的应用 ​ 前提 ​ this: 没有继承也可以使用 ​ super: 只能在继承条件才可以使用 ​ 构造方法 ​ this() 本类的构造 ​ super(); 父类的构造 pa
深入super，看Python如何解决钻石继承难题
weixin_30602505的博客
07-16 474
1. Python的继承以及调用父类成员 python子类调用父类成员有2种方法，分别是普通方法和super方法 假设Base是基类 class Base(object): 　 def __init__(self): 　　　　print “Base init” 则普通方法如下 class Leaf(Base): def __ini...
Python中super()函数简介及用法分享
Skylar
03-12 7529
首先看一下super()函数的定义: super([type [,object-or-type]]) Return a **proxy object** that delegates method calls to a **parent or sibling** class of type. 返回一个代理对象, 这个对象负责将方法调用分配给第一个参数的一个父类或者同辈的类去完成. pa
python中的MRO与多继承
Han的小站
02-22 9330
相关概念： MRO：Method Resolution Order，即方法解析顺序，是python中用于处理二义性问题的算法   二义性： python支持多继承，多继承的语言往往会遇到以下两类二义性的问题： 有两个基类A和B，A和B都定义了方法f()，C继承A和B，那么调用C的f()方法时会出现不确定。 有一个基类A，定义了方法f(
Python的继承及super的用法
weixin_30663471的博客
11-26 435
最近在Python的学习中，在面向对象的部分遭遇了让我近期寝食难安的继承，主要是卡在了多继承（钻石继承）的问题上，以下是我关于这个问题的简单认识 1 认识Python的继承 1.1 继承的概念 继承是面向对象三大特性的重要组成部分，其作用是子类通过继承父类可以获得来自父类的除私有内容以外的其他内容，继承的使用得以让开发人员在开发阶段可以省去大量的重复性的工作，也使项目的迭代和维护更加便捷。 1.2...
Python|类的多重继承及super()的调用
算法与编程之美
03-22 1400
欢迎点击「算法与编程之美」↑关注我们！本文首发于微信公众号："算法与编程之美"，欢迎关注，及时了解更多此系列文章。问题描述在python...
python super mro
10-06
它解决了多重继承中的一些问题，比如查找顺序（MRO）和钻石继承中的重复调用等。MRO（Method Resolution Order）是Python中用于确定方法调用顺序的算法。它是根据类的继承关系构建的一个线性列表，确定了方法查找的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值