Python 元类 - Metaclasses

 Python 元类 - Metaclasses

 默认情况下儿, classes 是有 type() 构造的.
 类的结构体在一个新的 namespace 被执行, 类的名字 class name 绑定(bound locally)到
 type(name, bases, namespace) 的结果上.
 然而, 类的构造过程可以用户定义 - 在定义类的时候通过传入一个 metaclass 关键字;
 或者通过继承至一个有 metaclass 关键字的父类.
     如,
             class Meta(type):
                  pass

             class MyClass(metaclass=Meta):
                 pass
         or
             class MySubclass(MyClass):
                 pass

 在 class 定义中的其他关键字参数会被传给所有 metaclass 的操作.
     当 class 构造体被执行的时候,python 解释器按照下列顺序 interpretation,
         确定 class 对应的 metaclass ,
         准备 class 的 namespace,
         执行 class 定义体 - class body,
         创建 class 对象 - class object.

 下面我们逐一详细看一下儿以上几个解释步骤,
     metaclass 的确定 - Determining the appropriate metaclass
         metaclass 确定原则, 以 class B(metaclass = A, C) 为例阐述,
             如果 class 的定义中没有指定基类 bases, 并且没有 metaclass 关键字,采用 type() 作为 metaclass.
             如果有关键字 metaclass = A, 并且 A 不是 type() 的实例, 直接采用 A 作为 metaclass.
             如果 A 是 type() 一个实例 instance, 或者有定义基类 bases, 则 采用 the most derived metaclass  

             注,
                 candidate metaclasses 有2部分原来：
                     a, metaclass 关键字, 如上例子中的 A
                     b, 所有基类 bases的 metaclasses, 如上例子中的 type(c)
                 the most derived metaclass 是 candidate metaclasses 集合中的一个,
                 它需要满足是所有其他的 candidate 的 subtype,如果没有任何一个 candidate 满足这个条件,
                 则 class 的定义会报错，raise  TypeError  exception.

     namespace 的确定 - Preparing the class namespace
         metaclass 确定了之后, 到了该确定 namespace 的时候.
         如果 metaclass 有 __prepare__ attribute, 下面的语句将被调用,以确定 namespace
             namespace = metaclass.__prepare__(name, bases, **kwds),
                 **kwds 来至于 class 的定义语句.
         若 metaclass 没有 __prepare__ attribute, 则 类的 namespace 被初始化为空 an empty ordered mapping.

     class body 的执行 - Executing the class body
         class body 的执行, 可以用如下伪代码来表示,
             exec(body, globals(), namespace)

         跟一般的对 exec()的调用的关键区别在于, 当 class 定义在一个函数中时候,
         允许类的定义体 class body (包括其中的方法) 引用 '当前' 和 '外层' 作用域 scope 的 names
            "The key difference from a normal call to exec() is that lexical scoping allows
             the class body (including any methods) to reference names from the current and
             outer scopes when the class definition occurs inside a function."
         然而,及时 class 被定义在一个函数中, 在 class scope 所定义的 names 对 class 中定义的 methods
         仍然不可见.
         对类变量 Class variables 的访问, 必须通过 self.variable 的形式访问,或作为第一个参数传入.
             即,
                 class A(object):
                     a =  "variable - a"

                     def func1(self)：         # 必须通过 self.variable 的形式访问 Class variables
                         print(self.a)

                     def func2(self, a):       # 作为第一个参数传入的形式访问 Class variables
                         print(a)

             再或者通过 隐式词法作用于 implicit lexically scoped __class__ 引用, 见下一节描述.

     class object 的创建 - Creating the class object
         class namespace 被确定之后, class object 由下面方法创建,
             metaclass(name, bases, namespace, **kwds)
                 **kwds  跟传给 __prepare__ 的 **kwds, 即来至于 class 的定义语句.

         class object 即 super().__class__, 是一个在 class boby 中存在引用 __class__ 或 super 的方法
         的情况下儿被编译器 compiler 创建一个隐式闭包引用 an implicit closure reference.
         这保证了通过把 class 或者 instance 作为第一个参数来调用(属性/方法)的时候,无参数的 super()
         可以正确的识别对应的 class, 即 class body 中的 self 机制.

         CPython implementation detail:
             从 python 3.6 开始, __class__ 被传给 metaclass 作为 __classcell__ 存储在类的 namespace 中.
             如果 __class__ 存在, 需要向上反推到 type.__new__ 的调用,以保证 class 的正确初始化.
             如果 type.__new__ 调用失败,将报告 DeprecationWarning, 之后报 RuntimeWarning (python 3.6).
             当采用默认 metaclass, 或某一 metaclass 调用了 type.__new__, 在创建了 class object 下面额外
             的步骤姜维调用,
                 a, type.__new__ 收集 class namespace 中的所有 descriptors, 定义 __set_name__() 方法
                 b, 在所定义的类上调用 __set_name__ 中的描述符方法,
                    class being defined and the assigned name of that particular descriptor 作为参数.
                 c, 在被定义 class 的最近的基类上(MRO)调用 __init_subclass__(),
             当 class object 被创建后, 如果 class 存在 decorators 将 class object 传给 decorators 装饰.
             将返回的新对象绑定到 local namespace.
             当一个新的 class 是由 type.__new__ 创建的, namespace parameter 复制一个新的 ordered mapping
             中, 源对象被弃用. 新的 ordered mapping 将被包装成 read-only proxy, 最终成为 class object 的
             __dict__ 属性.  

 最后来看例子 - Metaclass example
     metaclasses 的潜在用途有很多, 包括  enum, logging, interface checking, automatic delegation,
     automatic property creation, proxies, frameworks, and automatic resource locking/synchronization.

     下面是一个通过 collections.OrderedDict 来记录类参数定义顺序的 metaclasses 应用的例子,
         import collections
         class OrderedClass(type):

             @classmethod
             def __prepare__(metacls, name, bases, **kwds):
                 return collections.OrderedDict()

             def __new__(cls, name, bases, namespace, **kwds):
                 result = type.__new__(cls, name, bases, dict(namespace))
                 result.members = tuple(namespace)
                 return result

         class A(metaclass=OrderedClass):
             A = 1
             C = 2
             B = 3
             def one(self): pass
             def two(self): pass
             def three(self): pass
             def four(self): pass
     Output,
         >>> A.members
         ('__module__', '__qualname__', 'A', 'C', 'B', 'one', 'two', 'three', 'four')

     当类 A 的定义体被执行的时候, 先调用 metaclass 的 __prepare__ 方法, __prepare__()
     返回一个空的 collections.OrderedDict. 这个 OrderedDict 被用来按声明顺序记录 A 中
     定义的 methods and attributes. 当解释器解释到 attributes 被声明的位置时, 通过执行声明
     将 attributes 被添加到 ordered dictionary. 并且调用 metaclass 的 __new__() method 被,
     结果就是 __new__() 创建一个新的的 type 并将 ordered dictionary 的 keys 存储在 members
     属性中.

 Reference,
     python doc,
         https://docs.python.org/3/reference/datamodel.html#metaclasses