python 学习-打开潘多拉的魔盒-元类（metaclass）学习

前言

在 Python 里面大家都比较熟悉了，通过 class 关键字创建一个类，这是通过硬编码来实现的。
那么如何动态创建一个类呢，如果给一批数据，让它动态生成一个类？

学习警告：不要轻易打开潘多拉的魔盒，潘多拉出于好奇打开一个魔盒, 释放出人世间的所有邪恶:贪婪、虚无、诽谤、嫉妒、痛苦等等,当她再盖上盒子时,只剩下希望在里面。
不要轻易去开启python的 黑魔法--元类（metaclass）学习，可能会有2个极端

• 打开之后，如果你能驾驭，会发现无所不能，真正掌握了面向对象的精髓，可以无所不能实现你想要的任何功能。
• 如果你出于好奇是尝试它，恶魔被释放出来，可能会让你越来越痛苦，最后可能会怀疑自己的学习能力，逐渐失去学习的乐趣。

类与实例

先来理解一个非常简单的例子

class People:
    name = "zhangsan"
    age = 22


p = People()
print(p.name)
print(p.age)

上面代码 People 是一个类， p是 People 类的实例。

接着用 type 查看对象

print(type(p))  # <class '__main__.People'>
print(type(People))  # <class 'type'>

p 是 People 类的实例
People 是一个类，它是 type 的实例，也就是说 People 类是 type 创建的一个实例。
type 就是一个元类（metaclass），简单的理解，元类就是创建类的类。

再举个简单例子

• 数字123 是一个实例，它是 Int 类的实例， Int类又是type 创建的。
• 字符串“adc” 是一个实例，它是 Str 类的实例，Str 类又是 type 创建的。

# 作者-上海悠悠 wx:283340479
# blog地址 https://www.cnblogs.com/yoyoketang/

x = 123
print(type(x))    # <class 'int'>
print(type(int))  # <class 'type'>

y = "abc"
print(type(y))    # <class 'str'>
print(type(str))  # <class 'type'>

学到这里也就理解了，python是面向对象的编程语言，python里面的str, int 等class 创建的类，都是type 类创建的，type 就是一个创建类的元类（metaclass）。
str, int 等class 创建的类都是 type 类的实例。

用一个图来表示对象（obj，或叫实例）、类（class）、元类（Metaclass）的关系。

（可以这样理解：张三是人类的一个实例，人类是上帝创造的，那么人类是上帝的一个实例， type 就是 python 里面的上帝）

type 动态创建类

type 创建类的部分源码

  def __init__(cls, what, bases=None, dict=None): # known special case of type.__init__
      """
      type(object_or_name, bases, dict)
      type(object) -> the object's type
      type(name, bases, dict) -> a new type
      # (copied from class doc)
      """
      pass

基本语法如下：

type(name of the class, 
  tuple of the parent class (for inheritance, can be empty), 
  dictionary containing attributes names and values)

传三个参数：

• class 类的名称， 字符串类型
• bases 是需要继承的类，默认继承object,可以为空，类型传元组
• dict 字典类型，传类的属性和方法

接着我们用 type 动态创建一个类

# 作者-上海悠悠 wx:283340479
# blog地址 https://www.cnblogs.com/yoyoketang/


# 通过 type 创建一个猫类
Cat = type("Cat", (object, ), {"name": "hello kitty", "age": 2})
c = Cat()
print(c.name)
print(c.age)
print(type(c))   # <class '__main__.Cat'>
print(type(Cat)) # <class 'type'>

Cat 就是 type 创建的一个类，等价于自己写的class Cat， 它是type 类的实例
c 是 Cat 类的实例。

学到这，就是掌握了使用 type 动态创建类的入门学习了~

自定义元类（metaclass）

如果想把一个类设计成 MetaClass 元类，其必须符合以下条件：

• 必须显式继承自 type 类；
• 类中需要定义并实现 __new__() 方法，该方法一定要返回该类的一个实例对象，因为在使用元类创建类时，该 __new__() 方法会自动被执行，用来修改新建的类。

# 作者-上海悠悠 wx:283340479
# blog地址 https://www.cnblogs.com/yoyoketang/


class DemoMetaClass(type):
    def __init__(cls, what, bases=None, dict=None):
        """
        初始化，四个参数
        """
        print("metaclass 创建类初始化。。。。")
        super().__init__(what, bases, dict)

    def __new__(cls, name, bases, attrs):
        """
         创建类，四个参数
           cls 代表动态修改的类
           name 代表动态修改的类名
           bases 代表被动态修改的类的所有父类
           attr 代表被动态修改的类的所有属性、方法组成的字典
        """
        # 动态为该类添加一个name属性
        attrs['name'] = "zhangsan"
        attrs['age'] = lambda x: 20
        return super().__new__(cls, name, bases, attrs)


