面向对象知识点
1 """""" 2 """ 3 多态 4 一种事物具备多种不同的形态 5 例:水:固态 气态 液态 6 大黄蜂:汽车人,汽车,飞机 7 8 官方解释: 9 多个不同对象可以响应同一个方法,产生不同的结果 10 首先强调 11 多态不是一种特殊的语法, 12 而是一种状态,特性 13 (即:多个不同对象可以响应同一个方法,产生不同的结果) 14 即:多个对象有相同的使用方法 15 16 好处:对于使用者而言,大大降低了使用难度 17 18 例如 :之前写的USB接口,鼠标,键盘都属于多态 19 20 实现多态: 21 接口 抽象 鸭子类型 22 都可以写出具备多态的代码,最简单的就是鸭子类型 23 24 """ 25 #"""案例""" 26 """ 27 要管理鸡,鸭,鹅 28 如何能够最方便的管理,即我说同一句话,他们都能理解,即他们拥有同一种方法 29 """ 30 class Ji: 31 def bart(self): 32 print('咯咯咯...') 33 def spawn(self): 34 print('下蛋了...') 35 class Duck: 36 def bart(self): 37 print('嘎嘎嘎...') 38 def spawn(self): 39 print('下蛋了...') 40 class E: 41 def bart(self): 42 print('鹅鹅鹅...') 43 def spawn(self): 44 print('下蛋了...') 45 # 规范 46 def mange(obj): 47 obj.bart() 48 obj.spawn() 49 50 j = Ji() 51 mange(j) 52 d= Duck() 53 mange(d) 54 e = E() 55 mange(e) 56 """ 57 咯咯咯... 58 下蛋了... 59 嘎嘎嘎... 60 下蛋了... 61 鹅鹅鹅... 62 下蛋了... 63 """ 64 # """案例2""" 65 # python中到处都有多态 66 a = 10 67 b = "10" 68 c = [10] 69 70 print(type(a)) 71 print(type(b)) 72 print(type(c)) 73 """ 74 <class 'int'> 75 <class 'str'> 76 <class 'list'> 77 """
1 """""" 2 """ 3 1.isinstance 4 判断一个对象是否是某个类的实例 5 参数1:要判断的对象 6 参数2:要判断的类型 7 语法: 8 isinstance(实例化对象,数据类型) 9 """ 10 # 案例 11 def add_cost(x,y): 12 if isinstance(x,str) and isinstance(y,str): 13 return x+y 14 return None 15 a = add_cost('12','45') 16 print(a) # 1245 17 b = add_cost('1',2) 18 print(b) # None 19 """ 20 2.issubclass 21 判断一个类是否是另一个类的子类 22 参数1:子类 23 参数2 :父类 24 语法: 25 issubclass(子类,父类) 26 """ 27 # 案例: 28 class Animal: 29 30 def eat(self): 31 print("动物得吃东西...") 32 class Pig(Animal): 33 def eat(self): 34 print('猪吃猪食...') 35 36 class Dog(Animal): 37 def eat(self): 38 print('狗吃狗粮...') 39 40 class Tree: 41 def lifht(self): 42 print('植物光合作用') 43 44 # 协议 45 def sucess(obj): 46 # obj 的类是否继承自obj 47 if issubclass(type(obj),Animal): 48 obj.eat() 49 else: 50 print('123') 51 52 p = Pig() 53 sucess(p) # 猪吃猪食... 54 d = Dog() 55 sucess(d) # 狗吃狗粮... 56 t = Tree() 57 sucess(t) # 123 58 print(issubclass(Tree,object)) # True
1 '''''' 2 """ 3 1.str 4 __str__会在对象被转换为字符串时,转换的结果就是这个函数的返回值 5 6 作用:自定义打印结果 7 8 使用场景:我们可以利用该函数来自定义,对象的打印格式 9 """ 10 # 案例: 11 class Person: 12 def __init__(self,name,age): 13 self.name = name 14 self.age = age 15 def __str__(self): 16 return 'name:%s age:%s'%(self.name,self.age) # name:llx age:123 17 p = Person('llx','123') 18 print(p) # name:llx age:123 19 ''' 20 2.del 21 执行时机:手动删除对象时立马执行,或是程序运行结束时,也会自动执行 22 23 使用场景: 24 当你的对象在使用过程中,打开了不属于解释器的资源:例如文件,网络端口 25 26 ''' 27 # 案例 28 class FileTool: 29 """该类用于简化文件的读写操作""" 30 def __init__(self,path): 31 self.file = open(path,"rt",encoding="utf-8") 32 self.a = 100 33 def read(self): 34 return self.file.read() 35 # 在这里可以确定一个事,这个对象肯定不使用了 所以可以放心的关闭问文件了 36 def __del__(self): 37 self.file.close() 38 f = FileTool('a.txt') 39 # print(f.read()) 40 print(f.__del__()) # 已关闭 41 """ 42 3.call 43 执行时机:在调用自身时执行(即,对象+()) 44 """ 45 # 案例: 46 # call的执行时机 47 class A: 48 def __call__(self,*args,**kwargs): 49 print("call run") 50 print(args) 51 print(kwargs) 52 a = A() 53 a(1,2,3,4,5) # (1, 2, 3, 4, 5) 54 print(a) 55 """ 56 4.__slots__ 57 该属性是一个类属性. 58 作用:用于优化对象内存占用, 59 60 优化的原理:将原本不固定的属性数量变得固定了 61 62 这样解释器也就不会为这个对象创建名称空间,所以__dict__也没了 63 64 从而达到减少内存开销的结果 65 66 另外当类中出现slots时将导致这个类的对象将无法再添加新的属性 67 """ 68 # 案例 69 class Person: 70 __slots__ = ["name","age","money"] 71 def __init__(self,name,age,money): 72 self.name = name 73 self.age = age 74 self.money =money 75 # 当类中出现slots时将导致这个类的对象将无法再添加新的属性,只能添加他所在类的属性 76 # print(self.__dict__) # dict 没有了 77 # AttributeError: 'Person' object has no attribute '__dict__' 78 p = Person('jck','20',10000) 79 import sys 80 # sys.getsizeof 方法可以查看 python 对象的内存占用，单位：字节 (byte) 81 print(sys.getsizeof(p)) # 64 82 # print(p)
1 """""" 2 """ 3 getattr 用点访问属性时,如果属性不存在时执行 4 setattr 用点设置属性时 5 delattr 用del 对象.属性 删除属性时执行 6 7 ps: 8 getattribute 该函数也是用来获取属性的, 9 在获取属性时,如果存在getattribute则先执行该函数, 10 如果没有拿到属性则继续调用getattr函数, 11 如果拿到则直接返回 12 """ 13 # 案例: 14 class A: 15 def __setattr__(self,key,value): 16 print(key) 17 print(value) 18 print("__setattr__") 19 self.__dict__[key] = value 20 21 def __delattr__(self, item): 22 print("__delattr__") 23 print(item) 24 self.__dict__.pop(item) 25 def __getattr__(self,item): 26 print("__getattr__") 27 return 1 28 def __getattribute__(self, item): 29 print("__getattribute__") 30 # return self.__dict__[item] 31 return super().__getattribute__(item) 32 33 a = A() 34 # setattr 用点设置属性时 35 a.name = 'llx' 36 print(a.name) 37 """ 38 name 39 llx 40 __setattr__ 41 __getattribute__ 42 __getattribute__ 43 llx 44 """ 45 # delattr 用del 对象.属性 删除属性时执行 46 del a.name 47 print(a.name) 48 """ 49 __delattr__ 50 name 51 __getattribute__ 52 __getattribute__ 53 __getattr__ 54 1 55 """ 56 # getattr 用点访问属性时,如果属性不存在时执行 57 print(a.xxx) 58 """ 59 __getattribute__ 60 __getattr__ 61 1 62 """ 63 """ 64 ps: 65 getattribute 该函数也是用来获取属性的, 66 在获取属性时,如果存在getattribute则先执行该函数, 67 如果没有拿到属性则继续调用getattr函数, 68 如果拿到则直接返回 69 """ 70 a.name = 'xxx' 71 print(a.name) 72 """ 73 name 74 xxx 75 __setattr__ 76 __getattribute__ 77 __getattribute__ 78 xxx 79 """ 80 b = A() 81 b.__dict__["name"] = "wyf" 82 print(b.name) 83 """ 84 __getattribute__ 85 __getattribute__ 86 wyf 87 """
1 """""" 2 """[]的实原理""" 3 """getitem,setitem,delitem""" 4 """ 5 任何符号,都会被解释器解释成特殊含义,例如 . [] () 6 """ 7 """ 8 getitem 当你用中括号去获取属性时 执行 9 setitem 当你用中括号去设置属性时 执行 10 delitem 当你用中括号去删除属性时 执行 11 """ 12 # 案例1: 13 # class A: 14 # def __getitem__(self, item): 15 # print("__getitem__") 16 # return self.__dict__[item] 17 # def __setitem__(self, key, value): 18 # print("__setitem__") 19 # self.__dict__[key] = value 20 # def __delitem__(self, key): 21 # del self.__dict__[key] 22 # print("__delitem__") 23 # a = A() 24 # # getitem 当你用中括号去获取属性时 执行 25 # a.name = 'llx' 26 # # setitem 当你用中括号去设置属性时 执行 覆盖 27 # # a['name'] = 'llw' 28 # print(a['name']) 29 # delitem 当你用中括号去删除属性时 执行 删掉 30 # del a['name'] 31 # print(a['name']) 32 33 """案例2""" 34 """ 35 需求让一个对象支持 点语法来取值 也支持括号取值 36 """ 37 class MyDict(dict): 38 39 def __getattr__(self, key): 40 return self.get(key) 41 def __setattr__(self, key, value): 42 self[key] = value 43 def __delattr__(self, item): 44 del self[item] 45 46 b = MyDict() 47 b["name"] = "jack" 48 print(b["name"]) 49 print(b.name) 50 """ 51 jack 52 jack 53 """ 54 b.age = 20 55 print(b["age"]) # 20
1 """""" 2 """ 3 运算符重载 4 当我们在使用某个符号时, 5 Python解释器都会为这个符号定义一个含义, 6 同时调用对应的处理函数, 7 8 当我们需要自定义对象比较规则时, 9 就可在子类中覆盖 大于 等于 等一系列方法... 10 """ 11 """ 12 案例: 13 14 原本自定义对象无法直接使用大于小于来进行比较 , 15 我们可自定义运算符来实现, 16 让自定义对象也支持比较运算符 17 """ 18 class Student: 19 def __init__(self,name,height,age): 20 self.name = name 21 self.height = height 22 self.age = age 23 def __gt__(self, other): 24 print(self) 25 print(other) 26 print("__gt__") 27 return self.height>other.height 28 def __lt__(self, other): 29 return self.height<other.height 30 def __eq__(self, other): 31 if self.name == other.name and self.age == other.age and self.height == other.height: 32 return True 33 return False 34 s1 = Student('llw','174','18') 35 s2 = Student('llx','180','24') 36 37 print(s1 == s2) # False 38 print(s1>s2) 39 """ 40 <__main__.Student object at 0x0000024008F821D0> 41 <__main__.Student object at 0x0000024008F82208> 42 __gt__ 43 False 44 """ 45 print(s1<s2) # True 46 """ 47 上述代码中,other指的是另一个参与比较的对象, 48 49 大于和小于只要实现一个即可,符号如果不同 解释器会自动交换两个对象的位置 50 """
1 """""" 2 """ 3 迭代器协议 4 5 迭代器是指具有__iter__和__next__的对象 6 7 我们可以为对象增加两个方法来让对象变成一个迭代器 8 """ 9 # 语法 10 # 案例:自定义一个range 11 class MyRange: 12 def __init__(self,start,end,step=1): 13 self.start = start 14 self.end = end 15 self.step = step 16 def __iter__(self): 17 return self 18 def __next__(self): 19 a = self.start 20 self.start += self.step 21 if self.end > a: 22 return a 23 else: 24 # 报错停止 25 raise StopIteration 26 m = MyRange(1,10,3) 27 m.__iter__() 28 print(m.__next__()) 29 print(m.__next__()) 30 print(m.__next__()) 31 # print(m.__next__()) 32 """ 33 1 34 4 35 7 36 raise StopIteration 37 StopIteration 38 """ 39 for i in MyRange(1,100,10): 40 print(i)
1 """""" 2 """ 3 1.上下文管理 4 5 上下文 context 6 7 这个概念属于语言学科,指的是一段话的意义,要参考当前场景,即:上下文 8 9 在Python中,上下文可以理解为是一个代码区间,一个范围, 10 例如with open打开的文件,仅在这个上下文中有效 11 """ 12 """ 13 2.涉及到两个方法 14 1.enter:表示进入上下文,(进入某个场景了) 15 2.exit:表示退出上下文,(退出某个场景了) 16 17 当执行with 语句时,会先执行enter, 18 当代码执行完毕后执行exit, 19 或者代码遇到异常会立刻执行exit,并传入错误信息 20 21 错误信息类型:错误的信息,错误的追踪信息 22 23 ps: 24 enter 函数应该返回对象自己 25 26 exit函数 可以有返回值,是一个bool类型,用于表示一场是否被处理,仅在上下文中出现异常有用 27 28 如果为 True 意味着异常已经被处理 29 False,异常未被处理,程序中断出错 30 """ 31 class MyOpen: 32 def __init__(self,path): 33 self.path = path 34 def __enter__(self): 35 self.file = open(self.path) 36 print("enter....") 37 return self 38 def __exit__(self, exc_type, exc_val, exc_tb): 39 print('exit...') 40 print(exc_type, exc_val, exc_tb) 41 self.file.close() 42 return True 43 with MyOpen('a.txt')as f: 44 print(f) 45 # print(f.file.read()) 46 # 中途不能插入其他无关数据,否则就不是的上下文了 47 "123"+1 48 f.file.read() 49 print(f.file.read()) 50 """ 51 enter.... 52 <__main__.MyOpen object at 0x000001F503CF8518> 53 asasasa 54 exit... 55 <class 'TypeError'> must be str, not int <traceback object at 0x000001F503D01F08> 56 """
总结
1 1.多态 2 3 是一种状态,如果程序具备这种状态,对象的使用者,可以很方便忽略对象之间的差异 4 5 我们可以通过鸭子类型来让程序具备多态性 6 7 2.一对函数 8 9 isinstance(对象实例化,数据类型) 判断类型 优先 10 11 issubclass(子类,父类) 判断两者是否是父子关系 优先 12 13 3.类中的魔法函数 14 15 str 优先 16 __str__ 会在对象被转换为字符串时,转换的结果就是这个函数的返回值 17 使用场景:我们可以利用该函数来自定义,对象的是打印格式 18 19 del 优先 20 执行时机: 手动删除对象时立马执行,或是程序运行结束时也会自动执行 21 使用场景:当你的对象在使用过程中,打开了不属于解释器的资源:例如文件,网络端口 22 23 call 24 执行时机:在调用对象时自动执行,(既对象加括号) 25 26 slots __slots__ = ["name"] 限制作用 27 该属性是一个类属性,用于优化对象内存占用 28 优化的原理,将原本不固定的属性数量,变得固定了 29 这样的解释器就不会为这个对象创建名称空间,所以__dict__也没了 30 从而达到减少内存开销的效果 31 32 4.点语法的 实现 getattr setattr delattr 33 print(a.name) 34 35 5.[]取值的实现 getitem setitem delitem 36 print(a["name"]) 37 38 6.运算符重载,可以让对象具备相互间比较的能力 39 # 传进类中两个对象,在方法中进行比较,返回符合的结果 40 7.迭代器的两个函数 iter next 41 42 8.上下文管理 优先 可以实现自动清理 与del的区别 del管理的是对象的生命周期 会在对象销毁时执行清理 43 44 上下文管理,管理的是一个代码范围 ,出了范围自动清理