标签：过多 地址 str people teacher -- 上传 一个 __new__
指的是在程序运行过程中可以"动态 (不见棺材不掉泪)"获取对象的信息
在不清楚对方程序提供的obj值对其进行分析处理时，不知道从什么地方获取，也不清楚这个值得属性的情况下 就需要用到反射进行动态获取进行分析
#举例： class People: def __init__(self,name,age): self.name=name self.age=age def say(self): print(‘<%s:%s>‘ %(self.name,self.age)) obj=People(‘辣白菜同学‘,18) #3.1 实现反射机制的步骤 #1、先通过多dir：查看出某一个对象下可以.出哪些属性来 print(dir(obj)) #2、可以通过字符串反射到真正的属性上，得到属性值 print(obj.__dict__[dir(obj)[-2]]) #3.2 四个内置函数的使用:通过字符串来操作属性值 #1、hasattr() print(hasattr(obj,‘name‘)) print(hasattr(obj,‘x‘)) #2、getattr() print(getattr(obj,‘name‘)) #3、setattr() setattr(obj,‘name‘,‘EGON‘) # obj.name=‘EGON‘ print(obj.name) #4、delattr() delattr(obj,‘name‘) # del obj.name print(obj.__dict__) res1=getattr(obj,‘say‘) # obj.say res2=getattr(People,‘say‘) # People.say print(res1) print(res2) obj=10 if hasattr(obj,‘x‘): print(getattr(10,‘x‘)) else: pass print(getattr(obj,‘x‘,None)) if hasattr(obj,‘x‘): setattr(obj,‘x‘,111111111) # 10.x=11111 else: pass
# 小案例 class Ftp: def put(self): print(‘正在执行上传功能‘) def get(self): print(‘正在执行下载功能‘) def interactive(self): method=input(">>>: ").strip() # method=‘put‘ if hasattr(self,method): getattr(self,method)() else: print(‘输入的指令不存在‘) obj=Ftp() obj.interactive()
定义在类内部，以开头并且以结尾的方法
特点：会在某种情况下自动触发执行
为了定制化我们的类or对象
# 常用： # __str__:定制内置打印方法 class People: def __init__(self,name,age): self.name=name self.age=age def __str__(self): #定制内置方法，一般用于定制打印操作 # print(‘运行了。。。。。‘) return ‘<%s:%s>‘ %(self.name,self.age) obj=People(‘辣白菜同学‘,18) print(obj) #打印显示是 内存地址 如果要显示<‘辣白菜同学‘：18> obj1=int(10) print(obj1) #10 内置的类型做处理了 #__del__:在清理对象时触发，会先执行该方法 class People: def __init__(self,name,age): self.name=name self.age=age #self.x占用的是操作系统的内存资源 def __del__(self): #删除对象之前进行回收资源， # print(‘run.....‘) # 发起系统调用，告诉操作系统回收相关的系统资源 self.x.close() obj = People(‘辣白菜同学‘, 18) del obj #obj.__del__() 平时几乎不会用到这个方法
应用场景：
应用程序结束后，操作系统不会清理内存空间，所以才需要内部自动触发，告诉操作系统，回收相关的系统资源
一切都源自于一句话：一切皆为对象
元类就是用来实例化产生类的类 关系：元类---实例化---->类（People）---实例化---->对象（obj）
class People: def __init__(self,name,age): self.name=name self.age=age def say(self): print(‘%s:%s‘ %(self.name,self.name)) print(People.__dict__) #如何得到对象 #obj=调用类() obj=People(‘egon‘,18) print(type(obj)) #如果说类也是对象 #People=调用类(。。。) #查看内置的元类： #1、type是内置的元类 #2、我们用class关键字定义的所有的类以及内置的类都是由元类type实例化产生 print(type(People)) print(type(int))
# 类有三大特征：类名、类的基类、执行类体代码拿到类的名称空间 # 1、类名 class_name="People" # 2、类的基类 class_bases=(object,) # 3、执行类体代码拿到类的名称空间 class_dic={} class_body=""" def __init__(self,name,age): self.name=name self.age=age def say(self): print(‘%s:%s‘ %(self.name,self.name)) """ exec(class_body,{},class_dic) # print(class_dic) # 4、调用元类 print(type(class_name,class_bases,class_dic)) #得到一个类 # People=type(class_name,class_bases,class_dic) #产生一个类，自己造一个类，也就是class关键字做的事)
class Mymeta(type): # 只有继承了type类的类才是元类 # 传过来4个参数，空对象,"People",(object,),{...} def __init__(self,x,y,z): #xyz此处表示变量名，可以是class_name、class_bases、class_dic # print(‘run....‘) # print(self) # print(x) # print(y) # print(z) print(self.__bases__) #object if not x.istitle(): raise NameError(‘类名的首字母必须大写啊！！！‘) def __new__(cls, *args, **kwargs):#自定义new方法，当前所在的类，调用类所传入的参数 print(‘run111.....‘) #造Mymeta的对象 print(cls,args,kwargs) # return super().__new__(cls,*args, **kwargs) return type.__new__(cls,*args, **kwargs) #两种都可 # People=Mymeta("People",(object,),{...}) # 调用Mymeta发生三件事 # 1、先造一个空对象=>People，调用类内的__new__方法，初始化属性 # 2、调用Mymeta这个类内的__init__方法，完成初始化对象的操作（调用init方法之前先执行其他的） # 3、返回初始化好的对象 class People(metaclass=Mymeta): #定义类名小写就会报错 def __init__(self,name,age): self.name=name self.age=age def say(self): print(‘%s:%s‘ %(self.name,self.name))
class Mymeta(type): #只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类 def __init__(self,class_name,class_bases,class_dic): # print(self) #<class ‘__main__.StanfordTeacher‘> # print(class_bases) #(<class ‘object‘>,) # print(class_dic) #{‘__module__‘: ‘__main__‘, ‘__qualname__‘: ‘StanfordTeacher‘, ‘school‘: ‘Stanford‘, ‘__init__‘: <function StanfordTeacher.__init__ at 0x102b95ae8>, ‘say‘: <function StanfordTeacher.say at 0x10621c6a8>} super(Mymeta, self).__init__(class_name, class_bases, class_dic) # 重用父类的功能 # if class_name.islower(): # raise TypeError(‘类名%s请修改为驼峰体‘ %class_name) if ‘__doc__‘ not in class_dic or len(class_dic[‘__doc__‘].strip(‘ \n‘)) == 0: raise TypeError(‘类中必须有文档注释，并且文档注释不能为空‘) # StanfordTeacher=Mymeta(‘StanfordTeacher‘,(object),{...}) class StanfordTeacher(object,metaclass=Mymeta): """ 类StanfordTeacher的文档注释 """ school=‘Stanford‘ def __init__(self,name,age): self.name=name self.age=age def say(self): print(‘%s says welcome to the Stanford to learn Python‘ %self.name) # 强调：只要是调用类，那么会一次调用 # 1.类内的__new__ # 2.类内的__init__
class Foo: def __call__(self, *args, **kwargs): print(self) print(args) print(kwargs) obj=Foo() #1、要想让obj这个对象变成一个可调用的对象，需要在该对象的类中定义一个方法__call__方法，该方法会在调用对象时自动触发 #2、调用obj的返回值就是__call__方法的返回值 res=obj(1,2,3,x=1,y=2)
class Mymeta(type): # 只有继承了type类的类才是元类 def __call__(self, *args, **kwargs): # 1、Mymeta.__call__函数内会先调用People内的__new__ people_obj=self.__new__(self) # 2、Mymeta.__call__函数内会调用People内的__init__ self.__init__(people_obj,*args, **kwargs) # print(‘people对象的属性：‘,people_obj.__dict__) people_obj.__dict__[‘xxxxx‘]=11111 # 3、Mymeta.__call__函数内会返回一个初始化好的对象 return people_obj # 类的产生： # People=Mymeta()=》type.__call__=>干了3件事 # 1、type.__call__函数内会先调用Mymeta内的__new__ # 2、type.__call__函数内会调用Mymeta内的__init__ # 3、type.__call__函数内会返回一个初始化好的对象 class People(metaclass=Mymeta): def __init__(self,name,age): self.name=name self.age=age def say(self): print(‘%s:%s‘ %(self.name,self.name)) def __new__(cls, *args, **kwargs): # 产生真正的对象 return object.__new__(cls) # 类的调用： # obj=People(‘egon‘,18) =》Mymeta.__call__=》干了3件事 # 1、Mymeta.__call__函数内会先调用People内的__new__ # 2、Mymeta.__call__函数内会调用People内的__init__ # 3、Mymeta.__call__函数内会返回一个初始化好的对象 obj1=People(‘egon‘,18) obj2=People(‘egon‘,18) # print(obj) print(obj1.__dict__) print(obj2.__dict__)
# 属性查找的原则：对象-》类-》父类 # 切记：父类 不是 元类 class Mymeta(type): #自定义一个元类 n=444 def __call__(self, *args, **kwargs): #self=<class ‘__main__.StanfordTeacher‘> obj=self.__new__(self) # StanfordTeacher.__new__ # obj=object.__new__(self) print(self.__new__ is object.__new__) #True self.__init__(obj,*args,**kwargs) return obj class Bar(object): # n=333 # def __new__(cls, *args, **kwargs): # print(‘Bar.__new__‘) pass class Foo(Bar): # n=222 # def __new__(cls, *args, **kwargs): # print(‘Foo.__new__‘) pass class StanfordTeacher(Foo,metaclass=Mymeta): # n=111 def __init__(self,name,age): self.name=name self.age=age obj=StanfordTeacher(‘lili‘,18) print(obj.__dict__) # print(obj.n) # print(StanfordTeacher.n)
标签：过多 地址 str people teacher -- 上传 一个 __new__
原文地址：https://www.cnblogs.com/dingbei/p/12706602.html
