python metaclass 入门简介

http://cizixs.com/2015/08/30/metaclass-in-python

动态类型也是类型

python 是一种动态类型语言，换句话说每个变量可以在程序里任何地方改变它的类型。想要获取变量的类型信息，可以使用 type：

>>> a = 2

>>> type(a)

int

>>> a = '1'

>>> type(a)

str

>>> type(str)

type

>>> type(type)

type

>>> class Test1 (object):

        pass

>>> class Test2 (Test1):

        pass

>>> a = Test1()

>>> b = Test2()

>>> type(a) is Test1

True

>>> type(b) is Test2

True

从上面的例子可以得到下面的结论：

每个变量都有自己的类型
变量的类型是可以随时改变的
type 只会返回对象的直接 type，就是定义该对象的类
类的 type 还是 type，这说明 type 定义了 python 中所有类的某些基本属性

type 的第二种用法

上面提到了 type 的一种用法，查看 python 对象的类型。type 的另外一个用法就比较独特：生成类。

Help on class type in module __builtin__:

class type(object)

 |  type(object) -> the object's type

 |  type(name, bases, dict) -> a new type

来我们看一下 type 到底怎么用！一般情况下，类的定义式这样的：

class Foo(object):

    """A class that does nothing."""

    def __init__(self):

        self.a = 1

    def magic(self):

        return self.a

使用 type 也可以做到同样的效果：

def __init__(self):

    self.a = 1

def magic(self):

    return self.a

Foo = type('Foo', (object,), {"__doc__": "A class that does nothing.", "__init__": __init__, "magic": magic})

foo = Foo()

print foo

print foo.a  # 1

print foo.magic  # <bound method Foo.magic of <__main__.Foo object at 0x100fa5d50>>

print foo.magic() # 1

type 的三个参数分别是：

name: 要生产的类名
bases：包含所有基类的 tuple
dict：类的所有属性，是键值对的字典

现在再回顾一下 “python 中一切皆对象”这句话，可能会更容易理解。

metaclass 就是类的类

我们在前面看到怎么使用 type 来动态创建类，其实在 python 内部也进行着同样的步骤。这就是 metaclass 的概念！

想弄明白 metaclass，我们要搞清楚 class。因为类似于 class 定义了 instance 的行为，metaclass 则定义了 class 的行为。可以说，class 是 metaclass 的 instance。

instance 创建的时候会调用 __init__ 函数，类似的，class 创建的时候会调用 __new__函数。通过自定义 __new__ 函数，你可以在创建类的时候做些额外的事情：把这个类注册到某个地方作为记录或者后续的查询，给类注入一些属性，或者干脆替换成另外一个类。

当遇到类定义的时候，

class MyClass(object):

    pass

不会立即去创建这个类，而是把这段代码当做正常的 code block 来执行，结果就是生成一个命名空间(namespace)，就是包含了要生成类(class-to-be)所有属性的字典，然后才会调用 __new__ 函数，把类名、类的父类、类的属性传递过去，生成这个类。

看到没有，上面一段话是不是很熟悉，没错，和我们使用 type 来创建类是一样的。

总结一下：metaclass 的功能是什么？根据类的信息，来创建这个类。没错，type 就是 python 自带的 metaclass。

创建自己的 metaclass

既然可以使用 type 来创建 python 标准的类，自然而然地，继承 type 这个类，覆盖已有的内置函数，就可以创建自己的 metaclsss。

下面的内容都会基于一个这样的并metaclass：它为要创建的类自动添加一个属性__cizixs。这个 metalcss 没有任何实际的意义，但可以帮助理解 metaclss 。

根据上面的思路，我们可以写出这样的代码：

class MyMetaclass(type):

    def __init__(cls, name, bases, attrs):

        cls.__cizixs = "Don't panic"

        print("In MyMetaclass for {}".format(name))

        super(MyMetaClass, cls).__init__(name, bases, attrs)

其实还可以覆写 __new__ 函数来达到相同的目的：

class MyMetaclass(type):

    def __new__(cls, name, bases, attrs):

        attrs['__cizixs'] = "Don't panic"

        print("In MyMetaclass for {}".format(name))

        return super(MyMetaclss, cls).__new__(cls, name, bases, attrs)

class Foo(object):

    __metaclass__ = MyMetaclass

    pass

#  In MyMetaclass for Foo

foo = Foo()

print foo.__cizixs  # Don't panic

关于 __new__ 和 __init__ 的不同，就不在此讲述，感兴趣可以自行搜索。只想提一句，__new__ 创建类，__init__ 初始化类。所以 __new__ 会在 __init__ 之前被调用，而且 __new__ 必须要返回新创建的类，__init__ 不需要。

上面这段代码需要说明的几点：

__new__ 函数就是类创建的时候可以使用的
注意 __new__ 是一个 classmethod，代码中参数 cls 在这里就是<class '__main__.MyMetaclass'>。
只要在类的定义里指定 __metaclss__，那么这个类在创建的时候就会自动使用自定义的 metaclass，而不是系统默认的 type。
在创建类的时候，python 会按照这样的顺序去找要使用的 metaclass：
- 类定义时候的类变量 __metaclass__
- 类所在MODULE（就是当前文件）里的 __metaclss__ 变量
- 第一个父类定义的 __metaclas__ 变量
- 系统默认的 type metaclass

如果要控制类实例化 instance 的行为，还可以覆写 __call__ 函数。