Python学习笔记2 内置函数super()(20.08.06)

本文链接：https://blog.csdn.net/qq_45363979/article/details/107833501

这里写目录标题

- Python super() 函数

Python super() 函数

1. 描述

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

2. python2与python3的区别

python2与python3的区别：
（1）继承类的区别
（2）Python 3 可以使用直接使用 super().xxx 代替 super(Class, self).xxx :

# Python 2
class A(object):
    pass
    
class B(A):
    def add(self, x):
        super(B, self).add(x)

# Python 3
class A:
    pass
    
class B(A):
    def add(self, x):
        super().add(x)

3. 语法和参数

super() 方法的语法:

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

其中参数
type – 类。
object-or-type – 类，一般是 self

4. 单类继承

在单继承中 super ，主要是用来调用父类的方法的。
实例

class A:
    def __init__(self):
        self.n = 2

    def add(self, m):
        print('self is {0} @A.add'.format(self))
        self.n += m


class B(A):
    def __init__(self):
        self.n = 3

    def add(self, m):
        print('self is {0} @B.add'.format(self))
        super().add(m)
        self.n += 3
b = B()
b.add(2)
print(b.n)

结果

self is <main.B object at 0x106c49b38> @B.add
self is <main.B object at 0x106c49b38> @A.add
8

从上面的结果，我们可以总结以下两点：
（1） super().add(m) 确实调用了父类 A 的add方法。
（2）super().add(m) 调用父类方法 def add(self, m) 时, 此时父类中 self 并不是父类的实例而是子类的实例, 所以 super().add(m) 之后 self.n 的结果是5而不是4 。

5. 多继承

分析
当我们调用 super()的时候，实际上是实例化了一个super 类。
在大多数情况下， supe 包含了两个非常重要的信息: 一个 MRO(Method Resolution Order) 列表以及MRO 中的一个类。当以如下方式调用 super 时:

super(a_type, obj)

MRO 列表指的是 type(obj) 的 MRO 列表, MRO 中的那个类就是 a_type , 同时 isinstance(obj, a_type) == True 。
super() 所做的事情，简单来说就是：提供一个 MRO 列表以及一个 MRO 中的类 C ， super() 将返回一个从 MRO 列表中 C 之后的类中查找方法的对象。
举个列子
MRO列表如下：

[A, B, C, D, E, object] # python3 中默认继承object类，该类中有很多方法，目前水平用不到。

下面调用：

super(C, A).foo()

super 只会从 C之后查找，即: 只会在 D或 E或 object 中查找 foo方法。

实例

class A:
    def __init__(self):
        self.n = 2

    def add(self, m):
        # 第四步
        # 来自 D.add 中的 super
        # self == d, self.n == d.n == 5
        print('self is {0} @A.add'.format(self))
        self.n += m
        # d.n == 7


class B(A):
    def __init__(self):
        self.n = 3

    def add(self, m):
        # 第二步
        # 来自 D.add 中的 super
        # self == d, self.n == d.n == 5
        print('self is {0} @B.add'.format(self))
        # 等价于 suepr(B, self).add(m)
        # self 的 MRO 是 [D, B, C, A, object]
        # 从 B 之后的 [C, A, object] 中查找 add 方法
        super().add(m)

        # 第六步
        # d.n = 11
        self.n += 3
        # d.n = 14

class C(A):
    def __init__(self):
        self.n = 4

    def add(self, m):
        # 第三步
        # 来自 B.add 中的 super
        # self == d, self.n == d.n == 5
        print('self is {0} @C.add'.format(self))
        # 等价于 suepr(C, self).add(m)
        # self 的 MRO 是 [D, B, C, A, object]
        # 从 C 之后的 [A, object] 中查找 add 方法
        super().add(m)

        # 第五步
        # d.n = 7
        self.n += 4
        # d.n = 11


class D(B, C):
    def __init__(self):
        self.n = 5

    def add(self, m):
        # 第一步
        print('self is {0} @D.add'.format(self))
        # 等价于 super(D, self).add(m)
        # self 的 MRO 是 [D, B, C, A, object]
        # 从 D 之后的 [B, C, A, object] 中查找 add 方法
        super().add(m)

        # 第七步
        # d.n = 14
        self.n += 5
        # self.n = 19

d = D()
print(D.mro())
print(d.n)
d.add(2)
print(d.n)

结果

5
[<class ‘main.D’>, <class ‘main.B’>, <class ‘main.C’>, <class ‘main.A’>, <class ‘object’>]
self is <main.D object at 0x000002881B06AC08> @D.add
self is <main.D object at 0x000002881B06AC08> @B.add
self is <main.D object at 0x000002881B06AC08> @C.add
self is <main.D object at 0x000002881B06AC08> @A.add
19

分析：
(1)D的 MRO 是:[D, B, C, A, object] 。备注: 可以通过 D.mro()(Python 2 使用 D.__mro__ ) 来查看 D的 MRO 信息）
(2)

在这里插入图片描述

实例

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
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')

（a）super().bar会得到一个对象来访问父类的属性，严格按照继承关系
（b）super(FooChild,self).__init__()这种__init__的方法，是直接把父类的__init__构造方法拿过来直接用，并且可以对属性将进行赋值，添加新的属性。并且，在python3中super(FooChild,self).__init__()可写成super().__init__()
（c）原本的话子类中的__init__方法会覆盖掉父类的__init__方法, 导致无法通过实例化子类的类对象去给父类的类对象添加成员属性/方法,也无法调用父类类对象的属性/方法。若把子类中的__init__注释掉，则可以访问父类中__init__，也就是说父类和子类中的__init__只能用一个。所以对于__init__方法，应该是子类先继承，在修改或添加。