面向对象_元类

元类　

　　python中一切皆为对象，所有的对象都是实例化或者调用类而得到的（调用类的过程称为类的实例化）

class MiddleSchool(object):
    school = 'NO1'

    def __init__(self,name,age):
        self.name = name
        self.age = age

    def teach(self):
        print('%s says welcome to MiddleSchooli'%self.name)

print(type(MiddleSchool))
#<class 'type'>

　　如果所有的对象都是调用类得到的，那么MiddleSchool必然也是调用了一个类得到的，这个类称为元类。MiddleSchool的类型为type，证明是调用了type这个元类而产生的MiddleSchool,即默认的元类为type

class关键字

　　我们用class关键字定义的类本身也是一个对象，负责产生该对象的类称为元类（元类可以简称为类的类），内置的元类为type

　　class关键字在创建类时，调用type时传入的参数有三部分

1.类名 class_name='MiddleSchool'
2.基类们 class_bases = (object,)
3.类的空间名称class_dic,类的名称空间是执行类体代码而得到的

　　因此class关键字创建类的过程如下

1.获取类名
2.获取基类们
3.执行类体代码，获取类的名称空间

class_body = '''

school = 'NO1'

def __init__(self,name,age):
    self.name = name
    self.age = age

def teach(self):
    print('%s says welcome to MiddleSchool'%self.name)
'''

class_dic = {}
exec(class_body,{},class_dic)
print(class_dic)

4.调用元类得到类MiddleSchool=type(class_name,class_bases,class_dic)

g={
    'x':1,
    'y':2
}
l={}

exec('''
global x,z
x=100
z=200
m=300
''',g,l)
print(g)
print(l)

'''
exec的用法
参数一:包含一系列python代码的字符串
参数二:全局作用域(字典形式),如果不指定，默认为globals()
参数三：局部作用域（字典形式），如果不指定，默认为locals()
可以把exec命令的执行当成是一个函数的执行，会将执行期间产生的名字存放于局部名称空间中
'''

自定义元类

　　一个类没有声明自己的元类，默认它的元类就是type，除了使用内置元类type,我们也可以通过继承type来自定义元类，然后使用metaclass关键字参数为一个类指定元类

class Mymeta(type): #只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类
    pass

class MiddleSchool(object,metaclass=Mymeta): #MiddleSchool=Mymeta('MiddleSchool',{object},{...})
    school = 'NO1'

    def __init__(self,name,age):
        self.name = name
        self.age = age

    def teach(self):
        print('%s says welcome to MiddleSchool'%self.name)

　　类的产生过程其实就是元类的调用过程，即MiddleSchool=Mymeta('MiddleSchool',{object},{...})，调用Mymeta会先生成一个空对象MiddleSchool，然后连同调用Mymeta括号内的参数一同传递给Mymeta下的__init__方法，完成初始化，于是我们可以补充Mymeta类定义

class Mymeta(type): #只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类
    def __init__(self,class_name,class_bases,class_dic):
        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('类中必须有文档注释，并且文档注释不能为空')
class MiddleSchool(object,metaclass=Mymeta):
    '''
    类MiddleSchool的文档注释
    '''
    school = 'NO1'

    def __init__(self,name,age):
        self.name = name
        self.age = age

    def teach(self):
        print('%s says welcome to MiddleSchool'%self.name)

对象的调用

class Foo:
    def __call__(self, *args, **kwargs):
        print(self)
        print(args)
        print(kwargs)

obj=Foo()  #调用类Foo生成对象obj
res=obj(1,2,3,x=1,y=2)  #调用对象obj(...),实际上是调用Foo.__call__方法

　　由上例可以看出调用一个对象，就是调用对象所在的类的__call__方法的执行，如果把MiddleSchool也当作一个对象，那么在MiddleSchool这个对象所属的类中也必然存在一个__call__方法

class Mymeta(type):
    def __call__(self, *args, **kwargs):
        print(self)
        print(args)
        print(kwargs)
        return 123

class MiddleSchool(object,metaclass=Mymeta):

    school = 'NO1'

    def __init__(self,name,age):
        self.name = name
        self.age = age

    def teach(self):
        print('%s says welcome to MiddleSchool'%self.name)

t1 = MiddleSchool('lary',18) #调用MiddleSchool就是在调用MiddleSchool所属的类Mymeta中的__call__方法
print(t1)       #返回值即为__call__的返回值 

　　调用t1=MiddleSchool(‘lary’,18)会完成三个步骤：产生一个空对象-调用__init__方法初始化对象obj-返回初始化后的obj。由此MiddleSchool所属类Meta中的__call__方法也应该完成这三个步骤

class Mymeta(type):
    def __call__(self, *args, **kwargs):
        obj = self.__new__(self)      #调用__new__产生一个空对象obj，此处必须传参，代表创建一个MiddleSchool的对象obj
        self.__init__(obj,*args,**kwargs) #调用__init__初始化空对象obj
        return obj  #返回初始化好的对象obj

class MiddleSchool(object,metaclass=Mymeta):

    school = 'NO1'

    def __init__(self,name,age):
        self.name = name
        self.age = age

    def teach(self):
        print('%s says welcome to MiddleSchool'%self.name)

t1 = MiddleSchool('lary',18)
print(t1.__dict__)

 　　上例的__call__相当于一个模板，我们可以在该基础上改写__call__的逻辑从而控制调用MiddleSchool的过程，比如将MiddleSchool的对象的所有属性都编程私有的

class Mymeta(type):
    def __call__(self, *args, **kwargs):
        obj = self.__new__(self)      #调用__new__产生一个空对象obj，此处必须传参，代表创建一个MiddleSchool的对象obj
        self.__init__(obj,*args,**kwargs) #调用__init__初始化空对象obj
        obj.__dict__={'_%s__%s'%(self.__name__,k):v for k,v in obj.__dict__.items()} #将属性都变成私有的
        return obj  #返回初始化好的对象obj

class MiddleSchool(object,metaclass=Mymeta):

    school = 'NO1'

    def __init__(self,name,age):
        self.name = name
        self.age = age

    def teach(self):
        print('%s says welcome to MiddleSchool'%self.name)

t1 = MiddleSchool('lary',18)
print(t1.__dict__)

属性查找

class Mymeta(type):
    n=444

    def __call__(self, *args, **kwargs):
        obj=self.__new__(self)
        self.__init__(obj,*args,**kwargs)
        return obj

class Bar(object):
    n=333

class Foo(Bar):
    n=222

class MiddleSchoold(Foo,metaclass=Mymeta):
    n=111

    school='NO1'

    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say(self):
        print('%s says welcome to school' %self.name)


print(MiddleSchoold.n) #自下而上依次注释各个类中的n=xxx，然后重新运行程序，发现n的查找顺序为MiddleSchool->Foo->Bar->object->Mymeta->type

　　属性查找应该分两层，一层是对象层（基于C3算法的MRO）查找，另外一层是类层（即元类层）的查找

　　查找顺序为：先对象层:MiddleSchool-Foo-Bar-object；然后元类层:Mymeta-type