13518219792
面向对象有3大特性：继承、多态、封装，本章介绍 Python中的 继承特性~
10年积累的网站设计、做网站经验，可以快速应对客户对网站的新想法和需求。提供各种问题对应的解决方案。让选择我们的客户得到更好、更有力的网络服务。我虽然不认识你，你也不认识我。但先网站设计后付款的网站建设流程，更有将乐免费网站建设让你可以放心的选择与我们合作。
继承是创建类的一种方式，在 Python中支持多继承，即在创建类的时候可以继承一个或者多个父类。
在继承关系中，被继承的类通常称为父类（或超类，基类），新建的类则称为子类（或派生类）。
继承的优势在于可以有效地重用代码，提高代码的可读性~
继承示例：
class Fu_1: # 父类
pass
class Fu_2: # 父类
pass
class Zi_1(Fu_1): # 单继承
pass
class Zi_2(Fu_1, Fu_2): # 多继承
pass
上述示例中，Fu_1 和 Fu_2 没有继承任何类，在 Python3 中，这样就会默认继承object类，而在 Python2 中，默认不会继承 object类，注意区分 ~
可通过 类的内置属性 __bases__ 查看这个类 继承的所有父类
print(Zi_1.__bases__)
print(Zi_2.__bases__)
# 输出结果：
(,)
(, ) 在开发过程中，若新建的一个类和已创建的另一个类 属性及方法大致相同，则可以让新建的类（子类）继承已创建的类（父类），这样子类会继承父类的所有属性，包括数据属性和函数属性，实现了代码重用，代码变得简洁，可以有效缩短开发周期~
class Father:
def __init__(self, name, age):
self.name = name
self.age = age
def say(self):
print('Hello !')
class Son(Father):
pass
p = Son('baby', 19)
p.say()
# 输出结果：
Hello !
在继承过程中，子类也可以添加或者重新定义这些属性，当父类和子类中有同名的属性时（包括数据属性和函数属性），会先调用子类中的属性（操作的是子类的实例化对象）
class Father:
city = 'NB'
def __init__(self, name, age):
self.name = name
self.age = age
def say(self):
print('Hello ! ' + self.city)
class Son(Father):
city = 'HZ'
def say(self):
print('你好 ~ ' + self.city)
def eat(self):
pass
p = Son('baby', 19)
p.say()
# 输出结果：
你好 ~ HZ在子类的函数中，若是要重用父类中某个函数的功能，可以直接通过 super 来调用父类中的函数，当然也可以通过 类名.func() 来调用，只不过这样与调用普通函数无异。这个经常使用在需要对父类的同名方法进行扩展的场景~
class Father:
def say(self):
print('Hello !')
def introduce(self):
print('Father')
class Son(Father):
def say(self):
super().say()
# Father.say(self) # 通过 类名.func()，输出结果一致
print('你好 ~')
p = Son()
p.say()
# 输出结果
Hello !
你好 ~上述示例中，使用 super的时候省略了2个参数：Son（当前类名称，注意不是父类），self（当前对象）
super().say()
# 等同于
super(Son, self).say()由于 super 方法中已经默认传递了self参数，所以后面的函数不需要再次传递self~
注意：super关键字只在新式类中有，Python3中所有的类都是新式类...
在子类的函数中使用super方法，不一定仅调用同名的父类函数，也可以调用其他的父类函数~
def say(self):
super().introduce()
print('你好 ~')
如下示例中子类对父类的 init方法 进行了扩展，这是一种较为常用的使用方式~
class Father:
def __init__(self, name, age):
self.name = name
self.age = age
def say(self):
print('Hello !')
class Son(Father):
def __init__(self, name, age, hobby):
super().__init__(name, age)
self.hobby = hobby
def say(self):
super().say()
print('你好 ~')
super方法不光可以在类的内部使用，也可以在类的外部的使用，在类的外部使用时，super方法不可以省略参数
# 外部使用super
p = Son()
super(Son, p).say()
# 输出结果：
Hello !上面已经说过，Python3 中所有的类都是新式类，新建的类没有继承任何类的时候，会默认继承 object 类。
在 Python2中，经典类和新式类并存，新建的类若是没有继承任何类，则这个类为经典类，只有显示地继承了 object 类或其子类，这个类才是新式类~
# Python2中
class C1: # 经典类
pass
class C2(C1): # 经典类
pass
class C3(object): # 新式类
pass
# Python3中
class N1: # 新式类
pass
class N2(N1): # 新式类
pass
class N3(object): # 新式类
pass
在Python中支持多继承，新式类和经典类的继承顺序有所差异，以下以钻石继承为例给出示例：
class A(object):
def fun(self):
print('from A')
class B(A):
def fun(self):
print('from B')
class C(A):
def fun(self):
print('from C')
class D(B):
def fun(self):
print('from D')
class E(C):
def fun(self):
print('from E')
class F(D, E):
# def fun(self):
# print('from F')
pass上述多个类的继承关系如下图所示：
当前环境为Python3，即新式类，可通过内置的__mro__方法查看继承顺序：
f1 = F()
# f1.fun()
print(F.__mro__)
# 输出结果：
(, , , , , , ) 即新式类的继承顺序：F->D->B->E->C->A，广度优先。
那什么是继承顺序呢？就是寻找父类的顺序，例如这里调用 f1对象（F类的实例化对象）的 fun方法，若F类中没有这个方法，就去D类中寻找，若D类中也没有，就去B类中寻找，然后是E类，C类，A类，即按照 MRO列表上 从左到右查找基类~
若这里的类是经典类，则继承顺序为：F->D->B->A->E->C ，深度优先~
广度优先 与 深度优先 的区别在于，广度优先算法在查找基类的时候，若之后能找到的，则之后再进行查找，若之后找不到的，现在就去查找。例如，通过E，C也能再次找到A，则先不找A，但是通过E，C不能再次找到B，所以查找D之后就找B，查找B之后不会去查找A，而是在C之后再去查找A~
再看如下示例，由于B和C只能通过一条途径找到，所以新式类和经典类的继承顺序一致：
新式类继承顺序：F->D->B->E->C
经典类继承顺序：F->D->B->E->C
若是在钻石继承中用到了 super 关键字，super 会去调用父类的对应方法，但是 super 的本质并不是直接找父类，而是根据调用者的节点位置的广度优先顺序来查找的。即 按照广度优先的继承顺序找到上一个类~
Tip：super 关键字只有在新式类中有，所以肯定是按照广度优先的继承顺序来进行查找的~
class A:
def func(self):
print('A')
class B(A):
def func(self):
super().func()
print('B')
class C(A):
def func(self):
super().func()
print('C')
class D(B, C):
def func(self):
super().func()
print('D')
d = D()
d.func()
# 输出结果：
A
C
B
D上述多个类的继承关系如下图所示：
当前使用的是新式类，继承顺序为：D->B->C->A（经典类的继承顺序为：F->B->A->C）
其中super的调用过程如下：
D类的 func() 方法中的 super().func() 会调用 B类的 func() 方法，B类的 func() 方法中的super().func() 会调用 C类的 func() 方法，C类的 func() 方法中的 super().func() 会调用 A类的 func() 方法~
当然在单继承中不会有这样的问题~
.................^_^
