python3高级知识元类(metaclass)深度剖析

class MyType(type):
def __init__(self, cls_name, bases, cls_attr):
print("Mytype __init__", cls_name, bases)
def __new__(cls, cls_name, bases, cls_attr):
print("Mytype __new__", cls_name, bases)
return super(MyType, cls).__new__(cls, cls_name, bases, cls_attr)
def __call__(self, *args, **kwargs):
print('Mytype __call__')
class Foo(metaclass=MyType):
def __init__(self, name):
print('this is __init__')
self.name = name
def __new__(cls, *args, **kwargs):
print('this is __new__')
return object.__new__(cls)
def __call__(self, *args, **kwargs):
print("this is __call__")
print("before -------")
obj = Foo('wd') # 实例化
print("after -------")
print(obj)
结果：
Mytype __new__ Foo ()
Mytype __init__ Foo ()
before -------
Mytype __call__
after -------
None

你会发现，当Foo实例化时候执行了元类的__call__,你从python的一切皆对象的方式来看，一切都是顺理成章的，因为这里的Foo其实是元类的对象，对象+()执行元类的__call__方法。请注意，在Foo进行实例化时候返回的对象是None，这是因为__call__方法返回的就是None，所以在没有必要的前提下最好不要随意重写元类的__call__方法，这会影响到类的实例化。__call__方法在元类中作用是控制类生成时的调用过程。

通过__call__方法我们能得出结果就是__call__方法返回什么，我们最后得到的实例就是什么。还是刚才栗子，我们让Foo实例化以后变成一个字符串：

class MyType(type):
def __init__(self, cls_name, bases, cls_attr):
print("Mytype __init__", cls_name, bases)
def __new__(cls, cls_name, bases, cls_attr):
return super(MyType, cls).__new__(cls, cls_name, bases, cls_attr)
def __call__(self, *args, **kwargs):
return 'this is wd'
class Foo(metaclass=MyType):
def __init__(self, name):
print('this is __init__')
self.name = name
def __new__(cls, *args, **kwargs):
print('this is __new__')
return object.__new__(cls)
def __call__(self, *args, **kwargs):
print("this is __call__")
obj = Foo('wd') # 实例化
print(type(obj),obj)
结果：
Mytype __init__ Foo ()
this is wd

既然__call__方法返回什么，我们实例化生成的对象就是什么，那么在正常的流程是返回的是Foo的对象，而Foo的对象是由Foo的__new__和Foo的__init__生成的，所以在__call__方法的内部又有先后调用了Foo类的__new__方法和__init__方法，如果我们重写元类的__call__方法，则应该调用对象的__new__和__init__，如下：

class MyType(type):
def __init__(self, cls_name, bases, cls_attr):
print("Mytype __init__", cls_name, bases)
def __new__(cls, cls_name, bases, cls_attr):
return super(MyType, cls).__new__(cls, cls_name, bases, cls_attr)
def __call__(self, *args, **kwargs):
print("Mytype __call__", )
obj = self.__new__(self)
print(self, obj)
self.__init__(obj, *args, **kwargs)
return obj
class Foo(metaclass=MyType):
def __init__(self, name):
self.name = name
def __new__(cls, *args, **kwargs):
return object.__new__(cls)
obj = Foo('wd') # 实例化
print(obj.name)
结果：
Mytype __init__ Foo ()
Mytype __call__
<__main__.Foo object at 0x1100c9dd8>
wd

同样，当函数作为元类时候，metaclass关键字会调用其对应的函数生成类，如果这个函数返回的不是类，而是其他的对象，那么使用该函数定义的类就得到的就是该对象，这也就是为什么我说使用函数作为元类时候，需要有type功能，一个简单的示例：

def func(cls_name, bases, dict_attr):
return 'this is wd'
class Foo(metaclass=func):
def __init__(self, name):
self.name = name
def __new__(cls, *args, **kwargs):
return object.__new__(cls)
print(Foo, "|", type(Foo)) # 结果：this is wd |
obj=Foo('wd') #报错

结语

现在说python一切皆对象可以说非常到位了，因为它们要不是类的对象，要不就是元类的对象，除了type。再者元类本身其实是复杂的，只是我们在对这元类生成类的这一过程做了深度的分析，所以在我们编写的程序中可能极少会用到元类，除非有特殊的需求，比如动态的生成类、修改类的一些东西等，当然你想让你的代码看来“复杂”也可以尝试使用。但是在有些情况下(如在文章中提到的几个场景中)使用元类能更巧妙的解决很多问题，不仅如此你会发现元类在很多开源框架中也有使用，例如django、flask，你也可以借鉴其中的场景对自己的程序进行优化改进。