Python super( )函数用法总结

一、super( ) 的用途

了解 super() 函数之前,我们首先要知道 super() 的用途是啥?

  • 主要用来在子类中调用父类的方法。
  • 多用于多继承问题中,解决查找顺序(MRO)、重复调用(钻石继承)等种种问题。

二、了解 super 的基础信息

语法格式:

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

函数描述:

返回一个代理对象,它会将方法调用委托给 type 的父类或兄弟类。

参数说明:

type —— 类,可选参数。object-or-type —— 对象或类,一般是 self,可选参数。

返回值:

super object —— 代理对象。

help 帮助信息:

>>> help(super)
Help on class super in module builtins:

class super(object)
 |  super() -> same as super(__class__, <first argument>)
 |  super(type) -> unbound super object
 |  super(type, obj) -> bound super object; requires isinstance(obj, type)
 |  super(type, type2) -> bound super object; requires issubclass(type2, type)
 |  Typical use to call a cooperative superclass method:
 |  class C(B):
 |      def meth(self, arg):
 |          super().meth(arg)
 |  This works for class methods too:
 |  class C(B):
 |      @classmethod
 |      def cmeth(cls, arg):
 |          super().cmeth(arg)

... ...
  • super 是一个继承自 object 的类,调用 super() 函数其实就是 super 类的实例化。
  • 根据官方文档的解释 super() 函数返回的对象 —— super object,就是一个代理对象。
  • super() 有四种参数的组合形式。
  • super()适用于类的静态方法。

三、典型用法

3.1 单继承问题

首先我们看一个最基本的子类调用父类方法的示例:

>>> class A:
        def funxx(self):
            print("执行 A 中的 funxx 方法 ... ...")

>>> class B(A):
        def funxx(self):
            A.funxx(self)       # 通过类名调用父类中的同名方法,self 参数代表 B 类的实例对象 b
            print("执行 B 中的 funxx 方法 ... ...")

>>> b = B()
>>> b.funxx()
执行 A 中的 funxx 方法 ... ...
执行 B 中的 funxx 方法 ... ...
  • 定义一个继承自 A 类的子类 B,并在 B 类中重写 funxx() 方法,B 中的 funxx() 是对 A 中的 funxx() 功能的拓展。
  • 因为是拓展了 A 类的 funxx() 方法的功能,所以其任然保留了原功能,即要在子类 B 中调用父类的同名方法来实现原有功能。
  • 上面的示例中是通过 A 类类名调用 A 类中的同名方法来实现的,而第一个参数 self 实际传递的是 B 类的实例 b。

使用 super() 函数来实现父类方法的调用:

>>> class A:
        def funxx(self):
            print("执行 A 中的 funxx 方法 ... ...")

>>> class B(A):
        def funxx(self):
            super().funxx()
            print("执行 B 中的 funxx 方法 ... ...")

>>> b = B()
>>> b.funxx()
执行 A 中的 funxx 方法 ... ...
执行 B 中的 funxx 方法 ... ...
  • 通过执行的结果可以看出实现了和普通类名调用的结果是一样的。
  • 在具有单继承的类层级结构中,super 引用父类而不必显式地指定它们的名称,从而令代码更易维护。(官方文档描述)
  • 也就是说,在子类中不再用父类名调用父类方法,而是用一个代理对象调用父类方法,这样当父类名改变或者继承关系发生变化时,不用对每个调用处都进行修改。

3.2 单继承问题拓展

help() 的帮助信息中,也说明了类中使用 super() 不带参数的形式等同于 super(__class__, <first argument>) 这种形式。这也是 Python 2.x 和 Python 3.x 关于 super() 的区别。

改写之前的单继承问题的代码:

>>> class A:
        def funxx(self):
            print("执行 A 中的 funxx 方法 ... ...")

>>> class B(A):
        def funxx(self):
	        super(B, self).funxx()
	        print("执行 B 中的 funxx 方法 ... ...")

