类的多态性
类的多态性
概念：
一个事物具备多种不同的形态
例如：水 固态 气态 液态
大黄蜂：汽车人，汽车，飞机
官方解释：多个不同类对象可以响应同一个方法，产生不同的结果
首先强调多态不是一种特殊的语法，而是一种状态(既多个不同对象可以响应同一个方法，产生不同的结果)
既等多个对象有相同的使用方法
类的多态性是指多个不同的对象之间具有相同的使用方法。
好处
对于使用者而言，大大的降低了使用难度
我们之前写的USB接口，下的鼠标，键盘，就属于多态。
实现多态
接口 ，抽象类，鸭子类型都可以写出具备多态的代码，最简单的就是鸭子类型，
案例：
"""
要管理 鸡 鸭 鹅
如何能最方便的 管理，就是我说一句话，他们都能理解
即它们拥有相同的方法
"""
class JI:
def jiao(self):
print('咯咯咯')
def lay_egg(self):
print('鸡下蛋了')
class Duck:
def jiao(self):
print('嘎嘎嘎')
def lay_egg(self):
print('鸭下蛋了')
class E:
def jiao(self):
print('鹅鹅鹅....')
def lay_egg(self):
print('鹅下蛋了')
j = JI()
y = Duck()
e = E()
def manage(obj):
obj.jiao()
obj.lay_egg()
mange(j)
mange(y)
mange(e)
# pyhton中到处都有多态
# 多个不同的对象之间具有相同的使用方法
a = 10
b = "10"
c = [10]
print(type(a))
print(type(b))
print(type(c))
isinstanse
判断一个对象是否是某个类的实例化对象
参数1 要判断的对象
参数2 要判断的类型
def add_num(a,b):
if isinstance(a,int) and isinstance(b,int):
return a+b
print(add_num(20,10))
issubclass
判断一个类是否是另一个类的子类
参数1 是子类
参数2 是父类
class Animal:
def eat(self):
print("动物得吃东西了")
class Pig(Animal):
def eat(self):
print('猪得吃主食.....')
class Tree:
def get_light(self):
print('植物的光合作用')
pig = Pig()
t = Tree()
def manage(obj):
# 判断obj的类型那个是不是Animal的子类
if issubclass(type(obj),Animal):
obj.eat()
else:
print('不是一头动物')
manage(pig) # 猪得吃主食.....
#
manage(t) # 不是一头动物
# 每个类都市object的子类
print(issubclass(Tree,object)) # True
str:打印对象的类型为字符串
__str__ 会在对象被转换为字符时，转换的结果就是这个函数的返回值
使用场景：我们可以利用该函数来自定义，对象的时打印格式
import sys
import time
class Person:
def __init__(self,name,age):
self.name = name
self.age = age
# __str__,是覆盖了父类object类中的__str__方法，可以自定义对象，的打印格式返回值是对象，
def __str__(self):
return f"这是一个person对象，名字为{self.name},年龄为{self.age}"
# 在程序运行结束才会执行
def __del__(self):
print('del run')
# 将对象由内存地址转化为了字符串，
p = Person("jack",20) # 这是一个person对象，名字为jack,年龄为20
time.sleep(2)
s = str(p)
print(s)
print("over")
# Person中没有__str__函数，默认使用object类中的__str__方法，即str(obj)对象的结果是一堆字符串，
p = Person("jack",20)
print(p) # <__main__.Person object at 0x025B8C30>
time.sleep(2)
s = str(p)
print(s) # <__main__.Person object at 0x025B8C30>
print("over")
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())
# del自动删除使用案例
class FileToll:
def __init__(self,path):
self.file = open(path,'rt',encoding='utf-8')
def read(self):
return self.file.read()
# 未手动删除，在程序运行结束后执行
def __del__(self):
self.file.close()
tool = FileToll('a.txt')
print(tool.read()) # 12345678
# del手动删除使用案例
import sys
import time
class Person:
def __init__(self,name,age):
self.name = name
self.age = age
def __del__(self):
print('del run')
p = Person("jack",20)
# 手动删除了，先运行__del__函数
del p # del run
time.sleep(2)
print("over") # over
call
执行时机：在调用对象时自动执行，(即对象加括号)
测试：
# call 的执行时机
class A:
# 只有在调用对象时自动执行，(即对象加括号)
def __call__(self, *args, **kwargs):
print('run')
print(args)
print(kwargs)
# 实例化a
a = A()
# 调用对象
a(1,a=100)
run
(1,)
{'a': 100}
slots
该属性是一个类属性，用于优化对象内存占用
优化的原理，将原本不固定的属性数量，变的固定了
这样的解释器就不会为这个对象创建名称空间，所以__dict__也没了
从而达到减少内存开销的效果
另外当类中出现了slots时将导致这个类的对象无法在添加新的属性
[https://www.cnblogs.com/zuihoudebieli/gallery/image/252164.html]
# slots的使用
class Person:
__slots__=['name']
def __init__(self,name):
self.name = name
p = Person('jack')
# 查看内存占用
# print(sys.getizeof(p))
# p.age = 20
# dict 没有了
print(p.__dict__)
# slots的使用
import sys
class Person:
# __slots__ = ["name"]
def __init__(self,name):
self.name = name
print(self.__dict__) # {'name': 'jason'}
p = Person("jason")
print(sys.getsizeof(p)) # 32
p.age = 20
print(p.age) # 20
# slots
import sys
class Person:
# 限制对象的属性个数，节省内存占用
__slots__ = ["name"]
def __init__(self,name):
self.name = name
# print(self.__dict__) # 无法打印
p = Person("jason")
print(sys.getsizeof(p)) # 28
# p.age = 20 # 无法添加属性
# print(p.age)
# dict 没有了
# print(p.__dict__)
getattr setattr delattr
setattr 用点设置属性时
delattr 用del 对象.属性 删除属性时 执行
getattr 用点访问属性的时候，如果属性不存在时执行
这几个函数反映了 python解释器时如何实现 用点来访问属性
getattribute 该函数也是用来获取属性的
在获取属性时如果存在getattribute则先执行该函数，如果没有拿到属性则继续调用 gatattr函数，如果拿到了则直接返回
# setattr使用案例
class A:
def __setattr__(self, key, value):
print(key)
print(value)
print("__setattr__")
# 将变量名和变量值添加到对象的属性的字典中
self.__dict__[key] = value
a = A()
# 设置属性，添加属性时，执行__setattr__
a.name = "jack"
print(a.name) # jack
print(a.__dict__) # {'name': 'jack'}
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)
def __getattr__(self, item):
print("__getattr__")
return 1
# def __getattribute__(self, item):
# print("__getattribute__")
#
# # return self.__dict__[item]
# return super().__getattribute__(item)
a = A()
# 设置属性，触发__setattr__
a.name = "jack"
# 打印结果
name
jack
__setattr__
# print(a.name)
# print(a.__dict__)
# 删除 属性时，触发__delattr__
del a.name
__delattr__
# 打印删除的属性名对应的值，由于对象中没有属性，查看没有的属性时，会自动触发__getattr__
print(a.name)
name
__getattr__
1
# 由于对象中没有属性，查看没有的属性时，会自动触发__getattr__
print(a.xxx)
__getattr__
1
# 设置属性，触发__setattr__
a.name = "xxx"
name
xxx
__setattr__
# 打印属性名对应的值
print(a.name)
xxx
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)
def __getattr__(self, item):
print("__getattr__")
return 1
def __getattribute__(self, item):
print("__getattribute__")
# return self.__dict__[item]
return super().__getattribute__(item)
a = A()
# 获取对象的属性，先执行__getattribute__，如果获取不到，执行__getattr__，如果获取到了直接返回。
print(a.name)
__getattribute__
__getattr__
1
a.name = "xxx"
# 获取对象的属性，先执行__getattribute__，获取到了属性，直接返回属性的值
print(a.name)
__getattribute__
xxx
b = A()
# 使用__dict__添加属性
b.__dict__["name"] = "jack"
# 获取对象的属性，先执行__getattribute__，添加属性后，在执行__getattribute__
print(b.name)
__getattribute__
__getattribute__
jack
[]的实现原理
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" 程序不执行
# 使用[]给对对象设置属性，触发__setitem__
a['name'] = "jack"
__setitem__
# 使用[]查看对象那个的属性，触发__getitem__
print(a['name'])
__getitem__
jack
# 使用[]删除对象的属性时，触发__delitem__
del a['name']
__delitem__
# print(a['name']) 对象没有名字属性，报错
"""需求让一个对象支持 点语法来取值 也支持括号取值"""
class MyDict(A):
def __getattr__(self, key):
return self.get(key)
def __setattr__(self, key, value):
self[key] = value
def __delattr__(self, item):
del self[item]
a = MyDict()
a['name'] = "jack"
print(a['name'])
print(a.name)
a.age = 20
print(a["age"])
print(a.name)
运算符重载
当我们在使用某个符号时，python解释器都会为这个符号定义一个含义，同时调用对应的处理函数，当我们需要自定义对象的比较规则时，就可在子类中覆盖大于，小于， 等于等一系列方法......
案例：
原本自定义对象无法直接使用大于小于来进行比较，我们可自定义运算符来实现，让自定义对象也支持比较运算符，
class Student(object):
def __init__(self,name,height,age):
self.name = name
self.height = height
self.age = age
def __gt__(self,other):
return self.height > other.height
def __lt__(self,other):
return self.height < other.height
def __eq__(self,other):
if self.name == other.name and self.age == other.age and self.height == other.height:
return True
return False
stu1 = Student("jack",180,28)
stu2 = Studnt("jack",180,28)
# print(stu1 < stu2)
print(stu1 < stu2)
上述代码中，other指的是另一个参与比较的对象，
大于和小于只要是实现一个即可，符号如果不同，解释器会自动交换两个对象的位置
class Student(object):
def __init__(self,name,height,age):
self.name = name
self.height = height
self.age =age
def __gt__(self, other):
print(self)
print(other)
print("__gt__")
return self.height > other.height
def __lt__(self, other):
return self.height < other.height
def __eq__(self, other):
if self.name == other.name and self.age == other.age and self.height == other.height:
return True
return False
s1 = Student("jack",180,28)
s2 = Student("jack",180,28)
# s2 = Student("nick",160,25)
print(s1 < s2) # False
print(s1 == s2) # True
迭代器协议
迭代器是指具有__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)
上下文管理
上下文context
这个概念属于语言学科，指的是一段话的意义，要参考当前的场景，既上下文
在python中，上下文可以理解为是一个代码区间，一个范围，例如with open 打开的文件仅在这个上下文中有效。
涉及到的两个方法：
enter
表示进入上下文,(进入某个场景了)
exit
表示退出了上下文,(推出了某个场景了)
当执行with语句时，会先执行enter
当代码执行完毕后执行exit，或者代码遇到了异常会立即执行exit，并传入错误信息
包含错误的类型.错误的信息.错误的追踪信息
注意：
enter 函数应该返回对象自己
exit函数 可以有返回值，是一个bool类型，用于表示异常是否被处理，仅在上下文中出现异常有用
如果为True 则意味着，异常以及被处理了
False，异常未被处理，程序将中断报错
接口抽象类，鸭子类型，
Never,Never,Never give up.
