标签：strip typeerror 继承 return 补充 推导 oldboy pre ems
元类
1.什么是元类：
源自一句话，在python中，一切皆对象，而对象都是由类实例化得到的
class OldboyTeacher: def __init__(self,name,age,sex): self.name=name self.age=age self.sex=sex def score(self): print(‘%s is scoring‘%self.name) tea1=OldboyTeacher(‘yb‘,18,‘male‘) print(type(tea1)) print(type(OldboyTeacher))
输出结果：
<class ‘__main__.OldboyTeacher‘> <class ‘type‘>
关系：
1.调用元类--------》自定义的类
2.调用自定义的类-----------》自定义的对象
class关键字创建自定义类的底层的工作原理，分为四步
1.先拿到类名：‘OldboyTeacher’
2.再拿到类的基类们：(object,)
3.然后拿到类的名称空间 （执行类体代码，将产生的名字放到类的名称空间也就是一个字典里，补充exec）
4.调用元类实例化得到自定义的类： OldboyTeacher=type(‘OldboyTeacher‘,(object,),{...})
class OldboyTeacher: #OldboyTeacher=type(...) school = ‘Oldboy‘ def __init__(self,name,age,sex): self.name=name self.age=age self.sex=sex def score(self): print(‘%s is scoring‘ %self.name) print(OldboyTeacher)
自定义的三个关键组成部分：
1.类名
2.类的基类们
3.类的名称空间
不依赖class关键字创建一个自定义类
# 1. 拿到类名 class_name=‘OldboyTeacher‘ #2. 拿到类的基类们:(object,) class_bases=(object,) #3. 拿到类的名称空间 class_dic={} class_body=""" school = ‘Oldboy‘ def __init__(self,name,age,sex): self.name=name self.age=age self.sex=sex def score(self): print(‘%s is scoring‘ %self.name) """ exec(class_body,{},class_dic) print(class_dic) #4. 调用type得到自定义的类 OldboyTeacher=type(class_name,class_bases,class_dic) print(OldboyTeacher) # print(OldboyTeacher.school) # print(OldboyTeacher.score) tea1=OldboyTeacher(‘egon‘,18,‘male‘) print(tea1.__dict__)
自定义元类来控制类的产生
模板 class Mymeta(type): #但凡继承了type的类才能称之为自定义的元类,否则就是只是一个普通的类 def __init__(self,class_name,class_bases,class_dic): print(self) print(class_name) print(class_bases) print(class_dic) class OldboyTeacher(object,metaclass=Mymeta): #OldboyTeacher=Mymeta(‘OldboyTeacher‘,(object,),{...}) school = ‘Oldboy‘ def __init__(self,name,age,sex): self.name=name self.age=age self.sex=sex def score(self): print(‘%s is scoring‘ %self.name)
控类的产生
1.类名必须用驼峰体
2.类体必须有文档注释，且文档注释不能为空
class Mymeta(type): #但凡继承了type的类才能称之为自定义的元类,否则就是只是一个普通的类 def __init__(self,class_name,class_bases,class_dic): if class_name.islower(): raise TypeError(‘类名必须使用驼峰体‘) doc=class_dic.get(‘__doc__‘) if doc is None or len(doc) == 0 or len(doc.strip(‘\n ‘)) == 0: raise TypeError(‘类体中必须有文档注释,且文档注释不能为空‘) class OldboyTeacher(object,metaclass=Mymeta): #OldboyTeacher=Mymeta(‘OldboyTeacher‘,(object,),{...}) school = ‘Oldboy‘ def __init__(self,name,age,sex): self.name=name self.age=age self.sex=sex def score(self): print(‘%s is scoring‘ %self.name) print(OldboyTeacher.__dict__)
自定义元类来控制类调用的过程
class Mymeta(type): #但凡继承了type的类才能称之为自定义的元类,否则就是只是一个普通的类 pass class OldboyTeacher(object): #OldboyTeacher=Mymeta(‘OldboyTeacher‘,(object,),{...}) school = ‘Oldboy‘ def __init__(self,name,age,sex): self.name=name self.age=age self.sex=sex def score(self): print(‘%s is scoring‘ %self.name) def __call__(self, *args, **kwargs): print(self) print(args) print(kwargs) tea1=OldboyTeacher(‘egon‘,18,‘male‘) tea1(1,2,a=1,b=2) #__call__(tea1,(1,2).{‘a‘:1,‘b‘:2})
总结：对象之所以可以调用，是因为对象的类中有一个函数__call__
推导：如果一切皆对象，那么OldboyTeacher也是一个对象，该对象之所以可以调用，肯定是这个对象的类中也定义了一个函数__call__
class Mymeta(type): #但凡继承了type的类才能称之为自定义的元类,否则就是只是一个普通的类 def __call__(self, *args, **kwargs): #self=OldboyTeacher这个类,args=(‘egon‘,18,‘male‘),kwargs={} # 1. 先产生一个空对象 tea_obj=self.__new__(self) #tea_obj是OldboyTeacher这个类的对象 # 2. 执行__init__方法,完成对象的初始属性操作 self.__init__(tea_obj,*args,**kwargs) # 3. 返回初始化好的那个对象 return tea_obj class OldboyTeacher(object,metaclass=Mymeta): #OldboyTeacher=Mymeta(‘OldboyTeacher‘,(object,),{...}) school = ‘Oldboy‘ # tea_obj,‘egon‘,18,‘male‘ def __init__(self,name,age,sex): self.name=name self.age=age self.sex=sex def score(self): print(‘%s is scoring‘ %self.name) tea1=OldboyTeacher(‘egon‘,18,‘male‘) # 会触发OldboyTeacher的类(即元类)中的__call__函数 print(tea1) print(tea1.__dict__)
实例化OldboyTeacher,或者说调用OldboyTeacher会
1.先产生一个空对象
2.执行__init__方法，完成对象的初始属性操作
3.返回初始化好的那个对象
推导：调用OldboyTeacher(...)就是在调用OldboyTeacher的类中的__call__，那么在该__call__中就需要做上述三件事
自定义元类来控制类的调用（即类的实例化过程）
class Mymeta(type): #但凡继承了type的类才能称之为自定义的元类,否则就是只是一个普通的类 def __call__(self, *args, **kwargs): #self=OldboyTeacher这个类,args=(‘egon‘,18,‘male‘),kwargs={} # 1. 先产生一个空对象 tea_obj=self.__new__(self) #tea_obj是OldboyTeacher这个类的对象 # 2. 执行__init__方法,完成对象的初始属性操作 self.__init__(tea_obj,*args,**kwargs) # print(tea_obj.__dict__) tea_obj.__dict__={(‘_%s__%s‘ %(self.__name__,k)):v for k,v in tea_obj.__dict__.items()} # 3. 返回初始化好的那个对象 return tea_obj class OldboyTeacher(object,metaclass=Mymeta): #OldboyTeacher=Mymeta(‘OldboyTeacher‘,(object,),{...}) school = ‘Oldboy‘ def __init__(self,name,age,sex): self.name=name self.age=age self.sex=sex def score(self): print(‘%s is scoring‘ %self.name) tea1=OldboyTeacher(‘egon‘,18,‘male‘) # 会触发OldboyTeacher的类(即元类)中的__call__函数 # print(tea1) print(tea1.__dict__)
属性查找
class Mymeta(type): # 但凡继承了type的类才能称之为自定义的元类,否则就是只是一个普通的类 # n=444 def __call__(self, *args, **kwargs): #self=OldboyTeacher这个类 # 1. 先产生一个空对象 tea_obj = self.__new__(self) # tea_obj是OldboyTeacher这个类的对象 # print(self.__new__ is object.__new__) # tea_obj=object.__new__(self) # 2. 执行__init__方法,完成对象的初始属性操作 self.__init__(tea_obj, *args, **kwargs) # 3. 返回初始化好的那个对象 return tea_obj class Bar: # n = 33 pass class Foo(Bar): # n = 222 pass class OldboyTeacher(Foo, metaclass=Mymeta): # OldboyTeacher=Mymeta(‘OldboyTeacher‘,(object,),{...}) # n = 111 school = ‘Oldboy‘ def __init__(self, name, age, sex): self.name = name #None.name=‘egon‘ self.age = age self.sex = sex def score(self): print(‘%s is scoring‘ % self.name) def __new__(cls, *args, **kwargs): # print(‘=====>‘) return super().__new__(cls) tea1 = OldboyTeacher(‘egon‘, 18, ‘male‘) # print(tea1) print(tea1.__dict__) # print(OldboyTeacher.n) # print(object.__new__)
标签：strip typeerror 继承 return 补充 推导 oldboy pre ems
原文地址：https://www.cnblogs.com/sanqiansi/p/9541177.html