>>> b = B()
>>> b.funxx()
执行 A 中的 funxx 方法 ... ...
执行 B 中的 funxx 方法 ... ...
  • 基本的调用方法 A.funxx(self) ,其中 self 指代实例对象 b。用语言描述为:实例对象 b 通过 A 类名调用方法 funxx()
  • 官方描述:返回一个代理对象,它会将方法调用委托给 type 的父类或兄弟类。用语言描述为:代理对象 super 通过 type 的父类或兄弟类调用其中的方法。
  • 我们发现 super 是通过参数设置来选择调用哪个父类的方法。其中第二个参数给出 MRO(方法解析顺序),也就是搜索目标方法的顺序,第一个参数则给出搜索目标方法的范围。
  • 例如 super(B, self) ,第一个参数为 B,第二个参数 self 为实例 b,其所在类的继承顺序(MRO)为:B→A→object。所以调用时是在 B 的父类 A 中寻找,如找不到目标方法则会在更上一层的 object 中寻找。

示例:

class A:
    pass

class B(A):
    pass

class C(A):
    def funxx(self):
        print("找到 funxx() 位于 C 中...")

class D(A):
    pass

class E(B, C):
    pass

class F(E, D):
    def funff(self):
        print("执行 F 中的 funff()...")
        super(E, self).funxx()

print(f"F 类的 MRO : {F.__mro__}")
f = F()
f.funff()

运行结果:

