面向对象思想有三大要素：
面向对象编程（OOP）语言的一个重要功能就是 “继承”：
举个例子，我们现在像创建猪、狗和猫三个类，它们都有名字和年龄属性，也都有一个叫的方法。不同的是，猪有吃的方法、狗有看家的方法、猫有抓老鼠的方法。按照之前的学习，我们会将代码写成这样：
class Pig:
def __init__(self, name, age):
self.name = name
self.age = age
def bark(self):
print('叫')
def eat(self):
print('吃')
class Dog:
def __init__(self, name, age):
self.name = name
self.age = age
def bark(self):
print('叫')
def guarding(self):
print('看家')
class Cat:
def __init__(self, name, age):
self.name = name
self.age = age
def bark(self):
print('叫')
def catch(self):
print('抓老鼠')
我们发现，虽然实现了需求，但是我们看到，这里面出现了大量的重复代码。如果我们能将这些重复代码封装起来，比如封装到一个动物类中，然后猪、狗和猫分别都继承这个动物类，就可以让代码更加简洁。
具体的实现方法为：
class Animal:
def __init__(self, name, age):
self.name = name
self.age = age
def bark(self):
print('叫')
class Pig(Animal):
def eat(self):
print('吃')
class Dog(Animal):
def guarding(self):
print('看家')
class Cat(Animal):
def catch(self):
print('抓老鼠')
mimi = Cat('咪咪', 3)
print(mimi.name, mimi.age)
mimi.bark()
mimi.catch()
输出的结果为：
咪咪 3
叫
抓老鼠
实现继承之后，子类将继承父类的属性和方法。
不难看出，继承关系的特点为：
组合与继承的对比：
Python 3 中使用的都是新式类，如果一个类谁都不继承，那么它默认继承 object 类。
继承虽然很好用，但是不能滥用，像之前说的，耦合程度不宜过高，否则逻辑会十分混乱：
回到我们刚才的例子，猪、狗、猫三各类都只有动物一个父类，这种只有一个父类的继承方式，我们称作为单继承。在单继承中，子类可以继承父类的属性和方法，修改父类，所有子类都会受到影响。
isinstance：
issubclass：
Python 与其他编程语言不同，当我们定义一个 class 的时候，我们实际上就定义了一个数据类型。我们定义的数据类型和 Python 自带的数据类型，比如 str、list、dict 没什么两样：
print(isinstance(10, int))
输出的结果为： True
如果父类中的方法在子类中不适用，我们可以对其进行重写：
class Animal:
def __init__(self, name, age):
self.name = name
self.age = age
def bark(self):
print('叫')
class Dog(Animal):
def bark(self): # 重写叫的方法
print('汪汪汪！')
def guarding(self):
print('看家')
wangwang = Dog('汪汪', 3)
print(wangwang.name)
wangwang.bark()
输出的结果为：
汪汪
汪汪汪！
重写父类方法的原理是，当示例调用方法时，会先在自己的类方法中查找，如果找不到，才会去父类中查找是否有相应的方法。如果在自己的类方法中找到了需要的方法，就不会去父类中查找，也就调用不到父类的同名方法，从而实现对父类中方法的重写
但是有些时候，我们不得已会写一些重名的方法，比如父类和子类都会有 __init__ 构造方法。但是我们在调用子类方法的同时，也希望调用到父类中相应的方法。我们可以通过父类的类名直接调用：
class Father:
eye_num = 2
def __init__(self, name, age):
self.name = name
self.age = age
def live_like_yemen(self):
print('打儿子')
class Son(Father):
hAIr_color = '蓝色'
def __init__(self, name, age, sex):
Father.__init__(self, name, age)
self.sex = sex
def live_like_yemen(self):
print('打弟弟')
xiaoming = Son('小明', 16, '男')
xiaoming.live_like_yemen()
print(xiaoming.name)
输出的结果为：
打弟弟
小明
需要注意的是，在类中，self 永远指的是调用类的实例化对象。
在上面的例子中，如果没有 Father.__init__(self, name, age) 这行代码，在子类中就无法调用父类的构造方法，因为子类已经重写了构造方法。上面的方法虽然实现了预期的功能，但是并不符合开发规范。
从子类中，调用父类中方法的关键字是 super，上述例子可修改为：
class Father:
eye_num = 2
def __init__(self, name, age):
self.name = name
self.age = age
def live_like_yemen(self):
print('打儿子')
class Son(Father):
hair_color = '蓝色'
def __init__(self, name, age, sex):
super().__init__(name, age) # 也可以写为super(Son, self).__init__(name, age)
self.sex = sex
def live_like_yemen(self):
print('打弟弟')
xiaoming = Son('小明', 16, '男')
xiaoming.live_like_yemen()
print(xiaoming.name)
super 方法：
父类方法重写：
多重继承和多继承
多重继承：包含多个间接父类
class A(object): pass
class B(A): pass
class C(B): pass
多继承：有多个直接父类
class X(object): pass
class Y(object): pass
class Z(object): pass
class M(X, Y, Z): pass
大部分面向对象的编程语言（除了 C++）都只支持单继承，而不支持多继承
Python 虽然在语法上明确支持多继承，但通常推荐如果不是很有必要，尽量不要使用多继承，而是使用单继承
如果多个直接父类中包含了同名的方法
class A:
def method(self):
print('A_method')
class B:
def method(self):
print('B_method')
class C(A, B):
pass
c = C()
c.method()
输出的结果为：
A_method
我们刚刚谈到，即便不使用 super 方法，直接使用父类的类名，同样可以实现对父类方法的调用。那为什么更推荐使用 super 方法呢？
这是因为当涉及到比较复杂得多继承关系，比如钻石继承关系时，会出现间接父类会被初始化多次的情况。
比如，我们来看下面这个钻石继承的例子，如果我们使用父类的类名调用构造方法：
class YeYe:
def __init__(self):
print('初始化爷爷类')
class QinBa(YeYe):
def __init__(self):
print('进入化亲爸类')
YeYe.__init__(self)
print('初始化亲爸类')
class GanDie(YeYe):
def __init__(self):
print('进入化干爹类')
YeYe.__init__(self)
print('初始化干爹类')
class ErZi(QinBa, GanDie):
def __init__(self):
print('进入化儿子类')
QinBa.__init__(self)
GanDie.__init__(self)
print('初始化儿子类')
erzi = ErZi()
我们看到，程序运行后，爷爷类被初始化了两次。
这是因为，当创建儿子对象时，会执行它的构造函数。首先打印的是儿子类中初始化方法的代码，然后执行秦霸的构造方法。在亲爸的构造方法中，也是先打印代码，然后执行爷爷的构造方法。执行完爷爷的构造方法之后，程序继续执行亲爸中剩余的代码，然后回到儿子类中，执行干爹的构造方法。在干爹的构造方法中，又要调用爷爷的构造方法。然后打印剩余代码，直至结束。
我们看到，第五步和第十步都是要调用爷爷的构造方法，爷爷类被初始化了两次。这种情况一来没有必要，会占用很大空间，二来，多次初始化也会带来程序逻辑的混乱。
如果我们改用 super 函数来进行这样的操作，就不会有这些麻烦：
class YeYe:
def __init__(self):
print('初始化爷爷类')
class QinBa(YeYe):
def __init__(self):
print('进入亲爸类')
super().__init__()
print('初始化亲爸类')
class GanDie(YeYe):
def __init__(self):
print('进入干爹类')
super().__init__()
print('初始化干爹类')
class ErZi(QinBa, GanDie):
def __init__(self):
print('进入儿子类')
super().__init__()
print('初始化儿子类')
erzi = ErZi()
首先，我们发现，在儿子类中，我们只用一行代码指代调用两个直接父类的构造方法。然后，从结果上看，此时，爷爷类只被初始化一次。
而且我们发现，代码的运行情况与多个装饰器装饰一个函数的情况很类似，子类的代码包含着父类的代码，一层套一层的形式。
查看 mro 的方法有两种：
类名.mro()
对象名.__class__.mro()
前面例子中的 mro 为：
[<class '__main__.ErZi'>, <class '__main__.QinBa'>, <class '__main__.GanDie'>, <class '__main__.YeYe'>, <class 'object'>]
我们说过，super 后面什么都不写，默认和 super(当前类名, self) 的写法一样。但事实上，super 的参数除了可以写当前类名外，还可以写它的父类 [^3] 的类名。此时，会执行在方法解析顺序列表中，该类下一个类的方法。
补充了这些知识，我们就可以解释上面的程序运行的顺序了。
super 关键字详解：
super 内核的 mro 方法：返回的是一个类的方法解析顺序表（顺序结构）
类名.mro()
对象名.__class__.mro()
事实上，super 和父类没有实质性的关联，我们也不一定非要把 super 后面的参数写成自己类的名字和 self。我们甚至可以很灵活地给 super 传参数
super(cls, obj) 获得的是 cls 在 obj 的 MRO 列表中的下一个类，cls 可以是任何一个类，obj 可以是任何一个对象，只要合理即可
class class ErZi(Qinba,GanDie):
def __init__(self):
super(ErZi, self).__init__()
print('初始化儿子')
在前面我们定义儿子类的时候，如果我们不想调用亲爸的 __init__()，而是要调用干爹的 __init__()，只需把 super 写成 super(Qinba, self).__init__()，也就是这样：
class YeYe:
def __init__(self):
print('初始化爷爷类')
class QinBa(YeYe):
def __init__(self):
print('进入亲爸类')
super().__init__()
print('初始化亲爸类')
class GanDie(YeYe):
def __init__(self):
print('进入干爹类')
super().__init__()
print('初始化干爹类')
class ErZi(QinBa, GanDie):
def __init__(self):
print('进入儿子类')
super(QinBa, self).__init__()
print('初始化儿子类')
erzi = ErZi()
其执行顺序为：
[^2]: Method Resolution Order
[^3]: 包括直接父类和间接父类
京公网安备 11010802035086号