# 定义一个类，指定metaclass 元类创建，而不是由 type 创建
class NewDemo(object, metaclass=DemoMetaClass):
    pass

以上代码直接执行，会看到打印结果

metaclass 创建类初始化。。。。

上面代码中 DemoMetaClass 是一个类， 该类继承自 type 类，并且内部实现了 __new__() 方法，因此 DemoMetaClass 是一个元类。
NewDemo 类不再由默认的type 创建了，而是由自己写的 DemoMetaClass 来创建。

当使用class NewDemo 创建类时，DemoMetaClass 元类就会触发__init__ 初始化 和 __new__ 创建类。

同样的道理，当我们写一个类， 继承了NewDemo （它由DemoMetaClass 创建）

class Hello(NewDemo):
    pass

它也会触发元类 __new__ 创建类 和 __init__ 初始化。

还可以由 type 动态创建类

World = type("World", (NewDemo, ), {})
w = World()
print(w.name)     # zhangsan
print(w.age())    # 20

它也会触发元类 __new__ 创建类 和 __init__ 初始化 。
学到这，大家会发现目前自己创建的元类已经改变了python 创建类的默认操作，潘多拉的魔盒被你悄悄打开了~~

掌握 __init__ 和 __new__

如果创建的class 类里面也有__init__ 和 __new__， 看下执行过程是怎样的

# 作者-上海悠悠 wx:283340479
# blog地址 https://www.cnblogs.com/yoyoketang/


class DemoMetaClass(type):
    def __init__(cls, what, bases=None, dict=None):
        """
        初始化，四个参数
        """
        print("metaclass 创建类初始化。。。。")
        super().__init__(what, bases, dict)

    def __new__(cls, name, bases, attrs):
        """
         创建类，四个参数
           cls 代表动态修改的类
           name 代表动态修改的类名
           bases 代表被动态修改的类的所有父类
           attr 代表被动态修改的类的所有属性、方法组成的字典
        """
        # 动态为该类添加一个name属性
        attrs['name'] = "zhangsan"
        attrs['age'] = lambda x: 20
        print(f"metaclass __new__: {cls}, {name}, {bases}, {attrs}")
        return super().__new__(cls, name, bases, attrs)


# 定义一个类，指定metaclass 元类创建，而不是由 type 创建
class NewDemo(object, metaclass=DemoMetaClass):
    def __init__(self, x):
        self.x = x
        print(f"class __init__ : {self.x}")

    def __new__(cls, *args, **kwargs):  # 通过 new 来实例化 __init__.new 是用来创建实例的。
        print(f"class __new__:{cls}, {args}, {kwargs}")
        return object.__new__(cls)


print("------------------------------------------")
demo = NewDemo(x="yoyo")

运行结果

metaclass __new__: <class '__main__.DemoMetaClass'>, NewDemo, (<class 'object'>,), {'__module__': '__main__', '__qualname__': 'NewDemo', '__init__': <function NewDemo.__init__ at 0x000002039EDB9310>, '__new__': <function NewDemo.__new__ at 0x000002039EDB93A0>, 'name': 'zhangsan', 'age': <function DemoMetaClass.__new__.<locals>.<lambda> at 0x000002039EDB9430>}
metaclass 创建类初始化。。。。
---------------------------
class __new__:<class '__main__.NewDemo'>, (), {'x': 'yoyo'}
class __init__ : yoyo

元类（metaclass) 实例---yaml.YAMLObject

yaml.YAMLObject 类用到了metaclass， 相关源码如下

class YAMLObjectMetaclass(type):
    """
    The metaclass for YAMLObject.
    """
    def __init__(cls, name, bases, kwds):
        super(YAMLObjectMetaclass, cls).__init__(name, bases, kwds)
        if 'yaml_tag' in kwds and kwds['yaml_tag'] is not None:
            if isinstance(cls.yaml_loader, list):
                for loader in cls.yaml_loader:
                    loader.add_constructor(cls.yaml_tag, cls.from_yaml)
            else:
                cls.yaml_loader.add_constructor(cls.yaml_tag, cls.from_yaml)

            cls.yaml_dumper.add_representer(cls, cls.to_yaml)