F 类的 MRO : (<class '__main__.F'>, <class '__main__.E'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.D'>, <class '__main__.A'>, <class 'object'>)
执行 F 中的 funff()...
找到 funxx() 位于 C 中...
  • 我们可以看出 F 类的 MRO:F→E→B→C→D→A→object。
  • super() 函数的第一个参数为:E,目标是调用 E 类的父类 B 中的 funxx() 方法,可惜 B 类中没找到,在 B 类的兄弟类 C 中找到了,符合要求。

3.3 重复调用问题

重复调用问题 也称 钻石继承问题 或 菱形图问题。

先来看看普通调用方法在:

>>> class A:
        def __init__(self):
            print("打印属性 a")

>>> class B(A):
        def __init__(self):
            print("打印属性 b")
            A.__init__(self)

>>> class C(A):
        def __init__(self):
            print("打印属性 c")
            A.__init__(self)

>>> class D(B, C):
        def __init__(self):
            print("打印属性 d")
            B.__init__(self)
            C.__init__(self)

>>> d = D()
打印属性 d
打印属性 b
打印属性 a
打印属性 c
打印属性 a
  • 因为 B,C 都继承自 A,所以当 D 在实例化时,A 的构造函数被执行了两次。这就是所谓的重复调用问题。
  • 很显然,我们只需要调用一次就可以了,重复的调用只会造成资源浪费。

接下来我们使用 super() 函数来调用:

>>> class A:
        def __init__(self):
            print("打印属性 a")

>>> class B(A):
        def __init__(self):
            print("打印属性 b")
            super().__init__()                # super() 等同于 super(B, self)

>>> class C(A):
        def __init__(self):
            print("打印属性 c")
            super().__init__()                # super() 等同于 super(C, self)

>>> class D(B, C):
        def __init__(self):
            print("打印属性 d")
            super(D, self).__init__()

>>> d = D()
打印属性 d
打印属性 b
打印属性 c
打印属性 a
  • 查看输出结果我们发现虽然解决了重复调用问题,但是输出结果的顺序好像与我们想的有所区别。我们的惯性思维是:先执行 D 类的 __init__() 方法,接着调用 B 类的 __init__() 方法,B 类的构造方法中又调用了父类 A 的 __init_() 方法,然后再是调用 C 类的 __init_() 方法,该方法也调用了父类 A 的 __init__() 方法。所以执行的结果应该是:打印属性 d,打印属性 b,打印属性 a,打印属性 c。
  • 为何结果不是我们想的那样呢,首先我们要知道 D 类中的第二个参数 self 为 D 的实例 d,它提供的 MRO 为:D→B→C→A→object。所以 D 类中的 super() 函数产生的是 d 的代理对象,当其调用父类 B 的 __init__() 时,B 的 super() 的第二个参数为 D 中的 super object,其所提供的 MRO 依旧为:D→B→C→A→object。也就是说 B 中的 super() 调用的是它的上一级 C 中的 __init__() ,而不是 A 中的 __init__()。所以执行的结果是:打印属性 d,打印属性 b,打印属性 c,打印属性 a。

3.4 super(type) 问题

>>> class A:
	    def funxx(self):
		    print("...A...")

>>> class B(A):
	    def funxx(self):
		    print("...B...")

>>> sa = super(B)
>>> print(sa)
<super: <class 'B'>, NULL>
>>> print(type(sa))
<class 'super'>

可以看出 super(type) 返回的是一个无效的对象,或者是未绑定的 super object。

到此这篇关于Python super( )函数用法总结的文章就介绍到这了,更多相关super( )函数内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

时间: 2021-06-09

Python super()函数使用及多重继承

super()函数可以用于继承父类的方法,语法如下: super(type[, object-or-type]) 虽然super()函数的使用比较简单,但是需要根据单继承和多继承来分析函数的调用关系. 首先,当类之间的继承关系为单继承时,函数调用关系也比较简单,可以参考如下的例子: #!/usr/bin/env python3 class A(object): def __init__(self): print('class A') class B(A): def __init__(self):

解决python super()调用多重继承函数的问题

当类间继承关系很简单时,super()的使用很简单. class A(object): def __init__(self): print('a') class B(A): def __init__(self): super(B, self).__init__() print('b') b = B() 输出结果: a b 当一个类继承多个类时,问题就复杂起来了,请看下例: class A(object): def __init__(self): print('a') class B(object

Python中super函数用法实例分析

本文实例讲述了Python中super函数用法.分享给大家供大家参考,具体如下: 这是个高大上的函数,在python装13手册里面介绍过多使用可显得自己是高手 23333. 但其实他还是很重要的. 简单说, super函数是调用下一个父类(超类)并返回该父类实例的方法. 这里的下一个的概念参考后面的MRO表介绍. help介绍如下: super(type, obj) -> bound super object; requires isinstance(obj, type) super(type)

python super()函数的基本使用

super主要来调用父类方法来显示调用父类,在子类中,一般会定义与父类相同的属性(数据属性,方法),从而来实现子类特有的行为.也就是说,子类会继承父类的所有的属性和方法,子类也可以覆盖父类同名的属性和方法. class Parent(object): Value = "Hi, Parent value" def fun(self): print("This is from Parent") # 定义子类,继承父类 class Child(Parent): Value

Python编程中对super函数的正确理解和用法解析

当在子类需要调用父类的方法时,在python2.2之前,直接用类名调用类的方法,即非绑定的类方法,并把自身对象self作参数传进去. class A(object): def say(self): print 'I am A' class B(A): def say(self): print 'I am B' A.say(self) b = B() b.say() 输出 I am B I am A 这样运作挺好,不过有个问题,当父类改了名字时,就要把这些显式调用父类的一个个更正,子类和父类耦合比

Python中super()函数简介及用法分享

首先看一下super()函数的定义: super([type [,object-or-type]]) Return a **proxy object** that delegates method calls to a **parent or sibling** class of type. 返回一个代理对象, 这个对象负责将方法调用分配给第一个参数的一个父类或者同辈的类去完成. parent or sibling class 如何确定? 第一个参数的__mro__属性决定了搜索的顺序, sup

python中enumerate函数遍历元素用法分析

本文实例讲述了python中enumerate函数遍历元素用法.分享给大家供大家参考,具体如下: enumerate函数用于遍历序列中的元素以及它们的下标 示例代码如下: i = 0 seq = ['one', 'two', 'three'] for element in seq: print i, seq[i] i += 1 #0 one #1 two #2 three print '============' seq = ['one', 'two', 'three'] for i, elem

基于Python中求和函数sum的用法详解

基于Python中求和函数sum的用法详解 今天在看<集体编程智慧>这本书的时候,看到一段Python代码,当时是百思不得其解,总觉得是书中排版出错了,后来去了解了一下sum的用法,看了一些Python大神写的代码后才发现是自己浅薄了!特在此记录一下.书中代码段摘录如下: from math import sqrt def sim_distance(prefs, person1, person2): # 得到shared_items的列表 si = {} for item in prefs[p

python中set()函数简介及实例解析

set函数也是python内置函数的其中一个,属于比较基础的函数.其具体介绍和使用方法,下面进行介绍. set() 函数创建一个无序不重复元素集,可进行关系测试,删除重复数据,还可以计算交集.差集.并集等. set,接收一个list作为参数 list1=[1,2,3,4] s=set(list1) print(s) #逐个遍历 for i in s: print(i) 输出: set([1, 2, 3, 4]) 1 2 3 4 使用add(key)往集合中添加元素,重复的元素自动过滤 list1

python中open函数的基本用法示例

前言 本文主要介绍的是关于python中open函数用法的相关资料,用法如下: name = open('errname.txt','w')<br>name.readline()<br>name.close() 1.看下第一行的代码 用来访问磁盘中存放的文件,可以进行读写等操作,例如上例中 'w',这里便是对errname.txt这个文件进行读操作 例如: w:以写方式打开 a:以追加方式打开 r+:以读写模式打开 w+:以读写模式打开 rb:以二进制读模式打开 wb:以二进制写模

Python中super函数的用法

描述 super() 函数用于调用下一个父类(超类)并返回该父类实例的方法. super 是用来解决多重继承问题的,直接用类名调用父类方法在使用单继承的时候没问题,但是如果使用多继承,会涉及到查找顺序(MRO).重复调用(钻石继承)等种种问题. MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表. 语法 以下是 super() 方法的语法: super(type[, object-or-type]) 参数 type -- 类. object-or-type -- 类,一般是 se

Python中XlsxWriter模块简介与用法分析

本文实例讲述了Python中XlsxWriter模块用法.分享给大家供大家参考,具体如下: XlsxWriter,可以生成excel文件(xlsx的哦),然后很重要的一点就是,它不仅仅只是生成数据,还能插入直方图,饼图-.,使用条件格式,合并单元格等等这些操作.话不多说,先上图,在上例子哈! 以直方图为例子哈 生成文体效果如下 代码解析 # -*- coding: cp936 -*- import xlsxwriter workbook = xlsxwriter.Workbook('chart_

Python中scatter函数参数及用法详解

最近开始学习Python编程,遇到scatter函数,感觉里面的参数不知道什么意思于是查资料,最后总结如下: 1.scatter函数原型 2.其中散点的形状参数marker如下: 3.其中颜色参数c如下: 4.基本的使用方法如下: #导入必要的模块 import numpy as np import matplotlib.pyplot as plt #产生测试数据 x = np.arange(1,10) y = x fig = plt.figure() ax1 = fig.add_subplot

浅述python中argsort()函数的实例用法

由于想使用python用训练好的caffemodel来对很多图片进行批处理分类,学习过程中,碰到了argsort函数,因此去查了相关文献,也自己在python环境下进行了测试,大概了解了其相关的用处,为了怕自己后面又忘了,就写下来权当加深理解了.(ps:我也是python小白,理解可能比较浅显) 1.先定义一个array数据 import numpy as np x=np.array([1,4,3,-1,6,9]) 2.现在我们可以看看argsort()函数的具体功能是什么: x.argsort