三大特性：继承
继承
什么是继承：类的继承跟现实生活中的父、子、孙子、重孙子、继承关系一样，父类又称为基类。
python中类的继承分为：单继承和多继承
class father: pass class mother: pass class Son(father): #单继承 pass class Son(father,mother): #多继承 pass
到底继承了什么：子类继承了父类的所有数据属性和函数属性
继承的本质是父类把自己类的属性引用传递给了子类,子类可以调用父类的属性,但其实它们是不属于子类的
#_*_coding:utf-8_*_ __author__ = 'Linhaifeng' class Dad: '我是爸爸类啊' money=10000 def __init__(self,name): print('爸爸类的初始化方法-->') self.name=name def hit_son(self): print('调用者是%s 我是爸爸吧的方法啊' %self.name) class Son(Dad): '我是儿子类吭' pass s1=Son('小白龙') print('继承的爸爸的遗产',s1.money) s1.hit_son() #继承了爸爸打儿子的方法 #上述表现貌似证明了儿子类,继承了父类所有的属性(类的数据属性和函数属性) print(Dad.__dict__) print(Son.__dict__) #打印的结果发现,儿子类的属性字典中没有任何关于父类的属性 #注意了 #注意了 #注意了 #注意了 #注意了 #注意了 #继承的本质是父类把自己类的属性引用传递给了儿子,儿子类可以调用父类的属性,但其实它们是不属于儿子的 #因此,在子类中定义的任何数据属性和函数属性都存在于儿子类的属性字典中,调用时优先从自己的属性字典里面查 class Dad: '我是爸爸类啊' money=10000 def __init__(self,name): print('爸爸类的初始化方法-->') self.name=name def hit_son(self): print('调用者是%s 我是爸爸吧的方法啊' %self.name) class Son(Dad): '我是儿子类吭' def __init__(self,name,age): self.name=name self.age=age def hit_son(self): print('我们做儿子的,哪能忍心下手再打儿子') s1=Son('小白龙',18) print(s1.name,s1.age) s1.hit_son() print(Dad.__dict__) print(Son.__dict__) 做儿子的哪能打儿子
继承和组合的使用分别：
1.当类之间有显著不同，并且较小的类是较大的类所需要的组件时，用组合比较好
例如：描述一个机器人类，机器人这个大类是由很多互不相关的小类组成，如机械胳膊类、腿类、身体类、电池类
2.当类之间有很多相同的功能，提取这些共同的功能做成基类，用继承比较好
例如
猫可以：喵喵叫、吃、喝、拉、撒
狗可以：汪汪叫、吃、喝、拉、撒
继承实现：
class Animal: def eat(self): print("%s 吃 " %self.name) def drink(self): print ("%s 喝 " %self.name) def shit(self): print ("%s 拉 " %self.name) def pee(self): print ("%s 撒 " %self.name) class Cat(Animal): def __init__(self, name): self.name = name self.breed = '猫' def cry(self): print('喵喵叫') class Dog(Animal): def __init__(self, name): self.name = name self.breed='狗' def cry(self): print('汪汪叫') # ######### 执行 ######### c1 = Cat('小白家的小黑猫') c1.eat() c2 = Cat('小黑的小白猫') c2.drink() d1 = Dog('胖子家的小瘦狗') d1.eat()
继承的两种含义
含义一.继承基类的方法，并且做出自己的改变或者扩展（代码重用）
含义二.声明某个子类兼容于某基类，定义一个接口类，子类继承接口类，并且实现接口中定义的方法
#接口类实现
import abc #导入abc模块 class All_file(metaclass=abc.ABCMeta): #在基类引入metaclass=abc.ABCMeta @abc.abstractmethod #@abc.abstractmethod 装饰器 所有继承这个基类的类，都必须满足这个函数 def read(self): '子类必须实现' '本身不用实现' pass @abc.abstractmethod def write(self): pass class Dict(All_file): def read(self): print('dict-读') def write(self): print('dict-写') class Cdrom(All_file): def read(self): print('Cdrom-读') def write(self): print('Cdrom-写') class Mem(All_file): def read(self): print('Mem-读') def write(self): print('Mem-写') m1 = Mem() #如果没有满足，编译时不会报错，但是在调用的时候，会报错 m1.read() #TypeError: Can't instantiate abstract class Mem with abstract methods write m1.write()
实践中，继承的第一种含义意义并不很大，甚至常常是有害的。因为它使得子类与基类出现强耦合。
继承的第二种含义非常重要。它又叫“接口继承”。
接口继承实质上是要求“做出一个良好的抽象，这个抽象规定了一个兼容接口，使得外部调用者无需关心具体细节，可一视同仁的处理实现了特定接口的所有对象”——这在程序设计上，叫做归一化。
归一化使得高层的外部使用者可以不加区分的处理所有接口兼容的对象集合——就好象linux的泛文件概念一样，所有东西都可以当文件处理，不必关心它是内存、磁盘、网络还是屏幕（当然，对底层设计者，当然也可以区分出“字符设备”和“块设备”，然后做出针对性的设计：细致到什么程度，视需求而定）。
继承顺序
继承顺序可通过类的F.__mro__(F是类名或者实例名)函数查看
继承顺序如图：
#_*_coding:utf-8_*_ __author__ = 'Linhaifeng' class A: def test(self): print('from A') class B(A): def test(self): print('from B') class C(A): def test(self): print('from C') class D(B): def test(self): print('from D') class E(C): def test(self): print('from E') class F(D,E): # def test(self): # print('from F') pass f1=F() f1.test() print(F.__mro__) #python2中没有这个属性 #新式类继承顺序:F->D->B->E->C->A #经典类继承顺序:F->D->B->A->E->C #python3中统一都是新式类 #pyhon2中才分新式类与经典类
所有父类的MRO列表并遵循如下三条准则:
1.子类会先于父类被检查
2.多个父类会根据它们在列表中的顺序被检查
3.如果对下一个类存在两个合法的选择,选择第一个父类
子类中调取父类
子类继承了父类的方法，然后想进行修改，注意了是基于原有的基础上修改，那么就需要在子类中调用父类的方法
学习使用：
#_*_coding:utf-8_*_ class Vehicle: #定义交通工具类 Country='China' def __init__(self,name,speed,load,power): self.name=name self.speed=speed self.load=load self.power=power def run(self): print('开动啦...') class Subway(Vehicle): #地铁 def __init__(self,name,speed,load,power,line): #用类名去调用，这种方式不好，当父类更改名称时，所有调用的都需要修改，不容易扩展 #Vehicle.__init__(self,name,speed,load,power) #直接调用父类方法 super().__init__(name,speed,load,power) #用super() self.line=line #派生 def run(self): print('地铁%s号线欢迎您' %self.line) #Vehicle.run(self) #调用父类方法，并传self给方法 super().run() line13=Subway('中国地铁','180m/s','1000人/箱','电',13) line13.run()
老师的定义：
ps1：父类名.父类方法()
#_*_coding:utf-8_*_ __author__ = 'Linhaifeng' class Vehicle: #定义交通工具类 Country='China' def __init__(self,name,speed,load,power): self.name=name self.speed=speed self.load=load self.power=power def run(self): print('开动啦...') class Subway(Vehicle): #地铁 def __init__(self,name,speed,load,power,line): Vehicle.__init__(self,name,speed,load,power) self.line=line def run(self): print('地铁%s号线欢迎您' %self.line) Vehicle.run(self) line13=Subway('中国地铁','180m/s','1000人/箱','电',13) line13.run()
ps2：super() 优势：易改代码，不用传self
#_*_coding:utf-8_*_ __author__ = 'Linhaifeng' class Vehicle: #定义交通工具类 Country='China' def __init__(self,name,speed,load,power): self.name=name self.speed=speed self.load=load self.power=power def run(self): print('开动啦...') class Subway(Vehicle): #地铁 def __init__(self,name,speed,load,power,line): #super(Subway,self) 就相当于实例本身 super(Subway,self).__init__(name,speed,load,power) self.line=line def run(self): print('地铁%s号线欢迎您' %self.line) super(Subway,self).run() class Mobike(Vehicle):#摩拜单车 pass line13=Subway('中国地铁','180m/s','1000人/箱','电',13) line13.run()
ps3:不用super引发的惨案
#_*_coding:utf-8_*_ __author__ = 'Linhaifeng' #每个类中都继承了且重写了父类的方法 class A: def __init__(self): print('A的构造方法') class B(A): def __init__(self): print('B的构造方法') A.__init__(self) class C(A): def __init__(self): print('C的构造方法') A.__init__(self) class D(B,C): def __init__(self): print('D的构造方法') B.__init__(self) C.__init__(self) pass f1=D() print(D.__mro__) #python2中没有这个属性
ps4:当你使用super()函数时,Python会在MRO列表上继续搜索下一个类。只要每个重定义的方法统一使用super()并只调用它一次,那么控制流最终会遍历完整个MRO列表,每个方法也只会被调用一次
#_*_coding:utf-8_*_ __author__ = 'Linhaifeng' #每个类中都继承了且重写了父类的方法 class A: def __init__(self): print('A的构造方法') class B(A): def __init__(self): print('B的构造方法') super(B,self).__init__() class C(A): def __init__(self): print('C的构造方法') super(C,self).__init__() class D(B,C): def __init__(self): print('D的构造方法') super(D,self).__init__() f1=D() print(D.__mro__) #python2中没有这个属性
