python继承细节

不要子类化内置类型

内置类型（由C语言编写）不会调用用户定义的类覆盖的特殊方法。

例如，子类化dict做为测验：

class DoppeDict(dict):
    def __setitem__(self, key, value):
        super().__setitem__(key, [value]*2)   #改成重复存入的值

dd = DoppeDict(one=1)
print(dd)
dd['two'] = 2
print(dd)
dd.update(three=3)
print(dd)

#结果
{'one': 1}    #没有预期效果，即__init__方法忽略了覆盖的__setitem__方法
{'one': 1, 'two': [2, 2]}     #[]正确调用
{'one': 1, 'three': 3, 'two': [2, 2]}   #update方法忽略了覆盖的__setitem__方法

原生类型这种行为违背了面向对象编程的一个基本原则：始终应该从实例所属的类开始搜索方法，即便在超类实现类的调用也是如此。这种环境中，有个特例，即__miss__方法能按预期工做。

不止实例内部的调用有这个问题，，内置类型的方法调用其余类的方法，若是被覆盖了，也不会被调用。例如：

class AnswerDict(dict):
    def __getitem__(self, item):   #无论传入什么键，始终返回42
        return 42


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

#结果
42       #符号预期
foo      #update忽略了覆盖的__getitem__方法  
{'a': 'foo'}

于是子类化内置类型（dict，list，str）等容易出错，内置类型的方法一般会忽略用户覆盖的方法。

不要子类化内置类型，用户自定义的类应该继承collections模块中的类，例如Userdict，UserList，UserString，这些类作了特殊设计，所以易于扩展：

import collections

class AnswerDict(collections.UserDict):
    def __getitem__(self, item):   #无论传入什么键，始终返回42
        return 42


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

#结果没有问题
42
42
{'a': 42}

多重继承和方法解析顺序

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

定义四个类ABCD:

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

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

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

class D(B, C):

    def ping(self):
        super().ping()
        print('D_ping:', self)

    def pingpong(self):
        self.ping()
        super().ping()
        self.pong()
        super().pong()
        C.pong(self)

实箭头表示继承顺序，虚箭头表示方法解析顺序，如图所示：

在D实例上调用pong方法：

if __name__ == '__main__':
    d = D()
    print(d.pong())
    print(C.pong(d))

#结果
B_pong: <__main__.D object at 0x0000026F4D9F5898>
C_pong: <__main__.D object at 0x0000026F4D9F5898>

按照解析顺序，，直接调用d.pong()运行的是B类中的版本；

超类中的方法均可以调用，只要把实例做为显式参数传入，如上面的C.pong(d)

python能区分d.pong()调用的是哪一个方法，是由于python会按照特定的顺序便利继承图。这个方法叫作方法解析顺序（本例中的解析顺序如虚箭头所示）。类都有一个名为__mro__的属性，它的值是一个元组，按照方法解析顺序列出各个超类，从当前类一直往上，直到object。D类的__mro__:

(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)

D->B->C->A->object

若想把方法调用委托给超类，推荐的方式是使用内置的super()函数。然而有时须要绕过方法解析顺序，直接调用某个超类的方法，例如D.ping方法这样写：

    def ping(self):
        A.ping(self)
        print('D_ping:', self)

这样就调用了A的ping()方法绕过了B。

但仍然推荐使用super()，它更安全也不易过期。super()方法调用时，会遵照方法解析顺序：

if __name__ == '__main__':
    d = D()
    print(d.ping())

#结果，两次调用
#1调用super().ping(),super()函数把ping调用委托给A类(B,C没有ping方法)
#2调用print('D_ping',self)
A_ping: <__main__.D object at 0x000001E1447358D0>
D_ping: <__main__.D object at 0x000001E1447358D0>

pingpong方法的5个调用：

if __name__ == '__main__':
    d = D()
    print(d.pingpong())

#结果
#1调用self.ping
#2调用self.ping内部的super.ping
#3调用super().ping
#4调用self.pong(),根据__mro__，找到B的pong
#5调用super().pong(),根据__mro__，找到B的pong
#6调用C.pong(self)，忽略__mro__，调用C类的pong
A_ping: <__main__.D object at 0x00000204691F6898>
D_ping: <__main__.D object at 0x00000204691F6898>
A_ping: <__main__.D object at 0x00000204691F6898>
B_pong: <__main__.D object at 0x00000204691F6898>
B_pong: <__main__.D object at 0x00000204691F6898>
C_pong: <__main__.D object at 0x00000204691F6898>

方法解析顺序不只考虑继承图，还考虑子类声明中列出的超类的顺序。若是把D类声明为class D(C, B):, 那么__mro__中就是：D->C->B->A->object

分析类时查看__mro__属性能够看到方法解析顺序：

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

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

#Base结尾命名的是抽象基类
import io
io.TextIOWrapper.__mro__
(<class '_io.TextIOWrapper'>, <class '_io._TextIOBase'>, <class '_io._IOBase'>, <class 'object'>)

处理多重继承

一些建议：

1.把接口继承和实现继承区分开

使用多重继承时，必定要明确一开始为何要建立子类。主要缘由可能有：

1）实现接口，建立子类型，实现"是什么"关系

2）继承实现，经过重用避免代码重复

这两条可能同时出现，不过只要可能，必定要明确意图。经过继承重用代码是实现细节，一般能够换用组合和委托模式。而接口继承则是框架的支柱。

2.使用抽象基类显式表示接口

若是类做用是定义接口，应该明确把它定义为抽象基类，建立abc.ABC或其余抽象基类的子类。

3.经过混入重用代码

若是一个类做用是为多个不相关的子类提供方法实现，从而实现重用，但不体现"是什么"关系，应该明确把那个类定义为混入类。混入类不能实例化，具体类不能只继承混入类。混入类应该提供某方面特定行为，只实现少许关系很是紧密的方法。

4.在名称中明确指明混入

在名称中加入Mixin后缀。

5.抽象基类能够做为混入，反过来则不成立

抽象基类能够实现具体方法，所以也能够做为混入使用。不过，抽象基类会定义类型，而混入作不到。此外，抽象基类能够做为其余类的惟一基类，而混入类不行。

抽象基类有个局限而混入类没有：抽象基类中实现的具体方法只能与抽象基类以及其超类中的方法协做。

6.不要子类化多个具体类

具体类能够没有或者最多只有一个具体超类。也就是说，具体类的超类中除了这一个具体超类以外，其他都是抽象基类或者混入。例如，下列代码中，若是Alpha是具体类，那么Beta和Gamma必须是抽象基类或者混入：

class MyConcreteclass(Alpha, Beta, Gamma):
     #更多代码...

7.为用户提供聚合类

类的结构主要继承自混入，自身没有添加结构或者行为，那么这样的类称为聚合类。

8.优先使用对象组合而不是继承

组合和委托可以代替混入，把行为提供给不一样的类，可是不能取代接口继承去定义类型层次结构。

以上来自《流畅的python》