3-4 Python中的多态

类具有继承关系，并且子类类型可以向上转型看做父类类型，如果我们从 Person 派生出 Student和Teacher ，并都写了一个who() 方法：

class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender
    def who(self):
        return 'I am a Person, my name is %s' % self.name

class Student(Person):
    def __init__(self, name, gender, score):
        super(Student, self).__init__(name, gender)
        self.score = score
    def who(self):
        return 'I am a Student, my name is %s' % self.name

class Teacher(Person):
    def __init__(self, name, gender, course):
        super(Teacher, self).__init__(name, gender)
        self.course = course
    def who(self):
        return 'I am a Teacher, my name is %s' % self.name

接着，我们分别把不同类型的who()函数结果打印出来：

p = Person('Tim', 'Male')
s = Student('Bob', 'Male', 88)
t = Teacher('Alice', 'Female', 'English')

运行结果：

I am a Person, my name is Tim
I am a Student, my name is Bob
I am a Teacher, my name is Alice

这种行为称为多态。从定义上来讲，Student和Teacher都拥有来自父类Person继承的who()方法，以及自己定义的who()方法。但是在实际调用的时候，会首先查找自身的定义，如果自身有定义，则优先使用自己定义的函数；如果没有定义，则顺着继承链向上找。

class Boss(Person):
    def __init__(self, name, gender,company):
        super(Boss, self).__init__(name, gender)
        self.company = company

b = Boss('Bob', 'Male', 'Alibaba')
b.who() # ==> I am a Person, my name is Bob

在Boss的定义类，没有定义who方法，所以会顺着继承链向上找到父类的who方法并且调用。

Python中的多重继承

除了从一个父类继承外，Python允许从多个父类继承，称为多重继承。多重继承和单继承没有特别大的差异，只是在括号内加入多个需要继承的类的名字即可。

class A(object):
    def __init__(self, a):
        print ('init A...')
        self.a = a

class B(A):
    def __init__(self, a):
        super(B, self).__init__(a)
        print ('init B...')

class C(A):
    def __init__(self, a):
        super(C, self).__init__(a)
        print ('init C...')

class D(B, C):
    def __init__(self, a):
        super(D, self).__init__(a)
        print ('init D...')

多重继承的继承链就不是一棵树了，它像这样：

从上图可知，A类被继承了两次，那么A的__init__()方法，是否会被调用两次呢？

​>>> d = D('d')
init A...
init C...
init B...
init D...

实践证明，在多重继承里，A虽然被继承了两次，但是__init__()的方法只调用一次。

多重继承的目的是从两种继承树中分别选择并继承出子类，以便组合功能使用。
举个例子，Python的网络服务器有TCPServer、UDPServer、UnixStreamServer、UnixDatagramServer，而服务器运行模式有 多进程ForkingMixin 和 多线程ThreadingMixin两种。
要创建多进程模式的 TCPServer：

class MyTCPServer(TCPServer, ForkingMixin)
    pass

要创建多线程模式的 UDPServer：

class MyUDPServer(UDPServer, ThreadingMixin):
    pass

如果没有多重继承，要实现上述所有可能的组合需要 4x2=8 个子类。