反射 元类
反射 refiect
反射指的是一个对象应具备 可以检测,修改,增加自身属性的能力
反射就是通过字符串操作属性
涉及的四个内置函数
hasattr(对象名, 属性名) : 判断某个对象是否存在某个属性
getattr(对象名, 属性名, 默认值) : 从对象中取出属性,第三个值是默认值,当属性不存在时返回默认值
setattr(对象名, 属性名, 属性值) : 为对象增加新的属性和值
delattr(对象名, 属性名) : 删除对象的属性
class A: def __init__(self, name, age, gander): self.name = name self.age = age self.gander = gander def hai(self): print('hai') a = A('x', 20, 'man') # 判断某个对象是否存在某个属性 if hasattr(a, 'name'): # 从对象中取出属性,第三个值是默认值,当属性不存在时返回默认值 print(getattr(a, 'name', None)) # 为对象增加新的属性和值 setattr(a, 'id', 110) print(a.id) # 删除对象的属性 delattr(a, 'id') if hasattr(a, 'id'): print(a.id) else: print('没有 id') print(getattr(a, 'hai')) # >>> <bound method A.hai of <__main__.A object at 0x00000209A0549C18>> func = getattr(a, 'hai') func() # >>> hai
应用场景:
反射其实就是对一个对象属性的增删改查,也可以通过通过__dict__来操作,单语法繁琐
另外一个主要的问题是,如果对象不是我自己写,是另一方提供的,我就必须判断这个对象是否满足要求,也就是是否有我需要的属性和方法
框架设计方式:
'''
反射被称为框架的基石
框架的设计值,不可能提前知道你的对象到底是怎么设计的,所以你提供给框架的对象必须通过判断验证之后才能正常使用,判断验证就是反射要做的事情
'''
'''插件部分''' class WinCMD: def cd(self): print("wincmd 切换目录....") def delete(self): print("wincmd 要不要删库跑路?") def dir(self): print("wincmd 列出所有文件....") class LinuxCMD: def cd(self): print("Linuxcmd 切换目录....") def rm(self): print("Linuxcmd 要不要删库跑路?") def ls(self): print("Linuxcmd 列出所有文件....") '''配置文件''' # 为框架的使用者提供一个配置文件,要求对方将类的信息写入配置文件,框架自己去加载小的模块 CLASS_PATH = 'libs.plugins.LinuxCMD' '''框架部分''' from frame import settings import importlib def run(obj): while True: cmd = input('请输入指令:') if cmd == 'exit': break # 因为无法确定框架使用者是否传入正确的对象,所以需要使用反射来检测 # 判断对象是否具有处理这个指令的方法 if hasattr(obj, cmd): # 取出该方法 func = getattr(obj, cmd) # 执行该方法 func() else: print('该指令不支持') print('退出') # 框架得根据配置文件拿到需要的类 path = settings.CLASS_PATH # 从配置文件中单独拿出模块和类名 module_path, class_name = path.rsplit('.',1) # 拿到模块 mk = importlib.import_module(module_path) # 取出模块中的类 cls = getattr(mk, class_name) # 实例化对象 obj = cls() # 调用框架 run(obj) # 如此一来 框架就与现实代码彻底解耦了
元类 metaclass
type 就是所有类的元类
元类是用于创建类的类
万物皆对象,类也是对象
对象时通过类实例化产生的,所以类对象必然也是由另一个类实例化产生的
class A: pass a = A() print(type(a)) # <class '__main__.A'> print(type(A)) # <class 'type'> # A类是通过type类实例化产生的
学习元类的目的:
高度的自定一个类,例如控制类的名字必须以大驼峰的方式来书写
类也是对象,也有自己的类
class MyType(type): # 覆盖元类中的__init__方法 def __init__(self, cls_name, bases, dict): # 调用元类中的__init__方法,使用其初始化功能 super().__init__(cls_name, bases, dict) # 添加判断条件 if not cls_name.istitle(): raise Exception('首字母需要大写') class A(metaclass=MyType): pass print(type(A))
元类中的call方法
当你调用类对象时会自动执行原类中__call__方法,并将这个类本身作为第一个参数传入,以及后面的一堆参数
覆盖元类中的__call__之后,这个类就无法产生对象,必须调用super().__call__来完成对象的创建,并返回其返回值
使用场景:
当你想要控制对象创建过程时,就覆盖call方法
当你想要控制类的创建过程时,就覆盖init方法
案例:
实现将对象的所有属性名称大写: lass MyType(type): def __call__(self, *args, **kwargs): new_args = [] for a in args: new_args.append(a.upper()) print(new_args) print(kwargs) # 注意: 一旦覆盖了__call__ 必须调用父类的call方法来产生对象并返回这个对象 return super().__call__(*new_args,**kwargs) class Person(metaclass=MyType): def __init__(self,name,gender): self.name = name self.gender = gender p = Person(name="jack",gender="woman") print(p.name) print(p.gender)
new方法
当你要创建对象时,会首先执行元类中的__new__方法,拿到一个空对象,然后会自动调用__init__来对这个类进行初始化操作
注意:如果你覆盖了该方法则必须保证__new__方法必须有返回值,且必须是对应的类对象
class Meta(type): def __new__(cls, *args, **kwargs): print(cls) # 元类自己 print(args) # 创建类需要的几个参数 类名,基类,名称空间 print(kwargs) #空的 print("new run") # return super().__new__(cls,*args,**kwargs) obj = type.__new__(cls,*args,**kwargs) return obj def __init__(self,a,b,c): super().__init__(a,b,c) print("init run") class A(metaclass=Meta): pass print(A)
__new__方法和__init__都可以实现控制类的创建过程,__init__更简单
单例设计模式
用于解决某种问题的固定思路
例如:MVC MTV等
单例:指的是一个趔产生一个对象
目的:单例是为了节省资源,当一个类的所有对象属性全部相同时,则没有必须要创建多个对象
# 单例n元类 class Single(type): def __call__(self, *args, **kwargs): if hasattr(self,"obj"): #判断是否存在已经有的对象 return getattr(self,"obj") # 有就返回 obj = super().__call__(*args,**kwargs) # 没有则创建 print("new 了") self.obj = obj # 并存入类中 return obj class Student(metaclass=Single): def __init__(self,name): self.name = name class Person(metaclass=Single): pass # 只会创建一个对象 Person() Person()
