元类

阅读目录

知识储备

知识储备

code = {
字符串
}

exec(code,global_dic,local_dic),

一、其中的字符串内，默认为局部空间如下例：

code="""
global x
x=1
y=2
"""
global_dic={'x':10000000}
local_dic={}
exec(code,global_dic,local_dic)

print(global_dic) # {'x':1,...}
print(local_dic) # {'y':2}

二、产生类有两个方式：

1、一种是用class关键字（背后原理就是调用type）直接生成类:
　　

# Chinese = type(...)
class Chinese: # class关键字自动拿到类名，括号内的基类，自动调exec函数的执行，把类体代码执行一遍得到一个字典，凑齐三要素自动赋值给type
    country = 'China'

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

    def speak(self):
        print('%s speak Chinese' % self.name)

print(Chinese) # <class '__main__.Chinese'>

　　我们用class定义的类来实例化出对象供我们使用,而内置元类type是专门来产生class定义的类

# 三大要素
# 类名，类的基类，类的局部名称空间
class_name = 'Chinese'
class_bases = (object,)
class_body = """
country = 'China'
def __init__(self,name,age,sex):
    self.name = name
    self.age = age
    self.sex = sex

def speak(self):
    print('%s speak Chinese' % self.name)
"""
class_dic = {}
exec(class_body,{},class_dic)

# 类的三大要素
# print(class_name,class_bases,class_dic)

obj = type(class_name,class_bases,class_dic)
print(obj) #<class '__main__.Chinese'>

2、另一种就是自定义元类，再由该元类定制类：

#上一步骤中，将最后type实例化的对象名修改成‘Chinese’，即可得到最终结果：
Chinese = type(class_name,class_bases,class_dic)
print(Chinese) #<class '__main__.Chinese'>
lmj = Chinese('lmj',18,'male')
print(lmj.name,lmj.age,lmj.sex) #lmj 18 male

三、__call__，调用条件下，会自动触发

class Foo:
    def __init__(self):
        pass

    def __str__(self):
        pass

    def __del__(self):
        pass

    def __call__(self, *args, **kwargs):
        print('run',args,kwargs)

obj = Foo()
obj(1,2,3,a=1,b=2,c=3) # run (1, 2, 3) {'a': 1, 'b': 2, 'c': 3}

注意：调用对象，则会自动将对象所在类的下的绑定方法__call__的执行，然后将对象本身当作第一个参数传给self，将调用对象时括号内的值传给*args与**kwargs。

 

正题：

类的类是元类（默认type），元类内也必定有__call__方法，用来在调用元类生成类的时候。

当一个类指定他的元类是自定义的（MyMeta）,那么就可以通过这个__call__方法来控制自定义化。

自定义类，控制创建类的行为：

# 自定义元类
# 控制创建类的行为
class Mymeta(type):
    # self = Foo
    def __init__(self,class_name,class_bases,class_dic):
        print(class_name) # Foo
        print(class_bases) # (<class 'object'>,)
        print(class_dic) #{'__module__': '__main__', '__qualname__': 'Foo', 'x': 1, '__init__': <function Foo.__init__ at 0x000000ABF6FD9C80>, 'f1': <function Foo.f1 at 0x000000ABF6FD9D08>}

# Foo = Mymeta('Foo',(object,),class_dic) 此处可理解为Mymeta类的实例化
class Foo(object,metaclass=Mymeta):
    x = 1
    def __init__(self,y):
        self.y = y

    def f1(self):
        print('from f1')

进阶完整版如下：

# 自定义元类
# 控制创建类的行为
class Mymeta(type):
    # self = Foo
    def __init__(self,class_name,class_bases,class_dic):
        # print(class_name)
        # print(class_bases)
        # print(class_dic)

        if not class_name.istitle():
            raise TypeError('类名首字母必须大写')
        # 重用父类__init__功能

        if not class_dic.get('__doc__'):
            raise TypeError('类中必须有文档注释')

        super(Mymeta,self).__init__(class_name,class_bases,class_dic)




# Foo = Mymeta('Foo',(object,),class_dic) 此处可理解为Mymeta类的实例化
class Foo(object,metaclass=Mymeta):
    """
    文档注释
    """
    x = 1
    def __init__(self,y):
        self.y = y

    def f1(self):
        print('from f1')

自定义类，控制调用类：

 注意：不能用init方法，因为new是在init之前执行的，当new了以后，字典就创建好了，再调init就已经改变不了字典里的内容了，如下：

因此，正确的打开方式如下，使用__new__方法：

class Mymeta(type):
    # self = Foo
    # 来控制类Foo的创建
    def __new__(self,class_name,class_bases,class_dic):
        update_attrs = {}
        for k,v in class_dic.items():
            if not callable(v) and not k.startswith('__'): # 非可调用的值（非函数）和非内置属性
                update_attrs[k.upper()] = v
            else:
                update_attrs[k] = v


        if not class_name.istitle():
            raise TypeError('类名首字母必须大写')
        # 重用父类__init__功能

        if not class_dic.get('__doc__'):
            raise TypeError('类中必须有文档注释')

        return type.__new__(self,class_name,class_bases,update_attrs)


    # 控制类Foo的调用，即控制实例化Foo的过程
    def __call__(self, *args, **kwargs): #self=Foo,args=(111,)
        # print('+++>')
        # return 123

        # 1 造空对象obj
        obj = object.__new__(self)
        # 2 调用Foo.__init__，将obj连同调用Foo括号内的参数一同传给__init__方法
        self.__init__(obj, *args, **kwargs)
        return obj

# Foo = Mymeta('Foo',(object,),class_dic) 此处可理解为Mymeta类的实例化
class Foo(object,metaclass=Mymeta):
    """
    文档注释
    """
    tag = 'China'
    x = 1
    def __init__(self,y):
        self.y = y

    def f1(self):
        print('from f1')

# 只要调用类，必产生空对象
obj = Foo(111) #此步会触发Foo对象所在类(此例即为Mymeta)之下的__call__()


print(Foo.__dict__)
"""
{'__module__': '__main__', '__doc__': '
    文档注释
    ', 'TAG': 'China', 'X': 1, '__init__': <function Foo.__init__ at 0x000000A0F3269D08>, 'f1': <function Foo.f1 at 0x000000A0F3269D90>, '__dict__': <attribute '__dict__' of 'Foo' objects>, '__weakref__': <attribute '__weakref__' of 'Foo' objects>}