类的继承与派生
经典类和新式类
在python3中，所有类默认继承object，但凡是继承了object类的子类，以及该子类的子类，都称为新式类（在python3中所有的类都是新式类）
没有继承object类的子类成为经典类（在python2中，没有继承object的类，以及它的子类，都是经典类）
1 class People: 2 pass 3 class Animal: 4 pass 5 class Student(People,Animal): #People、Animal称为基类或父类，Student为子类，Student继承了People和Animal的所有属性 6 pass 7 print(Student.__bases__) #__bases__方法，查看继承的类的元组 8 print(People.__bases__) 9 print(Animal.__bases__)
输出结果：
1 (<class ‘__main__.People‘>, <class ‘__main__.Animal‘>) #继承了两个父类 2 (<class ‘object‘>,) #默认继承了object类 3 (<class ‘object‘>,)
继承
继承是为了减少代码重用的问题，以减少代码冗余。
继承是一种是什么是什么的关系，例如老师类是人类，而非老师类是生日类
继承类示例：
1 class People: #定义父类People 2 def __init__(self, name, age): 3 self.name = name 4 self.age = age 5 def walk(self): 6 print(‘%s is walking‘ %self.name) 7 8 #Teacher类和Student类无任何属性 9 class Teacher(People): #Teacher类继承People类的属性 10 pass 11 class Student(People): #Student类继承People类的属性 12 pass
引用测试：
1 t=Teacher(‘bob‘,18) #实例化一个Teacher对象，而非People对象，Student子类同理
2 print(type(t))
3 print(t.name,t.age)
4 print(t.__dict__)
5 t.walk() #Teacher子类继承了People的属性，使得Teacher子类的对象能够调用到父类的属性
6
7 输出结果：
8 <class ‘__main__.Teacher‘>
9 bob 18
10 {‘name‘: ‘bob‘, ‘age‘: 18}
11 bob is walking
派生
派生是在子类继承父类的基础上， 定义子类独有的属性，例如Teacher可以有教师等级的划分、有教学课程的划分，但是继承父类People类是没有等级和课程的划分的。
示例：
1 #定义父类People 2 class People: 3 def __init__(self, name, age,sex): 4 self.name = name 5 self.age = age 6 self.sex=sex 7 def walk(self): 8 print(‘%s is walking‘ % self.name) 9 def test(self): 10 print(‘test class from father class %s‘ %self.name) 11 #定义Teacher子类 12 class Teacher(People): 13 school = ‘jialidun‘ 14 def __init__(self, name, age,sex,level,salary): 15 People.__init__(self,name,age,sex) #继承父类的初始化内容,实例化时候接收的参数name、age、sex会传给People.__init__ 16 self.level=level #派生的独有属性 17 self.salary=salary #派生的独有属性 18 def teach(self): #派生的独有属性 19 print(‘%s is teaching‘ %self.name) 20 def test(self): #派生父类的已有属性，对象在进行属性引用的时候会优先引用实例化过程中用到的类 21 People.test(self) 22 print(‘from teacher‘) 23 #定义Student子类 24 class Student(People): 25 def __init__(self, name, age,sex,group): 26 People.__init__(self, name, age, sex) 27 self.group=group 28 def study(self): 29 print(‘%s is studying‘ %self.name)
测试验证：
1 t=Teacher(‘natasha‘,18,‘male‘,10,3000) #__init__(t,‘natasha‘,18,‘male‘,10,3000) 2 print(Teacher.__bases__) 3 print(Teacher.__dict__) 4 t.test()
组合
不同于继承，组合是包含的意思，表示一种什么有什么的关系，也是为了减少重复代码的
示例：还是People、Teacher和Student的例子，只是加上了一个Birthday生日类
1 #Birthday类，需要传入年月日 2 class Birthday: 3 def __init__(self,year,mon,day): 4 self.year=year 5 self.mon=mon 6 self.day=day 7 def tell_birth(self): 8 print(‘出生于<%s>年 <%s>月 <%s>日‘ % (self.year,self.mon,self.day)) 9 #People类，需要接受名字年龄年月日，年月日传给Birthday类 10 class People: 11 def __init__(self, name, age, year, mon, day): 12 self.name = name 13 self.age = age 14 #__init__接收的year, mon, day传给Birthday类 15 self.birth = Birthday(year, mon, day) #包含Birthday类，生日不只是人类才有，其他动物也可以有生日，不同于继承 16 def walk(self): 17 print(‘%s is walking‘ % self.name) 18 #Teacher类 19 class Teacher(People): 20 def __init__(self, name, age, year, mon, day,level,salary): 21 #__init__接收的name, age, year, mon, day传给People类 22 People.__init__(self,name,age,year,mon,day) 23 self.level=level 24 self.salary=salary 25 def teach(self): 26 print(‘%s is teaching‘ %self.name) 27 #Student类 28 class Student(People): 29 def __init__(self, name, age, year, mon, day,group): 30 People.__init__(self,name,age,year,mon,day) 31 self.group=group 32 def study(self): 33 print(‘%s is studying‘ %self.name)
测试验证：
1 t=Teacher(‘hurry‘,18,1990,2,33,10,3000) #传入的值为Teacher类接收的值 2 print(t.name,t.age) #对象t的名字和年龄 3 print(t.birth) #输出的是一个类对象，因为父类People定义的birth属性就是一个类Birthday 4 t.birth.tell_birth() #查看对象t所继承的People类的birth属性(Birthday类)的tell_birth()属性 5 print(t.birth.year) 6 print(t.birth.mon) 7 print(t.birth.day)
接口和抽象类
接口
接口是一组功能的入口，要调用某一组功能，需要通过接口来进行调用，而不需要关注这组功能是如何实现的，要的只是结果。
在类里，接口是提取了一群类共同的函数，可以把接口当做一个函数的集合。
python模仿接口示例：
1 #模仿Linux内文件读写的接口，Linux不管是文本，还是磁盘还是进程都是通过文件去实现的，只不过方法不同，但是没关系 2 class File: #定义一个接口类，提供read和write方法，但是一定是pass没有处理过程的，因为功能的实现具体靠的是子类 3 def read(self): #定接口函数read 4 pass 5 def write(self): #定义接口函数write 6 pass 7 #定义子类实现读写功能 8 #文本文件的读写 9 class Txt(File): #文本，具体实现read和write 10 def du(self): #注意并不是read 11 print(‘文本数据的读取方法‘) 12 def xie(self): #注意并不是write 13 print(‘文本数据的写入方法‘) 14 #硬盘数据的读写 15 class Sata(File): #磁盘，具体实现read和write 16 def read(self): 17 print(‘硬盘数据的读取方法‘) 18 def write(self): 19 print(‘硬盘数据的写入方法‘) 20 #进程数据的读写 21 class Process(File): 22 def read(self): 23 print(‘进程数据的读取方法‘) 24 def write(self): 25 print(‘进程数据的写入方法‘)
测试验证：硬盘和进程一样，所以制作文本和硬盘的测试即可
硬盘读写测试：
1 disk=Sata() #实例化一个硬盘读写对象 2 disk.read() #硬盘读 3 disk.write() #硬盘写 4 5 输出结果： 6 硬盘数据的读取方法 7 硬盘数据的写入方法
文本读写测试：执行后会发现没有任何输出，那是因为txt对象实际上访问的read和write属性并非子类Txt所提供的属性，Txt所提供的属性只是du和xie，但是txt对象有read和write属性，别忘了Txt类是继承了父类File的属性，所以实际上txt对象的read和write属性是父类File提供的
1 txt=Txt() 2 txt.read() 3 txt.write()
正确的做法是将Txt类的du和xie方法改成read和write方法，这么做的意义为归一化
归一化，让使用者无需关心对象的类是什么，只需要的知道这些对象都具备某些功能就可以了，这极大地降低了使用者的使用难度。
抽象类
抽象类的本质上也是类，但是抽象类只能够被继承，不能进行实例化，也就是说可以当父类，但是不能生成对象。
抽象类介于接口和归一化中间，用于实现接口的归一化
当子类继承抽象类的时候，如果抽象类定义了抽象方法，那么子类必须要定义同名的方法。即父类限制：
1、子类必须要有父类的方法
2、子类实现的方法必须跟父类的方法的名字一样
python的抽象类通过abc模块实现。
接口归一化示例：
1 import abc 2 class File(metaclass=abc.ABCMeta): #metaclass指的是元类，边会讲，现在只需记住这个词 3 @abc.abstractmethod #抽象方法，即一个装饰器装饰read属性 4 def read(self): 5 pass 6 @abc.abstractmethod #抽象方法，即一个装饰器装饰write属性 7 def write(self): 8 pass 9 # # 当继承File类时候，如果没有read和write方法，会提示出错TypeError: Can‘t instantiate abstract class Txt with abstract methods read, write 10 # class Txt(File): 11 # def du(self): 12 # print(‘文本数据的读取方法‘) 13 # def xie(self): 14 # print(‘文本数据的写入方法‘) 15 #定义子类具体实现文本的读写操作 16 class Txt(File): 17 def read(self): 18 print(‘文本数据的读取方法‘) 19 def write(self): 20 print(‘文本数据的写入方法‘) 21 #定义子类具体实现硬盘的读写操作 22 class Sata(File): 23 def read(self): 24 print(‘硬盘数据的读取方法‘) 25 def write(self): 26 print(‘硬盘数据的写入方法‘) 27 #定义子类具体实现进程的读写操作 28 class Process(File): 29 def read(self): 30 print(‘进程数据的读取方法‘) 31 def write(self): 32 print(‘进程数据的写入方法‘)
测试验证：
1 t=Txt() 2 t.read() 3 t.write() 4 s=Sata() 5 s.read() 6 s.write() 7 输出结果： 8 文本数据的读取方法 9 文本数据的写入方法 10 硬盘数据的读取方法 11 硬盘数据的写入方法
时间： 2024-08-26 07:53:15