python 元类的创建过程

元类的一些应用,实现假的元类,扩展元类

元类与装饰器的混合应用

一切皆对象的概念.

这个概念在元类中充分体现.

一句话解释元类 : 创建某个class的过程中使用__new__ ,在__new__中你可随意修改此class

先啰嗦一些概念:

类(class)是type()创建的对象(玩c++和java可能懵比了)

要自己定义元类首先明确1个概念,

普通的class 虽然 由 type 创建,但他们并非继承type .这个概念很重要，不要搞混了

通常来说自定义元类则是type的子类, 即元类需继承type(这个是通常情况, 实际是一个可调用对象即可,只不过要符合一些协议,在另一篇文章内提到)

!!注意::元类自身并不会实例化!!! 元类是创建一个类对象的类.

!!实例创建自类， 类由type创建

type -> class -> instance

原型:

        some_class = type(classname, superclasses, attributedict) #str->类名 , 元组->父类们 , dict->命名空间词典

type也是类(type.__class__),从上面调用可以推导type自身必然实现了 __call__ .

在__call__ 运行了2行代码:

        type.__new__(typeclass, classname, superclasses, attributedict) :

       __new__ 调用完成后class已经创建完毕, 此时class的命名空间已经创建完毕,不可再次修改

 

        type.__init__(class, classname, superclasses, attributedict) ->这步可用可不用

       __init__ 的调用就像是使用装饰器来修改class

__init__是不是很熟 ,但是千万别把元类中的__init__ 和 类本身的__init__ 搞混了.

元类是用来处理类的，类是用来处理实例的,定义在元类中的__init__ 是在创建类的时候调用， 类本身的__init__ 是

类的实例创建时调用的!!!

再来个例子:

class A:
    data = 1
    def method(self):
        pass

A = type('A',(),{'data':1,'method':method,'__module__':__main__})

class A 的创建过程就是这样 , A 默认继承object , 由type创建

可以看看A.__class__ 是不是 type 的一个实例 , A.__bases__ 是不是继承object

当你在class A(metaclass = some_metaclass) 后 , 就不在调用默认的type了.

比如:

class A(metaclass = Meta):
    data = 1
    def method(self):
        pass
#Meta的第二个参数是继承的类
A = Meta('A',(),{'data':1,'method':method,'__module__':__main__})

class A 对象由Meta来创建.

一个实际的例子 , 注意了这是A类自身的创建过程， 不是class A 的实例!!!!!:

#第一个元类，基本没做任何事情，定义了自己的__new__

class MetaTest(type):                           #继承type ,
    def __new__(cls, *args, **kwargs):          #重定义了__new__,实际参数  __new__(meta, classname, supers, classdict):
        print('__new__ cls:',cls)
        print('__new__ args:',args)
        print("__new__ kwargs:",kwargs)
        return type.__new__(cls,*args,**kwargs)     #还是调用type.__new__来创建
class A(metaclass=MetaTest):
    data = 123
    def method(self):
        print('A.method')

#echo
#__new__ cls: <class '__main__.MetaTest'>
#__new__ args: ('A', (), {'__module__': '__main__', '__qualname__': 'A', 'data': 123, 'method': <function A.method at 0x022BE9C0>})
#__new__ kwargs: {}
#注意注意: 并没有创建A的实例, 这个过程是 class A 这个类对象的创建过程, 学过C++的注意了

 

前面说了 __call__ 会调用 __new__ 与 __init__ :

class MetaTest(type):                           #继承type ,
    def __new__(cls, *args, **kwargs):          #重定义了__new__
        print('__new__ cls:',cls)
        print('__new__ args:',args)
        print("__new__ kwargs:",kwargs)
        return type.__new__(cls,*args,**kwargs)     #还是调用type.__new__来创建

    #这里注意哦，这个__init__ 是类本身的初始化， 与类自身中定义的__init__ 没关系, 类自身定义的__init__ 是初始化实例的
    def __init__(cls, className, bases=None, classdict=None):   #重定义__init__
        print('__init__ :')
        #类名, 父类们, 类命名空间词典
        print(className,bases,classdict,sep='\n')

class A(metaclass=MetaTest):            #Class A 类由MetaTest 创建
    data = 123
    def __init__(self):                 #这里的__init__ 别和MetaTest中的搞混了,这个__init__是在创建实例时调用的
        print('***A.__init__')
    def method(self):
        print('A.method')

#echo
#__new__ cls: <class '__main__.MetaTest'>
#__new__ args: ('A', (), {'__module__': '__main__', '__qualname__': 'A', 'data': 123, 'method': <function A.method at 0x022BE9C0>})
#__new__ kwargs: {}
#__init__ :
#A
#()
#{'__module__': '__main__', '__qualname__': 'A', 'data': 123, '__init__': <function A.__init__ at 0x0205EA08>, 'method': <function A.method at 0x0205E9C0>}