Python的继承是多继承机制，一个子类可以同时有多个直接父类；继承可以得到父类定义的方法，子类就可以复用父类的方法。
一、继承的语法
子类：实现继承的类。
父类（基类、超类）：被继承的类。
子类继承父类是在定义子类时，将多个父类放在子类之后的圆括号内，如果定义类时，未指定这个类的直接父类，则默认继承object类，所以object类是所有类的父类（直接父类或者是间接父类）。
语法格式如下：
class SubClass (SuperClassl , SuperClass2 , ... ):
# 类定义部分
使用例子：
class Animal:
def dog(self):
print ('我有一只狗！他叫%s'%self.dog_name)
class Child:
def son(self):
print ('我有两个儿子！')
# 定义Myself类，继承Animal类和Child类
class Myself(Animal,Child):
def name(self):
print ('我叫小明！')
M = Myself() # 创建Myself对象
M.dog_name = '大黄' # 通过Myself对象添加dog_name类变量
M.dog() # 调用Myself对象的dog()方法,打印 我有一只狗！他叫大黄
M.son() # 调用Myself对象的son()方法,打印 我有两个儿子！
M.name() # 调用Myself对象的name()方法,打印 我叫小明！
在上面的例子中，定义了Animal和Child两个父类，和一个继承Animal类和Child类的Myself类；创建Myself对象后，可以访问Myself对象的dog()方法和son()方法，说明Myself对象也具有dog()方法和son()方法，所以继承可以得到父类定义的方法，通过继承子类就可以复用父类的方法。
二、多继承
子类会通过继承得到所有父类的方法，那么如果多个父类中有相同的方法名，排在前面的父类同名方法会“遮蔽”排在后面的父类同名方法，例：
class Animal:
def name(self):
print ('我有一只狗,他叫大黄!')
class Child:
def name(self):
print ('我有两个儿子！')
class Myself(Animal,Child):
pass
class Yourself(Child,Animal):
pass
M = Myself()
M.name() # 打印 我有一只狗,他叫大黄!
Y = Yourself()
Y.name() # 打印 我有两个儿子！
上面例子中，Myself类继承了Animal类和Child类，当Myself子类对象调用name()方法时，因为Myself子类中没有定义name()方法，Python会先在Animal父类中搜寻name()方法，一旦搜寻到就会停止继续向下搜寻，所以运行的是Animal类中的name()方法；而Yourself子类中由于Child父类排在前面，所以运行的是Child类的name()方法。
三、重写
子类包含与父类同名的方法称为方法重写（方法覆盖），可以说是重写父类方法，也可以说子类覆盖父类方法。
例：
class Animal:
def name(self):
print ('我有一只狗,他叫大黄!')
class Myself(Animal):
# 重写Animal类的name()方法
def name(self):
print ('我没有狗，我只有一只猫，他叫大白！')
M = Myself() # 创建Myself对象
M.name() # 执行Myself对象的name()方法，打印 我没有狗，我只有一只猫，他叫大白！
上面的例子中，运行M.name()时执行的不再是Animal类的fly()方法，而是Myself类的name()方法。
在子类中重写方法之后，如果需要用到父类中被重写的实例方法，可以通过类名调用实例方法来调用父类被重写的方法。
例：
class Animal:
def name(self):
print ('我有一只狗,他叫大黄!')
class Myself(Animal):
# 重写Animal类的name()方法
def name(self):
print ('我还有一只猫，他叫大白！')
def pet(self):
Animal.name(self) # 调用被重写的父类方法name()，使用类名.实例名调用，需要手动传self
self.name() # 执行name()方法，会调用子类重写的name()方法
M = Myself() # 创建Myself对象
M.pet()
'''
打印
我有一只狗,他叫大黄!
我还有一只猫，他叫大白！
'''
四、super函数调用父类构造方法
如果子类有多个直接的父类，那么排在前面的构造方法会遮蔽排在后面的构造方法。
例：
class Animal:
def __init__(self,pet,name):
self.pet = pet
self.name = name
def favourite_animal(self):
print ('我有一只%s,他叫%s!'%(self.pet,self.name))
class Fruit:
def __init__(self,kind):
self.kind = kind
def favourite_fruit(self):
print ('我喜欢的水果是%s!'%self.kind)
class Myself(Animal,Fruit):
pass
M = Myself('狗','大黄') # 创建Myself对象
M.favourite_animal() # 调用Myself对象的favourite_animal()方法，打印 我有一只狗,他叫大黄!
M.favourite_fruit() # 调用Myself对象的favourite_fruit方法，由于未初始化Fruit对象的kind实例变量，报错 AttributeError: 'Myself' object has no attribute 'kind'
上面例子中，Myself子类继承了Animal父类和Fruit父类，由于Animal父类排在Fruit父类前面，所以Animal父类的构造函数遮蔽了Fruit父类的构造函数，运行M.favourite_animal()没有任何问题，当运行M.favourite_fruit()时，由于未初始化Fruit对象的kind实例变量，所以程序会报错。
解决以上问题，Myself应该重写父类的构造方法，子类的构造方法可以调用父类的构造方法，有以下两种方式：
1.使用未绑定方法，即： 父类名.__init__(self，参数1，参数2....)。
2.使用super()函数调用父类构造方法。
先查看一下super()函数的帮助信息，
>>> help(super) Help on class super in module builtins: class super(object) | super() -> same as super(__class__, <first argument>) | super(type) -> unbound super object | super(type, obj) -> bound super object; requires isinstance(obj, type) | super(type, type2) -> bound super object; requires issubclass(type2, type) | Typical use to call a cooperative superclass method: | class C(B): | def meth(self, arg): | super().meth(arg) | This works for class methods too: | class C(B): | @classmethod | def cmeth(cls, arg): | super().cmeth(arg) ...
通过帮助信息，可以看到，当调用父类的实例方法时，会自动绑定第一个参数self；当调用类方法时，会自动绑定第一个参数cls。
接下来修改上面的程序：
class Animal:
def __init__(self,pet,name):
self.pet = pet
self.name = name
def favourite_animal(self):
print ('我有一只%s,他叫%s!'%(self.pet,self.name))
class Fruit:
def __init__(self,kind):
self.kind = kind
def favourite_fruit(self):
print ('我喜欢的水果是%s!'%self.kind)
class Myself(Animal,Fruit):
def __init__(self,pet,name,kind):
Fruit.__init__(self,kind) # 通过未绑定方法调用父类构造方法
super().__init__(pet,name) # 通过super()函数调用父类构造方法
M = Myself('狗','大黄','苹果')
M.favourite_animal() # 打印 我有一只狗,他叫大黄!
M.favourite_fruit() # 打印 我喜欢的水果是苹果!