什么是Python的metaclass

什么是 metaclass

很多书都会翻译成元类，仅从字面理解， meta 的确是元，本源.但理解时，应该把元理解为描述数据的超越数据，事实上，metaclass 的 meta 起源于希腊词汇 meta，包含两种意思：

“Beyond”，例如技术词汇 metadata，意思是描述数据的超越数据。
“Change”，例如技术词汇 metamorphosis，意思是改变的形态。

因此可以理解为 metaclass 为描述类的超类，同时可以改变子类的形态。你可能会问了，这和元数据的定义差不多么，这种特性在编程中有什么用？

用处非常大。在没有 metaclass 的情况下，子类继承父类，父类是无法对子类执行操作的，但有了 metaclass，就可以对子类进行操作，就像装饰器那样可以动态定制和修改被装饰的类，metaclass 可以动态的定制或修改继承它的子类。

metaclass 能解决什么问题？

你已经知道了 metaclass 可以像装饰器那样定制和修改继承它的子类，这里就说下它能解决什么实际问题。比方说，在一个智能语音助手的大型项目中，我们有 1 万个语音对话场景，每一个场景都是不同团队开发的。作为智能语音助手的核心团队成员，你不可能去了解每个子场景的实现细节。

在动态配置实验不同场景时，经常是今天要实验场景 A 和 B 的配置，明天实验 B 和 C 的配置，光配置文件就有几万行量级，工作量不可谓不小。而应用这样的动态配置理念，我就可以让引擎根据我的文本配置文件，动态加载所需要的 Python 类。

如果你还不是很清楚，那么 YAML 你应该知道，它是一个家喻户晓的 Python 工具，可以方便地序列化和反序列化数据，YAMLObject 可以让它的任意子类支持序列化和反序列化（serialization & deserialization）。序列化和反序列化你应该清楚吧：

序列化：当程序运行时，所有的变量或者对象都是存储到内存中的，一旦程序调用完成，这些变量或者对象所占有的内存都会被回收。而为了实现变量和对象持久化的存储到磁盘中或在网络上进行传输，我们需要将变量或者对象转化为二进制流的方式。而将其转化为二进制流的过程就是序列化。
反序列化：而反序列化就是说程序运行的时候不能从磁盘中进行读取，需要将序列化的对象或者变量从磁盘中转移到内存中，同时也会将二进制流转换为原来的数据格式。我们把这一过程叫做反序列化。

现在你有 1 万个不同格式的 YAML 配置文件，本来你需要写 1 万个类来加载这些配置文件，有了 metaclass，你只需要实现一个 metaclass 超类，然后再实现一个子类继承这个 metaclass，就可以根据不同的配置文件自动拉取不同的类，这极大地提高了效率。

通过一个实例来理解 metaclass

按步骤写代码，看看每一步都输出了什么，这样可以彻底的理解类的创建和实例化步骤。

1,定义类

class Mymeta(type):
    def __init__(self, name, bases, dic):
        super().__init__(name, bases, dic)
        print('===>Mymeta.__init__')
        print(self.__name__)
        print(dic)
        print(self.yaml_tag,'在实例化之前这里先定义yaml_tag的属性值')

    def __new__(cls, *args, **kwargs):
        print('===>Mymeta.__new__')
        print(cls.__name__)
        return type.__new__(cls, *args, **kwargs)

    def __call__(cls, *args, **kwargs):
        print('===>Mymeta.__call__')
        obj = cls.__new__(cls)
        cls.__init__(cls, *args, **kwargs)
        return obj


class Foo(metaclass=Mymeta):
    yaml_tag = '!Foo'

    def __init__(self, name):
        print('Foo.__init__')
        self.name = name

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

2.运行程序　

在未实例化之前,运行程序自动执行metaclass类,运行结果:

===>Mymeta.__new__
Mymeta
===>Mymeta.__init__
Foo
{'__module__': '__main__', '__qualname__': 'Foo', 'yaml_tag': '!Foo', '__init__': <function Foo.__init__ at 0x00000000028FAAE8>, '__new__': <function Foo.__new__ at 0x00000000028FAB70>}
!Foo 在实例化之前这里先定义yaml_tag的属性值

3.实例化对象

