谈谈Python中元类Metaclass(一)：什么是元类

简单的讲，元类建立了Python中全部的对象。

咱们说Python是一种动态语言，而动态语言和静态语言最大的不一样，就是函数和类不是编译时定义的，而是运行时动态建立的。

比方说咱们要定义一个HelloWorld的class，就写一个helloworld.py模块：

class HelloWorld(object):
    def helloworld(self):
        print('Hello World!')

当Python解释器载入helloworld模块时，就会依次执行该模块的全部语句，执行结果就是动态建立出一个HelloWorld的class对象，测试以下：

>>> from helloworld import HelloWorld
>>> h = HelloWorld()
>>> h.helloworld()
Hello, world!
>>> print(type(HelloWorld))
<class 'type'>
>>> print(type(h))
<class 'helloworld.HelloWorld'>

type()函数用来查看一个类型或变量的类型，HelloWorld是一个class，它的类型就是type，而h是一个实例，它的类型就是class Helloworld。

咱们说class的定义是运行时动态建立的，而建立class的方法就是使用type()函数。

定义：type(类名, 父类的元组（针对继承的状况，能够为空），包含属性的字典（名称和值）)

type()函数既能够返回一个对象的类型，又能够建立出新的类型，好比，咱们能够经过type()函数建立出HelloWorld类，而无需经过class HelloWorld(object)...的定义：

>>> def helloworld_outside(self): # 先定义函数
...     print('Hello World!')
...
>>> HelloWorld = type('HelloWorld', (object,), dict(helloworld=helloworld_outside)) # 建立HelloWorld class
>>> h = HelloWorld()
>>> h.helloworld()
Hello, world!
>>> print(type(HelloWorld))
<class 'type'>
>>> print(type(h))
<class '__main__.HelloWorld'>

那么要建立一个class对象，type()函数须要依次传入3个参数：

1. class的名称；
2. 继承的父类集合，注意Python支持多重继承，若是只有一个父类，别忘了tuple的单元素写法；
3. class的方法名称与函数绑定，这里咱们把函数helloworld_outside绑定到方法名helloworld上。

经过type()函数建立的类和直接写class是彻底同样的，由于Python解释器遇到class定义时，仅仅是扫描一下class定义的语法，而后调用type()函数建立出class。

正常状况下，咱们都用class Xxx...来定义类，可是，type()函数也容许咱们动态建立出类来，也就是说，动态语言自己支持运行期动态建立类，这和静态语言有很是大的不一样，要在静态语言运行期建立类，必须构造源代码字符串再调用编译器，或者借助一些工具生成字节码实现，本质上都是动态编译，会很是复杂。

metaclass

除了使用type()动态建立类之外，要控制类的建立行为，还可使用metaclass。

metaclass，直译为元类，简单的解释就是：

当咱们定义了类之后，就能够根据这个类建立出实例，因此：先定义类，而后建立实例。

可是若是咱们想建立出类呢？那就必须根据metaclass建立出类，因此：先定义metaclass，而后建立类。

因此，metaclass容许你建立类或者修改类。换句话说，你能够把类当作是metaclass建立出来的“实例”。

metaclass是Python面向对象里最难理解，也是最难使用的魔术代码。正常状况下，你不会碰到须要使用metaclass的状况，因此，如下内容看不懂也不要紧，由于基本上你不会用到。

咱们先看一个简单的例子，这个metaclass能够给咱们自定义的MyList增长一个add方法：

class ListMetaclass(type):
    def __new__(cls, name, bases, attrs):
        attrs['add'] = lambda self, value: self.append(value)
        return type.__new__(cls, name, bases, attrs)

class MyList(list, metaclass=ListMetaclass):
    pass

下面是运行结果，测试一下MyList是否能够调用add()方法：

>>> L = MyList()
>>> L.add(1)
>> L
[1]

经过这个例子咱们能够看到，自定义咱们的MyList分两步：

1. 建立Metaclass，用来建立/修改类

2. 建立实际的MyList Class

首先咱们来看第一步，建立Metaclass:

