反射 元类
1.反射 reflect
反射指的是一个对象应该具备,可以检测,修改,增加自身属性的能力,通过字符串操作属性
涉及四个普通的内置函数,没有双下划线, hasattr getattr setattr delattr
hasattr 判断对象中是否有这个方法或变量
getattr 获取对象中的方法或变量的内存地址
setattr 为对象添加变量或方法
delattr 删除对象中的变量(不能用于删除方法)
def abc(self):
print('%s正在交谈'%self.name)
class Person: def __init__(self,name,age,male): self.name = name self.age = age self.male = male
def talk(self):
print('%s正在交谈'%self.name) p = Person('jack',18,'man') if hasattr(p,"name"): # 判断某个对象是否存在某个属性 print(getattr(p,'name',None)) # jack # 从对象中取出属性,第三个值位默认值 当属性不存在是返回默认值 if hasattr(p,"talk"): # 判断某个对象是否存在talk方法
print(getattr(p,"talk","not find")) # 获得talk方法的内存地址 ,第三个参数用于当方法或属性不存在时,输出not find
setattr(p,"a",abc) # 将abc函数添加到对象中,并命名为a
p.talk(p) # 调用a方法,因为这是额外添加的方法,需要手动传入对象
setattr(p,'id','123') # 添加一个变量age,赋值为123 print(p.id) #123 delattr(p,'id') # 删除id变量 print(p.id) # 此时将报错
使用场景:
反射其实就是对属性的增删改查,但是如果直接使用内置的dict来操作,语法繁琐,不好理解, 另外一个最主要的问题是,如果对象不是我自己写的是另一方提供的,我就必须判断这个对象是否满足的要求,也就是是否我需要的属性和方法
框架代码:
反射被称为框架的基石, 因为框架的设计者,不可能提前知道你的对象到底是怎么设计的, 所以你提供给框架的对象 必须通过判断验证之后才能正常使用, 判断验证就是反射要做的事情, 通过__dict__也是可以实现的, 其实这些方法也就是对__dict__的操作进行了封装
需求:要实现一个用于处理用户的终端指令的小框架
框架就是已经实现了最基础的构架,就是所有项目都一样的部分
import importlib import settings def run(plugin): while True: cmd = input('请输入指令').strip() if cmd == 'exit': break if hasattr(plugin,cmd): # 取出对应方法 func = getattr(plugin,cmd) func() else: print('该指令不支持') print('see you la la') 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) #调用框架
settings 文件里的代码为 CLASS_PATH = 'plugins.LinuxCMD'
plugins 文件里的代码
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 Person(object): name = '123' p = Person() print(type(p)) # <class '__main__.Person'> print(type(Person)) <class 'type'>
调用type类可以产生类对象, 一个类的三个基本组成部分
1.类的名字 2.类的父类们 3.类的名称空间
cls_obj = type('dog',(),{}) print(cls_obj) # <class '__main__.dog'>
元类
用于创建类的类, 对象是通过类实例化产生的,如果类也是对象的话,必然类对象也是有另一个类实例化产生的, 默认情况下所有类的元类都是type,但是type是继承object
class Person: pass p = Person() print(type(p)) # <class '__main__.Person'> print(type(p).__class__) #<class 'type'> print(p.__class__) # <class '__main__.Person'> print(type(Person)) #<class 'type'> print(type(Person).__class__) # <class 'type'>
学习元类的目的: 高度的自定义一个类,例如控制类的名字必须以大驼峰的方式来书写, 我们的需求是创建类对象做一些限制, 想到了初始化方法 我们只要找到类对象的类(元类),覆盖其中 init方法就能实现需求, 当然我们不能修改源代码,所以应该继承type来编写自己的元类,同时覆盖init来完成需求
class MyType(type): # 定义了一个元类 def __init__(self,clss_name,bases,dict): super().__init__(clss_name,bases,dict) if not clss_name.istitle(): raise Exception('类名有误') class Pig(metaclass = MyType): # 为pig类指定了元类为MyType pass
class MyType(type): def __call__(self, *args, **kwargs): new_args = [] for a in args: new_args.append(a.upper()) print(new_args) # ['HAHA'] print(kwargs) # {'name': 'jack', 'gender': 'woman'} return super().__call__(*new_args,**kwargs) class Person(metaclass=MyType): def __init__(self,*args,name,gender): self.name = name self.gender = gender p = Person('haha',name="jack",gender="woman") print(p.name) #jack print(p.gender) #woman
要求创建对象时,必须以关键字参数形式传参
覆盖元类的__call__
判断你有没有传非关键字参数 == 不能有位置参数, 有就炸
class Mate(type): def __call__(self, *args, **kwargs): if args: raise Exception('不允许使用位置参数') return super().__call__(*args,**kwargs) class A(metaclass=Mate): def __init__(self,name): self.name = name a = A(name='jack') print(a.name) # jack
元类中call方法
当你调用类对象时会自动执行元类中的__call__方法 ,并将这个类本身作为第一个参数传入,以及后面的一堆参数, 覆盖元类中的call之后,这个类就无法产生对象,必须调用super().__call__来完成对象的创建 , 并返回其返回值
使用场景:
当你想要控制对象的创建过程时,就覆盖call方法,
class Meta(type): def __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): # init run pass print(A) # <class '__main__.A'>
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 Studenet(metaclass= Single): def __init__(self,name): self.name = name class Person(metaclass=Single): pass stu = Student('jack')
stu = Student('jack')
单例设计模式: 指的是一个类产生一个对象
为什么要使用单例: 单例是为了节省 资源,当一个类的所有对象属性全部相同时,则没有必要创建多个对象
魔法方法
class TestClass: def __new__(cls, *args, **kwargs): print("创建实例") return object.__new__(cls) def __setattr__(self,age,value): print("执行__setattr__") object.__setattr__(self,age,value) def __init__(self,name): self.name = name print("初始化实例") def __str__(self): return self.name def __getattr__(self, item): print("不存在的属性") return item def a(self): print("a") def __del__(self): print("销毁") t = TestClass('dayehui') print(t.age) t1 = TestClass(22)