阅读目录
内容回顾
继承的另一种使用方式
多继承
组合
菱形继承问题（经典类和新式类路线不一样）
接口
抽象类
鸭子类型
##内容回顾
#属性的的正确存放位置 类中应该存储所有对象公共的内容 对象中存储都是每个对象独有的(都不同) #初始化函数 给对象的属性赋初值 , 可以保证只要对象被创建就一定有相应的属性 节省了重复代码 #绑定方法 指的是 将类或对象与函数进行了绑定 之所以绑定是为了提高整合度,后续在拿到对象就可以直接调用而无需关心 数据时什么 #如何处理 对象也可以看做是一个存储数据的容器 对象绑定方法 默认情况下就是绑定给对象的 当执行该方法时,需要访问对象中的内容 当使用对象调用时 会自动传入对象本身作为第一个参数 用类来调用时就是一个普通函数 该怎么传就这么传 类绑定方法 当执行该方法时,需要访问类中的内容而不需要对象中的内容 @classmethod 无论使用类还是对象来调用都会自动传入类本身作为第一个参数 非绑定方法 既不需要访问类中的内容 也不需要访问对象中的内容 那就作为非绑定方法 就是一个普通函数 没有自动传值的效果 @staticmethod #继承 说的是类与类之间的关系 存在基础关系后 子类可以直接使用父类已经存在的内容 总的来说是为了提高代码的复用性 例如猫 和狗 都属于动物类 描述的时 什么是什么的关系 如:猫是动物 要开始累积自己的类库 把经常使用的小功能写到一个模块中 以后可以直接调用 class 子类(父类): pass #属性查找顺序 对象本身 -> 所在的类 -> 类的父类 -> .... object #抽象 使用基础时 应该先抽象 在继承 抽象指的是 把一系列类中的相同的特征和行为抽取 形成一个新的类 (公共父类) #派生 子类拥有与父类不同的内容 #覆盖 子类出现了与父类完全相同的名字 #一切皆对象 在py3里面所有东西全是对象 包括 int list 模块 函数 .....包等等.... list.append(li,1) #子类访问父类的内容 1.指名道姓 直接写死了类名 即时不存在继承关系也能调用 2.super().要访问的属性 (py3出现的) 3.super(这个子类的名字,self).属性
##继承的另一种使用方式
#继承已有的类来扩展新功能 ----用已经有的类建立一个新的类，这样就重用了已经有的软件中的一部分甚至大部分，大大节省了编程工作量，这就是常说的软件重用，不仅可以重用自己的类，
也可以继承别人的，比如标准库，来定制新的数据类型，大大缩短了软件开发周期，对大型软件开发来说，意义重大 #示例 """ 实现一个存储类 在提供基本的存取功能之外 还要可以限制存储元素的类型 """ class MyList(list): def __init__(self,element_cls): # 当你覆盖了init方法时 # 不要忘记调用super().init函数让父类完成原有的初始化操作 super().__init__() self.element_cls = element_cls def append(self, object): # if isinstance(object,str) # 判断要存储的元素是否是指定类型 if object.__class__ == self.element_cls: super().append(object) else: print("只能存储%s类型!" % self.element_cls.__name__) li = MyList(str) li.append(10) li.append("123") print(li) # li = list() # li = MyList() # # li.append(10) # # li.append(20) # # # # print(li) # # li.append("hello") # li.append(20) # # print(li)
##多继承
#多继承 python支持多继承 一个类可以同时继承多个父类 好处是更加灵活 #问题是:属性的查找顺序该怎么确定 #总结 当你使用super()函数时,Python会在MRO列表上继续搜索下一个类。如果每个重定义的方法统一使用super()并只调用它一次,那么控制流最终会遍历完整个MRO列表,
每个方法也只会被调用一次**(注意注意注意：使用super调用的所有属性，都是从MRO列表当前的位置往后找，千万不要通过看代码去找继承关系，一定要看MRO列表) #示例 # 问题:多继承时如果多个父类中出现了同名的属性/函数 # 你不能用眼睛去判断查找顺序 ,需要使用mro列表来查看真正的继承顺序 # 总结:super在访问父类属性时 是按照mro列表一层层往上找的 #测试 class A: def test(self): print("from A") super().test() # 应该报错..... 但是却执行成功了 class B: def test(self): print("from B") pass class C(A,B): pass c = C() c.test() #最后:尽量不要使用多继承
##组合
#组合: 指的是 一个类把另一个类的对象作为自己的属性 就称之为组合 无处不在 当你定义一个类 并且这个类拥有某种类型的属性时 就称之为组合 都是用来重用代码的方式: 组合描述的是 什么拥有什么的关系 学生 有 书 学生有手机 继承描述的是 什么是什么的关系 麦兜是猪 猪猪侠也是猪 #示例1 class Equip: #武器装备类 def fire(self): print('release Fire skill') class Riven: #英雄Riven的类,一个英雄需要有装备,因而需要组合Equip类 camp='Noxus' def __init__(self,nickname): self.nickname=nickname self.equip=Equip() #用Equip类产生一个装备,赋值给实例的equip属性 r1=Riven('锐雯雯') r1.equip.fire() #可以使用组合的类产生的对象所持有的方法 #示例2 # class Person: # def __init__(self,name): # self.name = name # p = Person("rose") # print(p.name) class PC: def open_app(self,app_name): print("open %s" % app_name) class OldBoyStudent: def __init__(self,PC,notebook): self.PC = PC self.notebook = notebook pass pc = PC() notebook = PC() stu = OldBoyStudent(pc,notebook) # stu.PC.open_app("pycharm") stu.notebook.open_app("pycharm") # stu.open_app("pycharm")
##菱形继承问题（经典类和新式类路线不一样）
# 在py2中 A就是一个经典类---即经典类不继承object父类，主动继承变为新式类，py3都是新式类，可以不括号中添加也会继承object，但有时候为为了兼容py2，py3会有添加的 # class A: # pass # 如果你的代码需要兼容py2 那应该显式的继承object 无论是直接还是间接继承 class B(object): pass class A(B): pass
#下图：
#1、经典类 ：深度优先 e--->b ---->a ----->c ---->d
#2、新式类：因为是菱形，所以总会存在一个父类，e ——————>b 发现a是b、c、d 的父类，也可以理解为先深度找到相同父类，在按广度优先找：e---->b（发现a是相同父类，不找了，广度来找）------>c ------>d----->a
##多菱形示例
class A: # a = 1 pass class B(A): # a = 2 pass class C(A): # a = 3 pass class D(A): # a = 4 pass class E(B,C,D): # a = 5 pass e1 = E() # print(e1.a) # 新式类的顺序 # E B C D A object # 经典类的顺序 # E B A C D # print(E.mro()) 注意:经典类没有mro列表
##接口
#什么是接口? 接口其实是一套协议规范：usb就是一种接口,电源插座也是接口,python中没interface关键字，只能模拟成接口模式 #为什么需要接口? 1.让使用者无需关心对象的类是什么，只需要的知道这些对象都具备某些功能就可以了，这极大地降低了使用者的使用难度。 2.使得外部使用者可以不加区分的处理所有接口兼容的对象 #注意 完全可以不用去实现接口，没有强制性的要求子类必须实现父类的方法,这就用到了抽象类 #示例1 class Mouse(USB): # 实现接口规定的所有功能 def open(self): print("mouse opened") def work(self): print("mouse working...") def close(self): print("mouse closed") class KeyBoard: def open(self): print("KeyBoard opened") def work(self): print("KeyBoard working...") def close(self): print("KeyBoard closed") # 问题是 无法限制子类必须真正的实现接口中的功能 class Camera(USB): def open(self): pass def work(self): pass def close(self): pass class PC: def conntent_device(self,usb_device): usb_device.open() usb_device.work() usb_device.close() # 在实例化Camera abc模块就会检查Camera是否实现了所有的抽象方法 如果没有则无法实例化 Camera() # pc = PC() # # # 创建一个鼠标设备 # mouse1 = Mouse() # # # 创建键盘设备 # key1 = KeyBoard() # # # 链接到电脑上 # # pc.conntent_device(mouse1) # pc.conntent_device(key1) #示例2 class IOInterface:#定义接口Interface类来模仿接口的概念，python中压根就没有interface关键字来定义一个接口。 def read(self): #定接口函数read pass def write(self): #定义接口函数write pass class Txt(Interface): #文本，具体实现read和write def read(self): print('文本数据的读取方法') def write(self): print('文本数据的读取方法') class Sata(Interface): #磁盘，具体实现read和write def read(self): print('硬盘数据的读取方法') def write(self): print('硬盘数据的读取方法') class Process(Interface): def read(self): print('进程数据的读取方法') def write(self): print('进程数据的读取方法')
##抽象类
# 抽象: 指的是 不清楚 不具体 看不懂 # 抽象方法: 指的是 没有函数体的方法 用@abc.abstractmethod 装饰器 如果类中具备抽象方法 那么这个类就称之为抽象类 # 抽象类的特点: 不能直接实例化 必须有子类覆盖了所有抽象方法后才能实例化子类 # 与接口的区别: 接口是指只有方法声明而没有实现体 , 接口中所有方法都是抽象的 #补充 如果接口的子类没有实现接口中的方法,那是没有任何意义的 抽象类之所以出现的意义:通过抽象类来强行限制子类必须覆盖所有的抽象方法 #示例1 import abc class Test(metaclass=abc.ABCMeta): @abc.abstractmethod def say_hi(self): pass class TT(Test): def say_hi(self): print("i am TT obj") t = TT() t.say_hi() #示例二 #_*_coding:utf-8_*_ #一切皆文件 import abc #利用abc模块实现抽象类 class All_file(metaclass=abc.ABCMeta): all_type='file' @abc.abstractmethod #定义抽象方法，无需实现功能 def read(self): '子类必须定义读功能' pass @abc.abstractmethod #定义抽象方法，无需实现功能 def write(self): '子类必须定义写功能' pass # class Txt(All_file): # pass # # t1=Txt() #报错,子类没有定义抽象方法 class Txt(All_file): #子类继承抽象类，但是必须定义read和write方法 def read(self): print('文本数据的读取方法') def write(self): print('文本数据的读取方法') class Sata(All_file): #子类继承抽象类，但是必须定义read和write方法 def read(self): print('硬盘数据的读取方法') def write(self): print('硬盘数据的读取方法') class Process(All_file): #子类继承抽象类，但是必须定义read和write方法 def read(self): print('进程数据的读取方法') def write(self): print('进程数据的读取方法') wenbenwenjian=Txt() yingpanwenjian=Sata() jinchengwenjian=Process() #这样大家的使用方法时完全一致的,也就是一切皆文件的思想 wenbenwenjian.read() yingpanwenjian.write() jinchengwenjian.read() print(wenbenwenjian.all_type) print(yingpanwenjian.all_type) print(jinchengwenjian.all_type)
##鸭子类型
#类比方法 说如果一个对象叫声像鸭子,走路像鸭子,长得像鸭子,那它就是鸭子 例如linux 有一句话叫一切皆文件 之所以这么设计是为了提高扩展性,让Linux可以无差别对待任何设备! #示例1 class PC(): def conntent_device(self, usb_device): usb_device.open() usb_device.work() usb_device.close() class Mouse: # 实现接口规定的所有功能 def open(self): print("mouse opened") def work(self): print("mouse working...") def close(self): print("mouse closed") mouse = Mouse() pc = PC() pc.conntent_device(mouse) class KeyBoard: def open(self): print("KeyBoard opened") def work(self): print("KeyBoard working...") def close(self): print("KeyBoard closed") key1 = KeyBoard() # 如果key1的特征和行为都像USB设备 那就把它当做USB设备来使用 # 对于使用者而言可以不用关心这个对象是什么类,是如如何是实现, pc.conntent_device(key1) #示例2 class Linux: def read_data(self,device): data = device.read() return data def write_data(self,device,data): device.write(data) class Disk: def read(self): print("disk reading....") return "这是一个磁盘上的数据" def write(self,data): print("disk writing %s..." % data) class UP: def read(self): print("disk reading....") return "这是一个U盘上的数据" def write(self,data): print("disk writing %s..." % data) l = Linux() d = Disk() data = l.read_data(d) l.write_data(d,"这是一个数据....") up1 = UP() l.read_data(up1) l.write_data(up1,"一个数据...")