　　foo = Foo('foo')

实例化运行结果:

foo = Foo('foo')

===>Mymeta.__call__
Foo.__new__
Foo.__init__

从上面的运行结果可以发现在定义 class Foo() 定义时，会依次调用 MyMeta 的 __new__ 和 __init__ 方法构建 Foo 类，然后在调用 foo = Foo() 创建类的实例对象时，才会调用 MyMeta 的 __call__ 方法来调用 Foo 类的 __new__ 和 __init__ 方法。

把上面的例子运行完之后就会明白很多了，正常情况下我们在父类中是不能对子类的属性进行操作，但是元类可以。换种方式理解：元类、装饰器、类装饰器都可以归为元编程。

Python 底层语言设计层面是如何实现 metaclass 的？

要理解 metaclass 的底层原理，你需要深入理解 Python 类型模型。下面，将分三点来说明。

第一，所有的 Python 的用户定义类，都是 type 这个类的实例。

事实上，类本身不过是一个名为 type 类的实例。在 Python 的类型世界里，type 这个类就是造物的上帝。这可以在代码中验证：

# Python 3和Python 2类似
class MyClass:
    pass

instance = MyClass()

print(type(instance))

print(type(MyClass))


#运行结果:
#>>><class '__main__.MyClass'>
#>>><class 'type'>

　　你可以看到，instance 是 MyClass 的实例，而 MyClass 不过是“上帝” type 的实例。

第二，用户自定义类，只不过是 type 类的 `call` 运算符重载

当我们定义一个类的语句结束时，真正发生的情况，是 Python 调用 type 的 __call__ 运算符。简单来说，当你定义一个类时，写成下面这样时：

class MyClass:
    data = 1

Python 真正执行的是下面这段代码：

class = type(classname, superclasses, attributedict)

这里等号右边的 type(classname, superclasses, attributedict)，就是 type 的 __call__ 运算符重载，它会进一步调用：

type.__new__(typeclass, classname, superclasses, attributedict)
type.__init__(class, classname, superclasses, attributedict)

当然，这一切都可以通过代码验证，比如

定义类方式一:

class MyClass:
    data = 1


instance = MyClass()


print(MyClass, instance)
print(instance.data)

#运行结果:

#<class '__main__.MyClass'> <__main__.MyClass object at 0x0000000002317470>

#1

定义类方式二:

MyClass = type('MyClass', (), {'data': 1})
instance = MyClass()

print(MyClass, instance)
print(instance.data)

#运行结果:

#<class '__main__.MyClass'> <__main__.MyClass object at 0x0000000002317550>
#1

两种方式运行结果一样:

由此可见，正常的 MyClass 定义，和你手工去调用 type 运算符的结果是完全一样的。

第三，metaclass 是 type 的子类，通过替换 type 的 `call` 运算符重载机制，“超越变形”正常的类

其实，理解了以上几点，我们就会明白，正是 Python 的类创建机制，给了 metaclass 大展身手的机会。

一旦你把一个类型 MyClass 的 metaclass 设置成 MyMeta，MyClass 就不再由原生的 type 创建，而是会调用 MyMeta 的 __call__ 运算符重载。

class = type(classname, superclasses, attributedict) 
# 变为了
class = MyMeta(classname, superclasses, attributedict)

用type定义类继承父类时,用到metaclass

 # Instantiate type(form) in order to use the same metaclass as form.
class= type(form)(class_name, (form,), form_class_attrs)

使用 metaclass 的风险

不过，凡事有利必有弊，尤其是 metaclass 这样“逆天”的存在。正如你所看到的那样，metaclass 会"扭曲变形"正常的 Python 类型模型。所以，如果使用不慎，对于整个代码库造成的风险是不可估量的。

换句话说，metaclass 仅仅是给小部分 Python 开发者，在开发框架层面的 Python 库时使用的。而在应用层，metaclass 往往不是很好的选择。

总结

本文从 Python 类创建的过程，帮助你理解 metaclass 的作用。

metaclass 是黑魔法，使用得当就是天堂，反之就是地狱。

posted @ 2020-07-22 07:47 JIMfan 阅读(772) 评论(0) 编辑收藏举报

刷新页面返回顶部