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

落日映苍穹つ 2023-09-24 09:27 51阅读 0赞

简单的讲，元类创建了Python中所有的对象。

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

比方说我们要定义一个的class，就写一个模块：

class HelloWorld(object):

def helloworld(self):

print('Hello World!')

当Python解释器载入模块时，就会依次执行该模块的所有语句，执行结果就是动态创建出一个的class对象，测试如下：

>>> from helloworld import HelloWorld

>>> h= HelloWorld()

>>> h.helloworld()

Hello, world!

>>> print(type(HelloWorld))

>>> print(type(h))

函数用来查看一个类型或变量的类型，是一个class，它的类型就是，而是一个实例，它的类型就是class 。

我们说class的定义是运行时动态创建的，而创建class的方法就是使用函数。

定义：type(类名, 父类的元组(针对继承的情况，可以为空)，包含属性的字典(名称和值))

函数既可以返回一个对象的类型，又可以创建出新的类型，比如，我们可以通过函数创建出类，而无需通过的定义：

>>> 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))

>>> print(type(h))

那么要创建一个class对象，函数需要依次传入3个参数：

class的名称；

继承的父类集合，注意Python支持多重继承，如果只有一个父类，别忘了tuple的单元素写法；

class的方法名称与函数绑定，这里我们把函数helloworld\_outside绑定到方法名上。

通过函数创建的类和直接写class是完全一样的，因为Python解释器遇到class定义时，仅仅是扫描一下class定义的语法，然后调用函数创建出class。

正常情况下，我们都用来定义类，但是，函数也允许我们动态创建出类来，也就是说，动态语言本身支持运行期动态创建类，这和静态语言有非常大的不同，要在静态语言运行期创建类，必须构造源代码字符串再调用编译器，或者借助一些工具生成字节码实现，本质上都是动态编译，会非常复杂。

除了使用动态创建类以外，要控制类的创建行为，还可以使用metaclass。

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

当我们定义了类以后，就可以根据这个类创建出实例，所以：先定义类，然后创建实例。

但是如果我们想创建出类呢？那就必须根据metaclass创建出类，所以：先定义metaclass，然后创建类。

所以，metaclass允许你创建类或者修改类。换句话说，你可以把类看成是metaclass创建出来的“实例”。

metaclass是Python面向对象里最难理解，也是最难使用的魔术代码。正常情况下，你不会碰到需要使用metaclass的情况，所以，以下内容看不懂也没关系，因为基本上你不会用到。

我们先看一个简单的例子，这个metaclass可以给我们自定义的MyList增加一个方法：

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

下面是运行结果，测试一下是否可以调用方法：

>>> 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)

类名的定义：定义，按照默认习惯，metaclass的类名总是以Metaclass结尾，以便清楚地表示这是一个metaclass

Metaclass的父类：M

选择\_\_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声明处传入关键字参数，python会在当前class里创建属性\_\_metaclass\_\_，因此它指示Python解释器在创建时，要通过来创建，在ListMetaclass.\_\_new\_\_()中，我们可以修改类的定义，比如，加上新的方法，然后，返回修改后的定义。

Ok,下面测试一下是否可以调用方法：

>>> L= MyList()

>>> L.add(1)

>> L

\[1\]

而普通的没有方法：

>>> L2= list()

>>> L2.add(1)

Traceback (most recent call last):

File " ", line 1, in

AttributeError: 'list' object has no attribute 'add'

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