Python继承的优缺点

推出继承的初衷是让新手顺利使用只有专家才能设计出来的框架！

子类化内置类型的问题

在Python2.2之前，内置类型不能子类化，如list、dict等。

在Python2.2之后，内置类型可以子类化了，但是要注意的是：内置类型（使用C语言编写）不会调用用户定义的类覆盖特殊方法。

至于内置类型的子类覆盖覆盖的方法会不会隐式调用，CPython没有制定官方规则。基本上，内置类型的方法不会调用子类覆盖的方法。

例如，dict的子类覆盖了__getitem__()方法但不会被内置类型的get()方法调用，只能应用在[]运算符 dict[key]形式中。（感觉这也是理所当然）

示例，dict的__init__和__upate__方法会忽略掉子类覆盖的__setitem__方法

class DoubleDict(dict):
    def __setitem__(self, key, value):
        super().__setitem__(key, [value] * 2)


dd = DoubleDict(one=1)
print(dd)

dd['two'] = 2
print(dd)

dd.update(three=3)
print(dd)
打印
{'one': 1}
{'one': 1, 'two': [2, 2]}
{'one': 1, 'two': [2, 2], 'three': 3}

知识点：

字典的init和update方法，都可以使用key=value的形式传入

__setitem__方法，没有影响到init和update方法的功能

super().__setitem__可以委托给超类处理，这里不需要传入self了

原生类型这种行为违背了面向对象编程的一个基本原则：始终应该从实例(self)所属的类开始搜索方法，即使在超类实现的类中调用也是如此。在上面的糟糕的局面中，__missing__方法却能按照预期工作，不过这这是个例。

不过只有实例内部的调用有这个问题，内置类型的方法调用其他类的方法，如果被覆盖了，也不会被调用。

ps：self.get()不会调用self.__getitem__()

示例，dict.update方法会忽略AnswerDict.__getitem__方法

class AnswerDict(dict):
    def __getitem__(self, item):
        return 42


ad = AnswerDict(a=1)
print(ad['a'])

d = {}
d.update(ad)
print(d['a'])

以上可以看到，dict.update方法忽略了AnswerDict.__getitem__()

综上所述：

直接子类化内置类型（list、dict、str等）容易出错，因为内置类型的方法通常会忽略用户覆盖的方法。

不要子类化内置类型，应该继承collection模块中的类，如UserDict、UserList、UserString，这写类都做了特殊设计，因此易于扩展

示例，改为继承UserDict类，上面出现的问题都解决了

import collections


class DoubleDict(collections.UserDict):
    def __setitem__(self, key, value):
        super().__setitem__(key, [value] * 2)


dd = DoubleDict(one=1)
print(dd)

dd['two'] = 2
print(dd)

dd.update(three=3)
print(dd)


class AnswerDict(collections.UserDict):
    def __getitem__(self, item):
        return 42


ad = AnswerDict(a=1)
print(ad['a'])

d = {}
d.update(ad)
print(d['a'])
打印
{'one': [1, 1]}
{'one': [1, 1], 'two': [2, 2]}
{'one': [1, 1], 'two': [2, 2], 'three': [3, 3]}
42
42

多重继承和方法解析顺序-MRO

任何实现多重继承的语言都要处理潜在的命令冲突，这种冲突由不相关的祖先类同名方法引起的，这种冲突称为“菱形问题”

示例，ABCD四个类的继承

class A:
    def ping(self):
        print('ping', self)


class B(A):
    def pong(self):
        print('pong B', self)


class C(A):
    def pong(self):
        print('pong C', self)


class D(B, C):
    def ping(self):
        super().ping()  # supper函通过mro委托给了A类，由A.ping()
        print('post-ping', self)

    def pingpong(self):
        self.ping()  # 调用自己的ping方法
        super().ping()  # 调用超类的ping方法，跳过D类的ping方法，找到A类的ping方法
        self.pong()  # 根据mro顺序，找到B类的pong方法
        super().pong()  # 也根据mro顺序，找到B类的pong方法
        C.pong(self)  # 指定调用C.pong方法，忽略mro顺序，找到C类的pong方法


d = D()
d.pong()

C.pong(d)  # 调用超类中的方法

print(D.__mro__)
打印
pong B <__main__.D object at 0x034461B0>
pong C <__main__.D object at 0x034461B0>
(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)

知识点：

超类中的方法都可以直接调用，此时要把示例作为显式参数传入

Python能区分d.pong调用的哪个方法，是因为Python会按照特定的顺序遍历继承图，这个顺序叫做方法解析顺序（Method Resolution Order）。类都有一个叫做__mro__的属性，他的值是一个元组，按照方法解析顺序列出各个超类，从当前类一直向上，知道object类。比如这里就是D→B→C→A→object。方法继承顺序不仅考虑继承图，还要考虑子类声明中超类的顺序，也就是说改成Class D(C, B)，那么D类的__mro__属性就不一样了，变为先搜索C，在搜索B。

想把方法调用委托给超类，推荐的方式是使用supper(）函数。

如果想要绕过方法解析顺序，直接调用超类的方法，可以这样实现

def ping(self):

A.ping(self) # 而不是supper().ping()

print('post-ping', self)

注意，这样直接在类上调用实例方法时，比需显式的传入self，因为这样访问的是未绑定方法（unbound method）

然而，如果不是特殊需要，还是使用supper()最安全。

示例，查看一些类的__mro__属性

>>> bool.__mro__

(<class 'bool'>, <class 'int'>, <class 'object'>)

验证了bool是int的子类

>>> import numbers

>>> numbers.Integral.__mro__

(<class 'numbers.Integral'>, <class 'numbers.Rational'>, <class 'numbers.Real'>, <class 'numbers.Complex'>, <class 'numbers.Number'>, <class 'object'>)

验证了numbers模块的“数字塔”

>>> import io

>>> io.BytesIO.__mro__

(<class '_io.BytesIO'>, <class '_io._BufferedIOBase'>, <class '_io._IOBase'>, <class 'object'>)

io模块中有抽象基类（以Base后缀结尾的是抽象基类）和具体类，

方法解析顺序使用C3算法。 C3算法不用了解，对于开发者来说。

多重继承的真实应用--Tkinter

在Python标准库中，最常使用的多重继承的是collection.abc包。这没什么问题，毕竟连Java都支持接口的多重继承，而抽象基类就是接口说明，只不过是他可以提供具体方法的实现。

ps： Java8也允许提供方法实现，这个新功能在Java中叫默认方法

标准库中，GUI工具包Tkinter把多重继承用到了极致。

下面是Tkinter GUI类层次接口的UML图，使用<<mixin>>标记的类通过多重继承为其他类提供服务。 mixin（混合类型）

Toplevel：表示Tkinter应用程序中顶层窗口的类。

Widget：窗口中所有可见对象的超类。

Button：普通的按钮小组件。

Entry：单行可编辑文本字段。

Text：多行可编辑文本字段。

>>> import tkinter

>>> tkinter.Toplevel.__mro__

(<class 'tkinter.Toplevel'>, <class 'tkinter.BaseWidget'>, <class 'tkinter.Misc'>, <class 'tkinter.Wm'>, <class 'object'>)

>>> tkinter.Text.__mro__

(<class 'tkinter.Text'>, <class 'tkinter.Widget'>, <class 'tkinter.BaseWidget'>, <class 'tkinter.Misc'>, <class 'tkinter.Pack'>, <class 'tkinter.Place'>, <class 'tkinter.Grid'>, <class 'tkinter.XView'>, <class 'tkinter.YView'>, <class 'object'>)

>>>