Python——元类

摘取自：https://zhuanlan.zhihu.com/p/109336845

元类

什么是元类

• 一切都源于一句话——python中一切皆为对象
• 元类就是用来实例化产生类的类，简言之就是类的类
• 默认的元类为type

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

class关键字创造类People的步骤

# 类有三大特征：
# 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、调用元类
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}

如何自定义元类类控制类的产生

class MyMeta(type): # 只有继承了type类的类才是元类
    def __init__(self, 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('类中必须有文档注释，并且文档注释不能为空')
         #   当前所在的类，调用类时所传入的参数
        
    def __new__(cls, *args, **kwargs):
        # 造Mymeta的对象
        print('run1111111111.....')
        # print(cls,args,kwargs)
        # return super().__new__(cls,*args, **kwargs)
        return type.__new__(cls,*args, **kwargs)
    
# People=Mymeta("People",(object,),{...})
# 调用Mymeta发生三件事，调用Mymeta就是type.__call__
# 1、先造一个空对象=>People,调用Mymeta类内的__new__方法
# 2、调用Mymeta这个类内的__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))

# 强调：
# 只要是调用类，那么会一次调用
# 1、类内的__new__
# 2、类内的__init__

__call__

class Foo:
    def __init__(self,x,y):
        self.x=x
        self.y=y

    #            obj,1,2,3,a=4,b=5,c=6
    def __call__(self,*args,**kwargs):
        print('===>',args,kwargs)
        return 123

obj=Foo(111,222)
# print(obj) # obj.__str__
res=obj(1,2,3,a=4,b=5,c=6) # res=obj.__call__()
print(res)

'''
应用：如果想让一个对象可以加括号调用，需要在该对象的类中添加一个方法__call__
总结：
对象()->类内的__call__
类()->自定义元类内的__call__
自定义元类()->内置元类__call__
'''

自定义元类控制类的调用=》类的对象的产生

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

元类下的属性查找

• 对象查找不会找到元类

'''
属性查找应该分成两层，
一层是对象层（基于c3算法的MRO）的查找，
另外一个层则是类层（即元类层）的查找
'''
#查找顺序：
#1、先对象层：StanfordTeacher->Foo->Bar->object
#2、然后元类层：Mymeta->type

# 依据上述总结，我们来分析下元类Mymeta中__call__里的self.__new__的查找
class Mymeta(type): 
    n=444

    def __call__(self, *args, **kwargs): #self=<class'__main__.StanfordTeacher'>
        obj=self.__new__(self)
        print(self.__new__ is object.__new__) #True


class Bar(object):
    n=333

    # def __new__(cls, *args, **kwargs):
    #     print('Bar.__new__')

class Foo(Bar):
    n=222

    # def __new__(cls, *args, **kwargs):
    #     print('Foo.__new__')

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

    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)


    # def __new__(cls, *args, **kwargs):
    #     print('StanfordTeacher.__new__')

#触发StanfordTeacher的类中的__call__方法的执行，进而执行self.__new__开始查找
StanfordTeacher('lili',18) 

'''
总结，Mymeta下的__call__里的self.__new__
在StanfordTeacher、Foo、Bar里都没有找到__new__的情况下，
会去找object里的__new__，而object下默认就有一个__new__，
所以即便是之前的类均未实现__new__,也一定会在object中找到一个，
根本不会、也根本没必要再去找元类Mymeta->type中查找__new__
'''