一 元类介绍
1.1 引入
一切都源自于一句话：一切皆为对象
1.2 什么是元类
元类就是用来实例化产生类的类，举个例子
class People:
def __init__(self,name,age):
self.name=name
self.age=age
def say(self):
print(‘%s:%s‘ %(self.name,self.name))
obj = People(‘aaa‘,18)
所有的对象都是实例化或者说调用类而得到的（调用类的过程称为类的实例化），比如对象obj是调用类People得到的
如果一切皆为对象，那么类People本质也是一个对象，既然所有的对象都是调用类得到的，那么People必然也是调用了一个类得到的，这个类称为元类
于是我们可以推倒出关系：元类---实例化---->类（People）---实例化---->对象（obj）
1.3 查看内置的元类
print(type(People)) # 结果为<class ‘type‘>，证明是调用了type这个元类而产生的People，即默认的元类为type
因此type是内置的元类，我们用class关键字定义的所有的类以及内置的类都是由元类type实例化产生
二 class关键字创建类的流程分析
class关键字在帮我们创建类时，必然帮我们调用了元类People=type(...)，那调用type时传入的参数是什么呢？必然是类的关键组成部分，一个类有三大组成部分，分别是
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)) """ class_dic={}
调用type时会依次传入以上三个参数
综上，class关键字帮我们创建一个类应该细分为以下四个过程：
‘‘‘ 1拿到类名 2拿到基类 3执行类体代码，拿到类的名称空间 4调用元类，传入参数，得到类 ‘‘‘ #因此我们只要有上面的3个参数我们哪怕不用class也能通过以下方式创建出一个类 People = type(class_name,class_bases,class_dic)
了解：exec的用法
#exec：三个参数 #参数一：包含一系列python代码的字符串 #参数二：全局作用域（字典形式），如果不指定，默认为globals() #参数三：局部作用域（字典形式），如果不指定，默认为locals() #可以把exec命令的执行当成是一个函数的执行，会将执行期间产生的名字存放于局部名称空间中 g={ ‘x‘:1, ‘y‘:2 } l={} exec(‘‘‘ global x,z x=100 z=200 m=300 ‘‘‘,g,l) print(g) #{‘x‘: 100, ‘y‘: 2,‘z‘:200,......} print(l) #{‘m‘: 300}
三 自定义元类控制类的创建
3.1 初步创建自定义元类
一个类没有声明自己的元类，默认他的元类就是type，除了使用内置元类type，我们也可以通过继承type来自定义元类，然后使用metaclass关键字参数为一个类指定元类
class Mymeta(type):# 只有继承了type类的类才是元类
pass
# People=Mymeta("People",(object,),{...})
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): super().__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(‘类中必须有文档注释，并且文档注释不能为空‘) # People=Mymeta(‘People‘,(object),{...}) class StanfordTeacher(metaclass=Mymeta): """ People """ 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) 案例用自定义元类控制类必须要有注释和类名驼峰
3.2 __new__方法
该方法会在__init__之前运行，__new__方法必须要有返回造好的对象，在这基础上你可以自己加一些方法。
class Mymeta(type):# 只有继承了type类的类才是元类
def __init__(self,name,bases,dic):
print(‘run22222222222....‘)
# 当前所在的类，调用类时所传入的参数
def __new__(cls, *args, **kwargs):
print(‘run1111111111.....‘)
return super().__new__(cls,*args, **kwargs)
# People=Mymeta("People",(object,),{...})
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))
‘‘‘
强调：
只要是调用类，那么会一次调用
1、类内的__new__
2、类内的__init__
‘‘‘
调用Mymeta发生三件事，调用Mymeta就是type.__call__
1、先造一个空对象=>People,调用Mymeta类内的__new__方法
2、调用Mymeta这个类内的__init__方法，完成初始化对象的操作
3、返回初始化好的对象
四 自定义元类控制类的调用
__call__
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)
由上例得知，调用一个对象，就是触发对象所在类中的__call__方法的执行，如果把People也当做一个对象，那么在People这个对象的类中也必然存在一个__call__方法
class Mymeta(type): #只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类
def __call__(self, *args, **kwargs):
print(self)
print(args)
print(kwargs)
return 123
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))
obj = People(‘aa‘,18)
print(obj)
调用__call__方法会发生三件事
1、产生一个空对象obj
2、调用__init__方法初始化对象obj
3、返回初始化好的obj
对应着，Mymeta中的__call__方法也应该做这三件事
class Mymeta(type): #只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类
def __call__(self, *args, **kwargs): #self=<class ‘__main__.StanfordTeacher‘>
#1、调用__new__产生一个空对象obj
obj=self.__new__(self) # 此处的self是类OldoyTeacher，必须传参，代表创建一个StanfordTeacher的对象obj
#2、调用__init__初始化空对象obj
self.__init__(obj,*args,**kwargs)
#3、返回初始化好的对象obj
return obj
上例的__call__相当于一个模板，我们可以在该基础上改写__call__的逻辑从而控制调用People的过程
五 属性查找
属性查找的原则：对象->类->父类
切记：父类 不是 元类
于是属性查找应该分成两层，一层是对象层（基于c3算法的MRO）的查找，另外一个层则是类层（即元类层）的查找 
正常情况下我们查找都是查找到object就结束了，只有类.属性（方法）时才会找到元类
最后一点：我们在元类的__call__中也可以用object.__new__(self)去造对象
我们在元类的__call__中也可以用object.__new__(self)去造对象
但我们还是推荐在__call__中使用self.__new__(self)去创造空对象，因为这种方式会检索三个类StanfordTeacher->Foo->Bar,而object.__new__则是直接跨过了他们三个
但我们还是推荐在__call__中使用self.__new__(self)去创造空对象，因为这种方式会检索三个类People->Foo->Bar,而object.__new__则是直接跨过了他们三个