欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

super()方法详解

程序员文章站 2022-04-29 17:59:20
[TOC] 单独调用父类的方法 需求:编写一个类,然后再写一个子类进行继承,使用子类去调用父类的方法1。 使用方法1打印: 胖子老板,来包槟榔。 那么先写一个胖子老板的父类,执行一下: 运行一下这个胖子老板父类的构造方法\_\_init\_\_ 如下: FatFather的init开始被调用 Fat ......

目录

单独调用父类的方法

需求:编写一个类,然后再写一个子类进行继承,使用子类去调用父类的方法1。

使用方法1打印: 胖子老板,来包槟榔

那么先写一个胖子老板的父类,执行一下:

class fatfather(object):
    def __init__(self, name):
        print('fatfather的init开始被调用')
        self.name = name
        print('fatfather的name是%s' % self.name)
        print('fatfather的init调用结束')


def main():
    ff = fatfather("胖子老板的父亲")

运行一下这个胖子老板父类的构造方法__init__ 如下:

if __name__ == "__main__":
    main()
fatfather的init开始被调用
fatfather的name是胖子老板的父亲
fatfather的init调用结束

好了,那么下面来写一个子类,也就是胖子老板类,继承上面的类

# 胖子老板的父类
class fatfather(object):
    def __init__(self, name):
        print('fatfather的init开始被调用')
        self.name = name
        print('调用fatfather类的name是%s' % self.name)
        print('fatfather的init调用结束')


# 胖子老板类 继承 fatfather 类
class fatboss(fatfather):
    def __init__(self, name, hobby):
        print('胖子老板的类被调用啦!')
        self.hobby = hobby
        fatfather.__init__(self, name)  # 直接调用父类的构造方法
        print("%s 的爱好是 %s" % (name, self.hobby))


def main():
    #ff = fatfather("胖子老板的父亲")
    fatboss = fatboss("胖子老板", "打斗地主")

在这上面的代码中,我使用fatfather.__init__(self,name)直接调用父类的方法。
运行结果如下:

if __name__ == "__main__":
    main()
胖子老板的类被调用啦!
fatfather的init开始被调用
调用fatfather类的name是胖子老板
fatfather的init调用结束
胖子老板 的爱好是 打斗地主

super() 方法基本概念

除了直接使用 fatfather.__init__(self,name) 的方法,还可以使用super()方法来调用。

那么首先需要看super()方法的描述和语法理解一下super() 方法的使用。

描述

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

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

mro 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。

语法

以下是 super() 方法的语法:

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

参数

  • type -- 类

  • object-or-type -- 类,一般是 self

python3.x 和 python2.x 的一个区别是: python 3 可以使用直接使用 super().xxx 代替 super(class, self).xxx :

  • python3.x 实例:
class a:
    pass
class b(a):
    def add(self, x):
        super().add(x)
  • python2.x 实例:
class a(object):   # python2.x 记得继承 object
    pass
class b(a):
    def add(self, x):
        super(b, self).add(x)

单继承使用super()

  • 使用super() 方法来改写刚才胖子老板继承父类的 __init__ 构造方法
# 胖子老板的父类
class fatfather(object):
    def __init__(self, name):
        print('fatfather的init开始被调用')
        self.name = name
        print('调用fatfather类的name是%s' % self.name)
        print('fatfather的init调用结束')


# 胖子老板类 继承 fatfather 类
class fatboss(fatfather):
    def __init__(self, name, hobby):
        print('胖子老板的类被调用啦!')
        self.hobby = hobby
        #fatfather.__init__(self,name)   # 直接调用父类的构造方法
        super().__init__(name)
        print("%s 的爱好是 %s" % (name, self.hobby))


def main():
    #ff = fatfather("胖子老板的父亲")
    fatboss = fatboss("胖子老板", "打斗地主")

从上面使用super方法的时候,因为是单继承,直接就可以使用了。
运行如下:

if __name__ == "__main__":
    main()
胖子老板的类被调用啦!
fatfather的init开始被调用
调用fatfather类的name是胖子老板
fatfather的init调用结束
胖子老板 的爱好是 打斗地主

那么为什么说单继承直接使用就可以呢?因为super()方法如果多继承的话,会涉及到一个mro(继承父类方法时的顺序表) 的调用排序问题。

下面可以打印一下看看单继承的mro顺序(fatboss.__mro__)。

# 胖子老板的父类
class fatfather(object):
    def __init__(self, name):
        print('fatfather的init开始被调用')
        self.name = name
        print('调用fatfather类的name是%s' % self.name)
        print('fatfather的init调用结束')


# 胖子老板类 继承 fatfather 类
class fatboss(fatfather):
    def __init__(self, name, hobby):
        print('胖子老板的类被调用啦!')
        self.hobby = hobby
        #fatfather.__init__(self,name)   # 直接调用父类的构造方法
        super().__init__(name)
        print("%s 的爱好是 %s" % (name, self.hobby))


def main():

    print("打印fatboss类的mro")
    print(fatboss.__mro__)

    print()
    print("=========== 下面按照 mro 顺序执行super方法 =============")
    fatboss = fatboss("胖子老板", "打斗地主")

上面的代码使用 fatboss.__mro__ 可以打印出 fatboss这个类经过 python解析器的 c3算法计算过后的继承调用顺序。
运行如下:

if __name__ == "__main__":
    main()
打印fatboss类的mro
(<class '__main__.fatboss'>, <class '__main__.fatfather'>, <class 'object'>)

