Python 面向对象 之 多继承 MRO

Python 面向对象 之 多继承 MRO

回顾 - 类继承

关于子类的继承. 即子类可以继承父类的所有 方法及属性, 当子类要添加新功能或修改父类方法是, 可以在 子类对私进行 重写 overwrite . 大概回顾就行了, 这里也不想进行对过于基础性的问题进行探讨.

class A:
    def __init__(self):
        self.a = 10
        self.b = 20

    @staticmethod
    def say_hello():
        print("hello, world!")

在子类初始化的时候, 是需要手动调用父类的初始化方法来说明的, 语法为: 父类名.__ init__(self, ...)

class B(A):
    def __init__(self, c, d):
        """重写父类__init__, 并新增d, e属性"""
        self.c = c
        self.d = d
        A.__init__(self)

if __name__ == '__main__':
    b = B(4, 5)
    print(b.a)
    print(b.d)

    # output
    10
    5

当然也可以这用 super 关键字

class B(A):
    def __init__(self, c, d):
        """重写父类__init__, 并新增d, e属性"""
        self.c = c
        self.d = d
        super().__init__()

多继承 - Bug

这里主要演示一个, 多继承会出现的问题, 其实也不算bug吧, 原理我也没有仔细去推敲过哈, 先露出来看看吧.

class 父亲:
    def __init__(self, name):
        self.name = name
        print("i am you father...")

class 长子(父亲):
    def __init__(self, name, age):
        self.age = age
        父亲.__init__(self, name)
        print(" i am eldest son")

class 次子(父亲):
    def __init__(self, name, gender):
        self.gender = gender
        父亲.__init__(self, name)
        print("i am the little son")

class 长孙(长子, 次子):
    """收养的哦"""
    def __init__(self, name, age, gender):
        长子.__init__(self, name, age)
        次子.__init__(self, name, gender)
        print("i am the sweet heart")

if __name__ == '__main__':

    king = 长孙("小王子", 23, "F")

i am you father...
i am eldest son

i am you father...  # 多执行了一次 ???

i am the little son
i am the sweet heart

卧槽. ....父类被执行了2次, 这感觉是浪费内存了呀, 嗯..有些紧张....

为啥会出现调用2次父类呢? 或者 如何只让调用一次就好呢 ? 分析一波上面这一段代码

长子.__init__(self, name, age) --> class 长子(父亲) --> class 父亲 -> print("father...")
次子.__init__(self, name, gender) --> class 次子(父亲) --> class 父亲 -> print("father...")

因此, 被调用了2次是没有问题的, 但这就带来一个新的优化问题: 浪费内存, 因为重复开辟空间了呀.

更一般地描述, 即在多继承的情况下, 父类的属性可能会出现被多次执行的情况, 这里仅仅是一个简单的case, 如果非常复杂的结果, 则会浪费非常多的内存和反复调用.

多继承 MRO

MRO - 引入

MRO 是 Pyhton 用来解决上面的这种, 会产生重复开辟空间的问题. 解决的办法是将 复杂结构上的所有类 全部映射到一个线性顺序上 (线性表), 这个顺序就是 MRO 顺序.

MRO表, 事先就调用好了, 按表的顺序调用, 从右到左

print(长孙.__mro__)

# output

(<class '__main__.长孙'>, <class '__main__.长子'>, <class '__main__.次子'>, <class '__main__.父亲'>, <class 'object'>)

这个线性表, 我从执行的角度来看, 就是个 栈, 父类在栈底, 小王子在栈顶 (Top) , 而搜索的顺序, 兄弟们, 定睛一看, 这一层, 一层第搜索,.... 感觉这就是 树的广度优先算法 呀.

MRO - super

官方已经把这个问题给解决了, 方式就是内置方法 super()

super() 方法在 Python 2 中是不一样的哦, Python3 更简洁, 直接拿父类的部件

super() - 多继承

class 父亲:
    def __init__(self, name):
        self.name = name
        print("i am you father...")

# tips: 避免少接收参数, 则可都用上 *args, **kwargs 呀
class 长子(父亲):
    def __init__(self, name, age, *args): # *args 接收 gender的.
        self.age = age
        super().__init__(name, *args)
        print(" i am eldest son")

class 次子(父亲):
    def __init__(self, name, gender):
        self.gender = gender
        super().__init__(name)
        print("i am the little son")

class 长孙(长子, 次子):
    """收养的哦"""

    def __init__(self, name, age, gender):
        super().__init__(name,  age, gender)
        print("i am the sweet heart")

if __name__ == '__main__':
    king = 长孙("小王子", 23, "F")
    print(长孙.__mro__)

i am you father...
i am the little son
i am eldest son
i am the sweet heart

(<class '__main__.长孙'>, <class '__main__.长子'>, <class '__main__.次子'>, <class '__main__.父亲'>, <class 'object'>)

小结

• 多继承会产生重复调用的问题, 浪费内存空间
• MRO顺序是Python将类映射到一个线性表中来调用, 有序的, 能避免重复调用, 搜索算法目测是广度优先
• super 的理解和用法, 注意的点是传参的数量问题, 不明白, 可以都为通用形式 (* args, **kwargs)

还是稍微细节一波关于super(), 在单继承中, super().xxx 和 父类名. ... 二者是一样的效果, 但是在 多继承中, super() 使得父类方法只会执行一次, 传统的方法呢, 就出现了上面的那种 "钻石调用问题". 在使用 super()时候, 必须将参数全部传递, tips, 后面加上 * args * *kwargs.

从最初的例子看, 在单继承的时候呢, super()方法只能传递父类方法所需的参数, 似乎又不能 *args ** kwargs , 总是感觉这些设计, 搞得怪怪的, 都要 debug很久.多继承中呢, 一般用的比较多的是 **重写或继承 __ init__() **, 此处呢, super() 的优势 就显现出来了, 只要一行代码就可以将父类的都执行了, 嗯, 可能, 这就是 super() 要求传递所有参数的原因了吧.

至于用类的方式, 还是用 super(), 我感觉, 我平时写的脚本, 基本都用不到继承哈哈, 真是有点尴尬, 感觉满身的技能, 却总是让我干一些, 打杂的活...知己难寻呀, 才无聊到写博客, 抄博客, 抄段子, 抄代码....