class YAMLObject(metaclass=YAMLObjectMetaclass):
    """
    An object that can dump itself to a YAML stream
    and load itself from a YAML stream.
    """

    __slots__ = ()  # no direct instantiation, so allow immutable subclasses

    yaml_loader = [Loader, FullLoader, UnsafeLoader]
    yaml_dumper = Dumper

    yaml_tag = None
    yaml_flow_style = None

    @classmethod
    def from_yaml(cls, loader, node):
        """
        Convert a representation node to a Python object.
        """
        return loader.construct_yaml_object(node, cls)

    @classmethod
    def to_yaml(cls, dumper, data):
        """
        Convert a Python object to a representation node.
        """
        return dumper.represent_yaml_object(cls.yaml_tag, data, cls,
                flow_style=cls.yaml_flow_style)

pydantic 也用到了metaclass

pydantic 的基本使用

from datetime import datetime
from typing import List, Optional
from pydantic import BaseModel


class User(BaseModel):
    id: int
    name = 'yo yo'
    birth: Optional[datetime] = None
    friends: List[int] = []


external_data = {
    'id': '123',
    'birth': '2019-06-01 12:22',
    'friends': [1, 2, '3'],
}
user = User(**external_data)
print(user.dict())  # dict() 函数将对象转化成字典

BaseModel 类，就是通过自定义的metaclass创建，相关源码

class BaseModel(Representation, metaclass=ModelMetaclass):
    if TYPE_CHECKING:
        # populated by the metaclass, defined here to help IDEs only
        __fields__: Dict[str, ModelField] = {}
        __validators__: Dict[str, AnyCallable] = {}
        __pre_root_validators__: List[AnyCallable]
        __post_root_validators__: List[Tuple[bool, AnyCallable]]
        __config__: Type[BaseConfig] = BaseConfig
        __root__: Any = None
        __json_encoder__: Callable[[Any], Any] = lambda x: x
        __schema_cache__: 'DictAny' = {}
        __custom_root_type__: bool = False
        __signature__: 'Signature'
        __private_attributes__: Dict[str, Any]
        __class_vars__: SetStr
        __fields_set__: SetStr = set()

    Config = BaseConfig
    __slots__ = ('__dict__', '__fields_set__')
    __doc__ = ''  # Null out the Representation docstring

    def __init__(__pydantic_self__, **data: Any) -> None:
        """
        Create a new model by parsing and validating input data from keyword arguments.

        Raises ValidationError if the input data cannot be parsed to form a valid model.
        """
        # Uses something other than `self` the first arg to allow "self" as a settable attribute
        values, fields_set, validation_error = validate_model(__pydantic_self__.__class__, data)
        if validation_error:
            raise validation_error
        try:
            object_setattr(__pydantic_self__, '__dict__', values)
        except TypeError as e:
            raise TypeError(
                'Model values must be a dict; you may not have returned a dictionary from a root validator'
            ) from e
        object_setattr(__pydantic_self__, '__fields_set__', fields_set)
        __pydantic_self__._init_private_attributes()

ModelMetaclass 元类相关源码

class ModelMetaclass(ABCMeta):
    @no_type_check  # noqa C901
    def __new__(mcs, name, bases, namespace, **kwargs):  # noqa C901
        fields: Dict[str, ModelField] = {}
        config = BaseConfig
        validators: 'ValidatorListDict' = {}



class ABCMeta(type):
    """Metaclass for defining Abstract Base Classes (ABCs).

    Use this metaclass to create an ABC.  An ABC can be subclassed
    directly, and then acts as a mix-in class.  You can also register
    unrelated concrete classes (even built-in classes) and unrelated
    ABCs as 'virtual subclasses' -- these and their descendants will
    be considered subclasses of the registering ABC by the built-in
    issubclass() function, but the registering ABC won't show up in
    their MRO (Method Resolution Order) nor will method
    implementations defined by the registering ABC be callable (not
    even via super()).
    """
    def __new__(mcls, name, bases, namespace, **kwargs):
        cls = super().__new__(mcls, name, bases, namespace, **kwargs)
        _abc_init(cls)
        return cls

    def register(cls, subclass):
        """Register a virtual subclass of an ABC.

        Returns the subclass, to allow usage as a class decorator.
        """
        return _abc_register(cls, subclass)

元类用来创建 API 是非常好的方法，使用元类的编写对于 python 开发者来说很复杂， 但对于使用者可以非常简洁的调用 API。
学到这大概明白了，元类是给真正的python 开发者使用的（并不是会写个print 就是python开发者，这里对开发者的定义是能开发框架的开发者），而不是给 python 使用者用（python 使用者是会调用第三方库的人员，无框架开发能力。）