=========== 下面按照 mro 顺序执行super方法 =============
胖子老板的类被调用啦!
fatfather的init开始被调用
调用fatfather类的name是胖子老板
fatfather的init调用结束
胖子老板 的爱好是 打斗地主

从上面的结果 (<class '__main__.fatboss'>, <class '__main__.fatfather'>, <class 'object'>) 可以看出,super() 方法在 fatboss 会直接调用父类是 fatfather ,所以单继承是没问题的。

那么如果多继承的话,会有什么问题呢?

多继承使用super()

假设再写一个胖子老板的女儿类,和 胖子老板的老婆类,此时女儿需要同时继承 两个类(胖子老板类,胖子老板老婆类)。

因为胖子老板有一个爱好,胖子老板的老婆需要干活干家务,那么女儿需要帮忙同时兼顾。

此时女儿就是需要继承使用这两个父类的方法了,那么该如何去写呢?

下面来看看实现代码:

# 胖子老板的父类
class fatfather(object):
    def __init__(self, name, *args, **kwargs):
        print()
        print("=============== 开始调用 fatfather  ========================")
        print('fatfather的init开始被调用')
        self.name = name
        print('调用fatfather类的name是%s' % self.name)
        print('fatfather的init调用结束')
        print()
        print("=============== 结束调用 fatfather  ========================")


# 胖子老板类 继承 fatfather 类
class fatboss(fatfather):
    def __init__(self, name, hobby, *args, **kwargs):
        print()
        print("=============== 开始调用 fatboss  ========================")
        print('胖子老板的类被调用啦!')
        #super().__init__(name)
        ## 因为多继承传递的参数不一致,所以使用不定参数
        super().__init__(name, *args, **kwargs)
        print("%s 的爱好是 %s" % (name, hobby))
        print()
        print("=============== 结束调用 fatboss  ========================")


# 胖子老板的老婆类 继承 fatfather类
class fatbosswife(fatfather):
    def __init__(self, name, housework, *args, **kwargs):
        print()
        print("=============== 开始调用 fatbosswife  ========================")
        print('胖子老板的老婆类被调用啦!要学会干家务')
        #super().__init__(name)
        ## 因为多继承传递的参数不一致,所以使用不定参数
        super().__init__(name, *args, **kwargs)
        print("%s 需要干的家务是 %s" % (name, housework))
        print()
        print("=============== 结束调用 fatbosswife  ========================")


# 胖子老板的女儿类 继承 fatboss fatbosswife类
class fatbossgril(fatboss, fatbosswife):
    def __init__(self, name, hobby, housework):
        print('胖子老板的女儿类被调用啦!要学会干家务,还要会帮胖子老板斗地主')
        super().__init__(name, hobby, housework)


def main():

    print("打印fatbossgril类的mro")
    print(fatbossgril.__mro__)

    print()
    print("=========== 下面按照 mro 顺序执行super方法 =============")
    gril = fatbossgril("胖子老板", "打斗地主", "拖地")

运行结果如下:

if __name__ == "__main__":
    main()
打印fatbossgril类的mro
(<class '__main__.fatbossgril'>, <class '__main__.fatboss'>, <class '__main__.fatbosswife'>, <class '__main__.fatfather'>, <class 'object'>)

=========== 下面按照 mro 顺序执行super方法 =============
胖子老板的女儿类被调用啦!要学会干家务,还要会帮胖子老板斗地主

=============== 开始调用 fatboss  ========================
胖子老板的类被调用啦!

=============== 开始调用 fatbosswife  ========================
胖子老板的老婆类被调用啦!要学会干家务

=============== 开始调用 fatfather  ========================
fatfather的init开始被调用
调用fatfather类的name是胖子老板
fatfather的init调用结束

=============== 结束调用 fatfather  ========================
胖子老板 需要干的家务是 拖地

=============== 结束调用 fatbosswife  ========================
胖子老板 的爱好是 打斗地主

=============== 结束调用 fatboss  ========================

从上面的运行结果来看,我特意给每个类的调用开始以及结束都进行打印标识,可以看到。

每个类开始调用是根据mro顺序进行开始,然后逐个进行结束的。

还有就是由于因为需要继承不同的父类,参数不一定。

所以,所有的父类都应该加上不定参数*args , **kwargs ,不然参数不对应是会报错的。

注意事项

  • super().__init__相对于类名.__init__,在单继承上用法基本无差

  • 但在多继承上有区别,super方法能保证每个父类的方法只会执行一次,而使用类名的方法会导致方法被执行多次,可以尝试写个代码来看输出结果

  • 多继承时,使用super方法,对父类的传参数,应该是由于python中super的算法导致的原因,必须把参数全部传递,否则会报错

  • 单继承时,使用super方法,则不能全部传递,只能传父类方法所需的参数,否则会报错

  • 多继承时,相对于使用类名.__init__方法,要把每个父类全部写一遍, 而使用super方法,只需写一句话便执行了全部父类的方法,这也是为何多继承需要全部传参的一个原因

练习

以下的代码的输出将是什么? 说出你的答案并解释。

class parent(object):
    x = 1


class child1(parent):
    pass


class child2(parent):
    pass


print(parent.x, child1.x, child2.x)
1 1 1
child1.x = 2
print(parent.x, child1.x, child2.x)
1 2 1
  • 注意:child1已经拥有了属于自己的x
parent.x = 3
print(parent.x, child1.x, child2.x)
3 2 3