6.2 继承
- 继承就是一个类能够取得另外一个类中的成员属性和成员办法
- 作用： 缩小代码，减少代码的复用性能，同时能够设置类与类间接的关系
继承与被继承的概念：
- 被继承的类叫父类，也叫基类，也叫超类
- 用与继承的类，叫子类，也叫派生类
- 继承与被继承肯定存在一个 is-a 关系
继承的特色
- 所有的类都继承自object类，即所有的类都是object类的子类
- 子类一旦继承父类，则能够应用父类中除公有成员外的所有内容
- 子类继承父类后并没有将父类成员齐全赋值到子类中，而是通过援用关系拜访调用
- 子类中能够定义独有的成员属性和办法
- 子类中定义的成员和父类成员如果雷同，则优先应用子类成员
- 子类如果想裁减父类的办法，能够在定义新办法的同时拜访父类成员来进行代码重用
能够应用 [父类名.父类成员] 的格局来调用父类成员，也能够应用[super().父类成员]的
格局来调用继承变量函数的查找程序问题
- 优先查找本人的变量
- 没有则查找父类
- 构造函数如果本类中没有定义，则主动查找调用父类构造函数
- 如果本类有定义，则不再持续向上查找
构造函数
- 是一类非凡的函数，在类进行实例化之前进行调用
- 如果定义了构造函数，则实例化时应用构造函数，不查找父类构造函数
- 如果没定义，则主动查找父类构造函数
- 如果子类没定义，父类的构造函数带参数，则结构对象时的参数应该按父类参数结构
super
- super不是关键字，而是一个类
- super的作用是获取MRO（MethodResolutionOrder）列表中的第一个类
- super与父类间接没任何实质性关系，但通过super能够调用到父类
- super应用两个办法，常见在构造函数中调用父类的构造函数
单继承和多继承
- 单继承：每个类只能继承一个类
- 多继承：每个类容许继承多个类
单继承和多继承的优缺点
单继承：
- 传承有序逻辑清晰语法简略隐患少
- 性能不能有限扩大，只能在以后惟一的继承链中扩大
多继承：
- 长处：类的性能扩大不便
- 毛病：继承关系凌乱
菱形继承/钻石继承问题
- 多个子类继承自同一个父类，这些子类又被同一个类继承，
于是继承关系图造成一个菱形图谱
- MRO
对于多继承的MRO
- MRO就是多继承中，用于保留继承程序的一个列表
- python自身采纳C3算法来多继承的菱形继承来进行计算的后果
MRO列表的计算准则：
- 子类永远在父类后面
- 如果多个父类，则依据继承语法中括号内类的书写程序寄存
- 如果多个类继承了同一个父类，孙子类中只会选取继承语法
括号中第一个父类的父类
构造函数
- 在对象进行实例化的时候，零碎主动调用的一个函数叫构造函数，通常此函数
用来对实例化对象进行初始化，顾名
- 构造函数肯定要有，如果没有，则主动向上查找，依照MRO程序，直到找到为止
# 继承的语法# 在python中，任何类都有一个独特的父类叫objectclass Person(): name = "NoName" age = 18 __score = 0 # 考试成绩是机密，只有本人晓得 _petname = "sec" # 小名，是爱护的，子类能够用，但不能专用 def sleep(self): print("Sleeping ... ...")# 父类写在括号里class Teacher(Person): teacher_id = "9527" def make_test(self): print("attention")t = Teacher()print(t.name)print(t._petname)# 公有拜访问题# 公开拜访公有变量，报错# print(t.__score)t.sleep()print(t.teacher_id)t.make_test()NoNamesecSleeping ... ...9527attention# 子类和父类定义同一个名称变量，则优先应用子类自身class Person(): name = "NoName" age = 18 __score = 0 # 考试成绩是机密，只有本人晓得 _petname = "sec" # 小名，是爱护的，子类能够用，但不能专用 def sleep(self): print("Sleeping ... ...")# 父类写在括号里class Teacher(Person): teacher_id = "9527" name = "DaNa" def make_test(self): print("attention") t = Teacherprint(t.name)DaNa# 子类裁减父类性能# 人有工作的函数，老师也有工作的函数，但老师的工作须要讲课class Person(): name = "NoName" age = 18 __score = 0 # 考试成绩是机密，只有本人晓得 _petname = "sec" # 小名，是爱护的，子类能够用，但不能专用 def sleep(self): print("Sleeping ... ...") def work(self): print("make some money")# 父类写在括号里class Teacher(Person): teacher_id = "9527" name = "DaNa" def make_test(self): print("attention") def work(self): # 裁减父类的性能只须要调用父类雷同的函数 # Person.work(self) # 裁减父类的另一种办法 # super代表失去父类 super().work() self.make_test() t = Teacher()t.work()make some moneyattention# 构造函数的概念class Dog(): # __init__就是构造函数 # 每次实例化的时候，第一个被主动的调用 # 因为次要工作是进行初始化，所以得名 def __init__(self): print("I am init in dog")# 实例化的时候，括号内的参数须要跟结构函数参数匹配kaka = Dog()I am init in dog# 继承中的构造函数 - 1class Animel(): passclass PaxingAni(Animel): passclass Dog(PaxingAni): # __init__就是构造函数 # 每次实例化的时候，第一个被主动的调用 # 因为次要工作是进行初始化，所以得名 def __init__(self): print("I am init in dog")# 实例化的时候，主动调用了Dog的构造函数 kaka = Dog()I am init in dog# 继承中的构造函数 - 2class Animel(): def __init__(self): print("Animel")class PaxingAni(Animel): def __init__(self): print("Paxing Dongwu")class Dog(PaxingAni): # __init__就是构造函数 # 每次实例化的时候，第一个被主动的调用 # 因为次要工作是进行初始化，所以得名 def __init__(self): print("I am init in dog")# 实例化的时候，主动调用了Dog的构造函数 # 因为找到了构造函数，则不再查找父类的构造函数kaka = Dog()# 猫没有写构造函数class Cat(PaxingAni): pass# 此时应该主动调用构造函数，因为Cat没有构造函数，所以查找父类构造函数# 在PaxingAni中查找到了构造函数，则进行向上查找c = Cat()I am init in dogPaxing Dongwu# 继承中的构造函数 - 3class Animel(): def __init__(self): print("Animel")class PaxingAni(Animel): def __init__(self, name): print("Paxing Dongwu {0}".format(name))class Dog(PaxingAni): # __init__就是构造函数 # 每次实例化的时候，第一个被主动的调用 # 因为次要工作是进行初始化，所以得名 def __init__(self): print("I am init in dog")# 实例化Dog时，查找到Dog的构造函数，参数匹配，不报错 d = Dog()class Cat(PaxingAni): pass# 此时，因为Cat没有构造函数，则向上查找# 因为PaxingAni的构造函数须要两个参数，实例化的时候给了一个，报错c = Cat()I am init in dog---------------------------------------------------------------------------TypeError Traceback (most recent call last)<ipython-input-29-35e195f59e34> in <module> 22 # 此时，因为Cat没有构造函数，则向上查找 23 # 因为PaxingAni的构造函数须要两个参数，实例化的时候给了一个，报错---> 24 c = Cat()TypeError: __init__() missing 1 required positional argument: 'name'# 继承中的构造函数 - 4class Animel(): def __init__(self): print("Animel")class PaxingAni(Animel): passclass Dog(PaxingAni): pass# 实例化Dog时，查找到Dog的构造函数，参数匹配，不报错 d = Dog()class Cat(PaxingAni): pass# 此时，因为Cat没有构造函数，则向上查找# 因为PaxingAni的构造函数须要两个参数，实例化的时候给了一个，报错c = Cat()AnimelAnimelprint(type(super))help(super)<class 'type'>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) | | Methods defined here: | | __get__(self, instance, owner, /) | Return an attribute of instance, which is of type owner. | | __getattribute__(self, name, /) | Return getattr(self, name). | | __init__(self, /, *args, **kwargs) | Initialize self. See help(type(self)) for accurate signature. | | __repr__(self, /) | Return repr(self). | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __self__ | the instance invoking super(); may be None | | __self_class__ | the type of the instance invoking super(); may be None | | __thisclass__ | the class invoking super()