class ListMetaclass(type):
    def __new__(cls, name, bases, attrs):
        attrs['add'] = lambda self, value: self.append(value)
        return type.__new__(cls, name, bases, attrs)

• 类名的定义：定义ListMetaclass，按照默认习惯，metaclass的类名老是以Metaclass结尾，以便清楚地表示这是一个metaclass
• Metaclass的父类：Metaclass是类的模板，因此必须从`type`类型派生：
• 选择__new__函数做为实现"修改类"的函数：
  • 函数__new__(cls, name,bases,attrs)中，"cls"相似于类中其余函数的self参数，例如__init__(self)，只不过self表明建立的对象，而cls表明类自己（__init__做为实例初始化的函数，须要把实例自己做为参数传进去，这样咱们才能保证被修改的是实例；同理，__new__函数须要把类自己做为参数传进去，才能保证被初始化的是当前类）; name表明类的名称；bases表明当前类的父类集合；attrs表明当前类的属性，是狭义上属性和方法的集合，能够用字典dict的方式传入
  • 对__new__的定义def __new__(cls, name,bases,attrs)，实际上，“new”方法在Python中是真正的构造方法（建立并返回实例），经过这个方法能够产生一个”cls”对应的实例对象因此说”new”方法必定要有返回，要把建立的实例对象返回回去。在此，咱们把对类的修改放到__new__方法中，而后返回修改事后的实例对象。另外，很简单的道理，选择type.__new__函数做为return的值，是由于咱们的ListMetaclass继承自type，所以应该返回class type的__new__函数建立的对象。

class MyList(list, metaclass=ListMetaclass):
    pass

有了ListMetaclass，下一个问题是如何使用ListMetaclass?

首先咱们须要先谈一谈Python建立class的机制：

当建立class的时候，python会先检查当前类中有没有__metaclass__，若是有，就用此方法建立对象；若是没有，则会一级一级的检查父类中有没有__metaclass__，用来建立对象。建立的这个“对象”，就是当前的这个类。若是当前类和父类都没有，则会在当前package中寻找__metaclass__方法，若是尚未，则会调用本身隐藏的的type函数来建立对象。

值得注意的是，若是咱们在作类的定义时，在class声明处传入关键字metaclass=ListMetaclass，那么若是传入的这个metaclass有__call__函数，这个__call__函数将会覆盖掉MyList class的__new__函数。这是为何呢？请你们回想一下，当咱们实例化MyList的时候，用的语句是L1=MyList()，而咱们知道，__call__函数的做用是能让类实例化后的对象可以像函数同样被调用。也就是说MyList是ListMetaclass实例化后的对象，而MyList()调用的就是ListMetaclass的__call__函数。另外，值得一提的是，若是class声明处，咱们是让MyList继承ListMetaclass，那么ListMetaclass的__call__函数将不会覆盖掉MyList的__new__函数。

所以，咱们在定义类的时候还要指示使用ListMetaclass来定制类（即在MyList class定义时，在class声明处传入关键字参数metaclass=ListMetaclass）：咱们传入关键字参数metaclass后，python会在当前class里建立属性__metaclass__，所以它指示Python解释器在建立MyList时，要经过ListMetaclass.__new__()来建立，在ListMetaclass.__new__()中，咱们能够修改类的定义，好比，加上新的方法，而后，返回修改后的定义。

Ok,下面测试一下MyList是否能够调用add()方法：

>>> L = MyList()
>>> L.add(1)
>> L
[1]

而普通的list没有add()方法：

>>> L2 = list()
>>> L2.add(1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'list' object has no attribute 'add'

动态修改有什么意义？直接在MyList定义中写上add()方法不是更简单吗？正常状况下，确实应该直接写，经过metaclass修改纯属变态。

可是，总会遇到须要经过metaclass修改类定义的。ORM就是一个典型的例子。

ORM全称“Object Relational Mapping”，即对象-关系映射，就是把关系数据库的一行映射为一个对象，也就是一个类对应一个表，这样，写代码更简单，不用直接操做SQL语句。

我将会在下一次文章中详细讲讲ORM是怎么工做的。