元编程(meta programming)是一项很神奇的能力,可以通过代码在
运行时动态生成代码。
元类(meta classes)是 Python 提供的一种元编程的能力。在 Python 中,类也是一种对象,那么类这种对象就是元类的实例,所以我们可以在运行时通过实例化元类动态生成类。
使用 type “函数”
首先我们来了解一下 type,type 可以作为函数使用,用来获得对象的类型:
>>>
class
Foo:
...
pass
>>>obj = Foo()
>>>obj.__class__
<
class '
__main__.
Foo'>
>>>
type
(obj)
<
class '
__main__.
Foo'>
>>>
obj.
__class__
is
type
(obj)
True
实际上 type 并不是一个函数,而是一个类,我们可以使用 type(type) 来确定一下:
>>>type(type)
<
class '
type'>
type 实际上不只是类,而是一个“元类”。我们接下来要可以看到,所有的元类都需要继承自 type。type 是所以类的元类,所以在上面的例子中 x 是 Foo 的实例,Foo 是 type 的实例,type 又是他自己的实例。
用 type 动态创建类
如果传递给 type 的参数是三个的时候,type 的语义就不再是返回给定参数的类,而是实例化生成一个新的类。
type(name: str, bases: tuple, namespace: dict)
第一个参数是新生成的类的名字;第二个参数是新生成的类的基类列表;第三个参数是要个这个类绑定的属性的列表,比如说这个类的一些方法。实际上 class Foo 这种语法只是使用 type 生成类的语法糖而已。
最简单的一个例子,比如我们要创建 Foo[0..9] 这些类,可以这样做:
classes = []
for i
in range(
10):
cls = type(
"Foo%s" % i, tuple(), {})
classes.append(cls)
# 就像使用普通类一样初始化 Foo0
foo0 = clssses[
0]()
如果要实现类的方法,一定要记得同样是要使用 self 变量的。在 Python 中 self 只是一个约定俗成的变量,而不是关键字。
def
__init__
(self, name):
self.name = name
def
print_name
(self):
print(self.name)
Duck = type(
"Duck", tuple(), {
"__init__": __init__,
"print_name": print_name})
duck = Duck(
"Donald")
duck.print_name()
# Donald
创建自己的元类
首先我们来回顾一下 Python 中类的初始化过程:
foo = Foo()
当这条语句运行的时候,Python 会依次调用 Foo 的
__new__ 和
__init__ 方法。其中
__new__ 方法在
__init__ 之前调用,并返回已经创建好的新对象,而
__init__ 函数是没有返回结果的。一般情况下,我们都会覆盖
__init__ 方法来对新创建的对象做一些初始化操作。
现在回归到元类上,
进入烧脑部分。前面我们说过元类的实例化就是类,所以大致相当于:
Foo = MetaFoo(name, bases, attrs)
# MetaFoo 默认情况下是 type
foo = Foo()
默认情况下,所有类的元类是 type,也就是在这个类是通过 type 来创建的,这和前面说的通过 type 来动态创建类也是一致的。
那么怎样定义一个 MetaFoo 呢?只需要继承自 type 就行了。因为元类的实例化就是类的创建过程,所以在元类中,我们可以修改
__new__ 来在
__init__ 之前对新创建的类做一些操作。
>>>
class
MetaFoo
(type):
...
def
__new__
(cls, name, bases, namespace):
... x = super().__new__(cls, name, bases, namespace)
# super实际上就是 type
... x.bar =
100
# 为这个类增加一个属性
...
return x
...
>>>Foo = MetaFoo(
"Foo", tuple(), {})
# MetaFoo 在这里就相当于 type 了,可以动态创建类
>>>Foo.bar
100
>>>foo = Foo()
>>>foo.bar
100
在这里我们创建了 MetaFoo 这个元类,他会给新创建的类增加一个叫做 bar 的属性。
在实际的代码中,我们一般还是不会直接动态生成类的,还是调用
class Foo 语法来生成类比较常见一点,这时候可以指定 metaclass 参数就好了。可以通过 Foo(metaclass=MetaFoo) 这种方式来指定元类。
class
Foo
(metaclass=MetaFoo):
pass
这种定义和上面的元类用法效果完全是一致的。
一个现实世界的元类例子
在 django.models 或者 peewee 等 ORM 中,我们一般使用类的成员变量来定义字段,这里就用到了元类。
class
Field:
pass
class
IntegerField
(Field):
pass
class
CharField
(Field):
pass
class
MetaModel
(type):
def
__new__
(meta, name, bases, attrs):
# 这里最神奇的是:用户定义的类中的 bases 和 attrs 都会作为参数传递进来
fields = {}
for key, value
in attrs.items():
if isinstance(value, Field):
value.name =
'%s.%s' % (name, key)
fields[key] = value
for base
in bases:
if hasattr(base,
'_fields'):
fields.update(base._fields)
attrs[
'_fields'] = fields
return type.__new__(meta, name, bases, attrs)
class
Model
(metaclass=MetaModel):
pass
这样用户使用的时候就可以这样定义:
>>>
class
A
(Model):
... foo = IntegerField()
...
>>>
class
B
(A):
... bar = CharField()
...
>>>B._fields
{
'foo': Integer(
'A.foo'),
'bar': String(
'B.bar')}
程序在执行的时候就可以直接访问
X._fields,而不用每次都通过反射遍历一次,从而提高效率以及做一些验证。
不过,其实这个完全可以通过装饰器来实现:
def
model
(cls):
fields = {}
for key, value
in vars(cls).items():
if isinstance(value, Field):
value.name =
'%s.%s' % (cls.__name__, key)
fields[key] = value
for base
in cls.__bases__:
if hasattr(base,
'_fields'):
fields.update(base._fields)
cls._fields = fields
return cls
@model
class
A
():
foo = IntegerField()
class
B
(A):
bar = CharField()
但是用装饰器的话,就失去了一些类型继承的语义信息。
总结与思考
Python 中的元编程还是一种很强大的特性,但是也比较复杂,有时候很难以理解。实际上,过分的动态特性也导致了 Python 的解释器和静态分析、自动补全等很难优化,因为有好多信息必须到运行时才能知道。
实际上近些年新开发的语言越来越多地加入了静态类型的特性,比如 swift, rust, go 等。就连 Python 本身也增加了 type hinting 的功能,很遗憾的是,这个功能不是强制性的,所以也很难用来提升性能。
元类这块应该是我在 Python 语言方面了解的最后一大块知识了。接下来除了写业务代码不会再深究 Python 了,研究 Golang 去了~
Au revoir, Python!