一、多态
多态:指的是某种事物存在多种形态，例如：动物有：人 狗 猪
在程序中多态指的是，不同对象可以响应相同的方法，并可以有自己不同的实现方法
使用多态的好处：
1：增加了程序的灵活性 （以不变应万变，不论对象千变万化，使用者都是同一种形式去调用）
2：增加了程序的可扩展性（通过继承后再创建新的类）
实现多态：
接口 抽象 鸭子类型（拥有相似的属性和方法）都可以写出具备多态的代码
多态 鸭子类型 class Ji: def bark(self): print("gege") def spawm(self): print("下鸡蛋") class Duck: def bark(self): print("gaga") def spawm(self): print("下鸭蛋") class EI: def bark(self): print("eeee") def spawm(self): print("下鹅蛋") j=Ji() d=Duck() e=EI() # j.spawm() # d.spawm() # e.spawm() def manage(obj): # 管理同样属性的功能 obj.spawm() manage(j) manage(d) manage(e)
"pyhton中到处都有多态的现象" a=100 b="Gavin" c=0.12355 d={'name':"jack",'age':20} e=(12,45,54) print(type(a)) print(type(b)) print(type(c)) print(type(d)) print(type(e)) >>> <class 'int'> <class 'str'> <class 'float'> <class 'dict'> <class 'tuple'>
二、oop相关内置函数
1、isinstance（obj,cls）：判断一个对象是否是某个类的对象 （判断类型的方法）
def add_num(a,b):
if isinstance(a,int) and isinstance(b.int): #判断是否是整型
return a+b
return None
a="100"
b=100
print(add_num(a,b))
# 判断是否是什么类型
2、issubclass(sub,super)：判断一个类是否是另一个类的子类
class Animai: print("动物都能动...") class Pig(Animai): def eat(self): print("猪都吃猪食...") class Tree: def light(self): print("植物的光合作用") p=Pig() t=Tree() def manage(obj): # 定义一个管理系统 if issubclass(type(obj),obj): # 判断是不是子类的类 obj.eat() else: print("这不是同一类!") manage(Pig) manage(t) print(issubclass(Tree,object))
>>>> 动物都能动... Traceback (most recent call last): 这不是同一类!
三、类中的魔法函数：对象的显示相关函数
1：__str__ 会在对象被转换为字符串时，转换的结果就是这个函数的返回值
使用的场景：可以利用该函数来自定义，对象的是打印格式。
class Person: def __str__(self): #转换为字符串 print("run") return "abc" p=Person() print(p) >> run abc
class Person: def __init__(self,name,age): self.name=name self.age=age def __str__(self): return "这是一个person对象 name：%s age:%s" %(self.name,self.age) pass # p=person() print(p) >>> 这是一个person对象 name：sore age:20 # 执行结果会覆盖——init——内置方法 执行打印的格式
2：__del__ 当手动删除对象时立马执行，或是程序运行结束时也会自动执行
使用的场景：当对象在使用过程中，打开了不属于解释器额资源，例如：文件 网络端口（网络编程）
import time class Person: def __init__(self,name,age): self.name=name self.age=age def __del__(self): print("del run ") p=person("reso",20) time.sleep(2) print("结束运行！")
__del__使用案例
# del使用案例 class FileTool: """该类用于简化文件的读写操作 """ def __init__(self,path): self.file = open(path,"rt",encoding="utf-8") self.a = 100 def read(self): return self.file.read() # 在这里可以确定一个事,这个对象肯定不使用了 所以可以放心的关闭问文件了 def __del__(self): self.file.close() tool = FileTool("a.txt") print(tool.read())
3：__call__ 执行时机：在调用对象时自动执行（即对象+括号）对象=类名（）
#call 的执行时机 class A: def __call__(self, *args, **kwargs): print("call run") print(args) print(kwargs) a = A() a(1,a=100) >> call run (1,) {'a': 100}
4:__slots__ :该属性是一个类属性，用于优化对象内存占用
优化的原理：将原本不固定的属性数量，变得固定了这样的解释器就不会为这个对象创建名称空间，所以__dict__查看对象也没了，从而达到减少内存空间的效果
当类中出现了slots时 将导致这个类的对象无法在添加新的属性,开辟的内存空间地址
# slots的使用 class Person: __slots__ = ["name"] # 只固定开辟 name的内存空间 优化内存不浪费空间 def __init__(self,name): self.name = name print(self.__dict__) p = Person("jck") # print(sys.getsizeof(p)) # p.age = 20 # dict 没有了 print(p.__dict__)
四、属性的getattr setattr 和delattr getattribute
点语法.操作对象属性时自动触发
getattr:使用点语法访问属性的时候如果属性不存在时才执行 setattr:用点语法设置属性（修改/添加）时触发它的执行 delattr:使用点语法删除属性时触发
这几个函数反映了 python解释器时如何让实现 用点来访问属性的
getattribute: 该函数也是用来获取属性的：在获取属性时如果存在gqtattribute 则先执行该函数，如果没有拿到属性则继续调用getattr函数，如果拿到了则直接返回
class A: def __setattr__(self, key, value):# 设置 # print(key) # print(value) print("__setattr__") self.__dict__[key] = value def __delattr__(self, item): # 删除 print("__delattr__") print(item) self.__dict__.pop(item) pass def __getattr__(self, item): # 获取属性 print("__getattr__") return 1 def __getattribute__(self, item): print("__getattribute__") # return self.__dict__[item] return super().__getattribute__(item) a = A() a.name = "jack" print(a.name) del a.name print(a.name) print(a.xxx) a.name = "xxx" print(a.name) >>>> __setattr__ __getattribute__ __getattribute__ jack __delattr__ name
五、[ ] 的原理：
getitem setitem delitem
任何的符号都会被解释器解释成特殊的含义，例如，[ ] ()
getitem 当你用中括号去获取属性时 执行
setitem 当你用中括号去设置属性时 执行
delitem 当你用中括号去删除属性时 执行
案例：
class A: def __getitem__(self, item): print("__getitem__") return self.__dict__[item] def __setitem__(self, key, value): print("__setitem__") self.__dict__[key] = value def __delitem__(self, key): del self.__dict__[key] print("__delitem__") a = A() # a.name = "jack" a["name"] = "jack" print(a["name"]) del a["name"] # print(a["name"]) >>> __setitem__ __getitem__ jack __delitem__
六、运算符重载：对象比较大小
当我们在使用某个符号时，python解释器都会为这个符号定义一个含义，同时调用对应的处理函数，
当我们需要自定义对象的比较规则时，就可以在子类中覆盖 大于 等于 小于 等一系列的方法....
案列：
原本自定义对象无法直接使用大于、小于来进行比较，我们可自定义运算符来实现，让自定义对象也支持比较云算符
__gt__:大于比较、 def __It__：小于比较、 def__eq__：等于比较
class Student(object): def __init__(self,name,age,height): self.name=name self.age=age self.height=height def __gt__(self, other): # 比较大于 # print(self) print(other) return self.name>other.name def __eq__(self, other): # 比较等于 print(self) print(other) if self.name == other.name and self.age == other.age: return True return False def __lt__(self, other): # 比较小于 if self.age<other: return s=Student("reso",20,185) s1=Student("Jack",18,155) # print(s.name,s1.age) print(s>s1) print(s<s1) print(s==s1) >>>> True 20 NOne 原本类于类之间不能进行比较 通过函数“__gt__ __qe__ __lt__ ” 后可以进行比较
上述 程序中，other指的是另一个参与比较的对象： 大于和小于只要实现一个即可，
解释器会自动交换两个对象的位置即可
七、迭代器协议
迭代器是指具__iter__和__next__的对象
我们可以为对象增加这两个方法来让对象变成一个迭代器
class MyRange: def __init__(self,start,end,step): self.start = start self.end = end self.step = step def __iter__(self): return self def __next__(self): a = self.start self.start += self.step if a < self.end: return a else: raise StopIteration for i in MyRange(1,10,2): print(i) >>>>1 3 5 7 9
实现让range(1,10)for 循环
八。上下文管理: __enter__和__exit__
上下文：context
在Python中，上下文可以理解为是一个代码区间，一个范围，例如 witho open 打开的文件仅在这个上下文中有效
涉及的方法：
enter: 表示进入上下文 exit : 表示退出上下文
当执行with语句时 会先执行enter，当代码执行完毕后执行exit 或者代码遇到了异常会立即执行exit，并传入错误的信息
包含：错误的类型 错误的信息 错误的追踪信息
注意：
enter 函数应该返回对象自己
exit 函数 可以有返回值，是一个bool类型，用于表示异常是否被处理
仅在上下 文中出现异常有用
如果为True则意味着，异常以经被处理了
False,异常未被处理,程序将中断报错