python中什么是元类

简单的讲，元类创建了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语句。