元类

一 元类介绍

　　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))
"""

　　调用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(' 
')) == 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__中使用self.__new__(self)去创造空对象，因为这种方式会检索三个类People->Foo->Bar,而object.__new__则是直接跨过了他们三个