理解Python中的元类(metaclass)

理解Python中的元类(metaclass)

这篇文章基本上是What are metaclasses in Python?最高赞答案的翻译,同时我简化了一点东西,加了点自己的demo。可以直接去看原文。

类也是对象

在理解元类之前,你需要先掌握Python中的类。Python中类的概念借鉴于Smalltalk,这显得有些奇特。在大多数编程语言中,类就是一组用来描述如何生成一个对象的代码段。在Python中这一点仍然成立:

>>> class ObjectCreator(object):
...       pass
...

>>> my_object = ObjectCreator()
>>> print(my_object)
<__main__.ObjectCreator object at 0x8974f2c>

但是,Python中的类还远不止如此。类同样也是一种对象。是的,没错,就是对象。只要你使用关键字class,Python解释器在执行的时候就会创建一个对象.

下面这段代码:

class ObjectCreator(object):
      pass

将在内存中创建一个对象,名字就是ObjectCreator。这个对象(类)自身拥有创建对象(类实例)的能力,而这就是为什么它是一个类的原因。但是,它的本质仍然是一个对象,于是你可以对它做如下的操作:

  1. 你可以将它赋值给一个变量
  2. 你可以拷贝它
  3. 你可以为它增加属性
  4. 你可以将它作为函数参数进行传递

下面是示例:

>>> print ObjectCreator     # 你可以打印一个类,因为它其实也是一个对象
<class '__main__.ObjectCreator'>
>>> def echo(o):
…       print o
…
>>> echo(ObjectCreator)                 # 你可以将类做为参数传给函数
<class '__main__.ObjectCreator'>
>>> print hasattr(ObjectCreator, 'new_attribute')
Fasle
>>> ObjectCreator.new_attribute = 'foo' #  你可以为类增加属性
>>> print hasattr(ObjectCreator, 'new_attribute')
True
>>> print ObjectCreator.new_attribute
foo
>>> ObjectCreatorMirror = ObjectCreator # 你可以将类赋值给一个变量
>>> print ObjectCreatorMirror()
<__main__.ObjectCreator object at 0x8997b4c>

动态地创建类

因为类也是对象,你可以在运行时动态的创建它们,就像其他任何对象一样。首先,你可以在函数中创建类,使用class关键字即可

>>> def choose_class(name):
…       if name == 'foo':
…           class Foo(object):
…               pass
…           return Foo     # 返回的是类,不是类的实例
…       else:
…           class Bar(object):
…               pass
…           return Bar
…
>>> MyClass = choose_class('foo')
>>> print MyClass              # 函数返回的是类,不是类的实例
<class '__main__'.Foo>
>>> print MyClass()            # 你可以通过这个类创建类实例,也就是对象
<__main__.Foo object at 0x89c6d4c>

但这还不够动态,因为你仍然需要自己编写整个类的代码。由于类也是对象,所以它们必须是通过什么东西来生成的才对。

type能动态的创建类,type可以接受一个类的描述作为参数,然后返回一个类。

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

比如下面的代码:

>>> MyShinyClass = type('MyShinyClass', (), {})  # 返回一个类对象
>>> print MyShinyClass
<class '__main__.MyShinyClass'>
>>> print MyShinyClass()  #  创建一个该类的实例
<__main__.MyShinyClass object at 0x8997cec>

type 接受一个字典来为类定义属性,因此:

>>> class Foo(object):
…       bar = True

等同于:

Foo = type('Foo', (), {'bar':True})

在Python中,类也是对象,你可以动态的创建类。这就是当你使用关键字class时Python在幕后做的事情,而这就是通过元类来实现的。

元类

元类就是创建类这种对象的东西。如果你喜欢的话,可以把元类称为“类工厂”。type就是Python的内建元类,当然了,你也可以创建自己的元类。

元类本身而言,它们其实是很简单的:

  1. 拦截类的创建

  2. 修改类

  3. 返回修改之后的类

自定义元类

元类的主要目的就是为了当创建类时能够自动地改变类。

Python 3中创建元类的语法:

class NothingMetaclass(type):
    def __new__(mcs, name, bases, namespace):
         # 什么都没做,你可以在这里做点什么
        return type.__new__(mcs, name, bases, namespace)

class Foo(object, metaclass=NothingMetaclass):
    pass

demo1

  1. new是一个静态方法,而init是一个实例方法.
  2. new方法会返回一个创建的实例,而init什么都不返回.
  3. 只有在new返回一个cls的实例时后面的init才能被调用.
  4. 当创建一个新实例时调用new,初始化一个实例时用init.

看一个例子

# 请记住,'type'实际上是一个类,就像'str'和'int'一样
# 所以,你可以从type继承
class MetaA(type):
    # __new__ 是在__init__之前被调用的特殊方法
    # __new__是用来创建对象并返回之的方法
    # 而__init__只是用来将传入的参数初始化给对象
    # 你很少用到__new__,除非你希望能够控制对象的创建
    # 这里,创建的对象是类,我们希望能够自定义它,所以我们这里改写__new__
    # 如果你希望的话,你也可以在__init__中做些事情
    # 还有一些高级的用法会涉及到改写__call__特殊方法,但是我们这里不用
    def __new__(cls, name, bases, dct):
        print('MetaA.__new__')
        # 这种方式不会调用__init__方法
        # return type(name, bases, dct)
        # 这种方式会调用__init__
        return type.__new__(cls, name, bases, dct)

    def __init__(cls, name, bases, dct):
        print('MetaA.__init__')


class A(object, metaclass=MetaA):
    pass


print(A())

demo2

class ListMetaclass(type):

    # 元类会自动将你通常传给‘type’的参数作为自己的参数传入
    # mcs表示元类
    # name表示创建类的类名(在这里创建类就是继承Model类的子类User)
    # bases表示创建类继承的所有父类
    # namespace表示创建类的所有属性和方法(以键值对的字典的形式)
    def __new__(mcs, name, bases, namespace):
        namespace['add'] = lambda self, value: self.append(value)
        return type.__new__(mcs, name, bases, namespace)


# 通过metaclass,给该类动态添加了add方法
class MyList(list, metaclass=ListMetaclass):
    pass


l = MyList()
l.add(1)
print(l)

究竟为什么要使用元类?

现在回到我们的大主题上来,究竟是为什么你会去使用这样一种容易出错且晦涩的特性?好吧,一般来说,你根本就用不上它:

“元类就是深度的魔法,99%的用户应该根本不必为此操心。如果你想搞清楚究竟是否需要用到元类,那么你就不需要它。那些实际用到元类的人都非常清楚地知道他们需要做什么,而且根本不需要解释为什么要用元类。” —— Python界的领袖 Tim Peters

元类的主要用途是创建API。一个典型的例子是Django ORM。它允许你像这样定义

class Person(models.Model):
    name = models.CharField(max_length=30)
    age = models.IntegerField()

然后可以通过简单点API操作数据库。其背后的魔法就是定义了元类,并且使用了一些魔法能够将你刚刚定义的简单的Person类转变成对数据库的一个复杂hook。Django框架将这些看起来很复杂的东西通过暴露出一个简单的使用元类的API将其化简,通过这个API重新创建代码,在背后完成真正的工作。

一个简单的orm demo

class Field:
    def __init__(self, name, column_type):
        self.name = name
        self.column_type = column_type

    def __str__(self):
        return '<%s:%s>' % (self.__class__.__name__, self.name)


class StringField(Field):
    def __init__(self, name):
        super(StringField, self).__init__(name, 'varchar(100)')


class IntegerField(Field):
    def __init__(self, name):
        super(IntegerField, self).__init__(name, 'bigint')


class ModelMetaclass(type):
    def __new__(mcs, name, bases, attrs):
        if name == 'Model':
            return type.__new__(mcs, name, bases, attrs)
        print("Found Model: %s" % name)
        mapping = dict()
        fields = list()
        # 将属性保存到mapping中
        for k, v in attrs.items():
            if isinstance(v, Field):
                print('Found mapping : %s ==> %s' % (k, v))
                mapping[k] = v
                fields.append(k)
        # 将Model中的Field删除
        for k in mapping.keys():
            attrs.pop(k)

        attrs['__fields__'] = list(map(lambda f: '`%s`' % f, fields))
        attrs['__mapping__'] = mapping
        attrs['__table__'] = name
        return type.__new__(mcs, name, bases, attrs)


class Model(dict, metaclass=ModelMetaclass):
    def __init__(self, **kwargs):
        super(Model, self).__init__(kwargs)

    def __getattr__(self, key):
        try:
            return self[key]
        except KeyError:
            raise AttributeError(r"'Model' object has no attribute '%s'" % key)

    def __setattr__(self, key, value):
        self[key] = value

    def save(self):
        fields = []
        params = []
        args = []

        for k, v in self.__mapping__.items():
            print("%s------%s" % (k, v))
            fields.append(v.name)
            params.append('?')
            args.append(getattr(self, k, None))

        sql = 'insert into %s (%s) values (%s)' % (self.__table__, ','.join(self.__fields__), ','.join(params))
        print('SQL: %s' % sql)
        print('ARGS: %s' % str(args))


class User(Model):
    # 定义类的属性到列的映射:
    id = IntegerField('id')
    name = StringField('username')
    email = StringField('email')
    password = StringField('password')


u = User(id=12345, name='Michael', email='test@orm.org', password='my-pwd')
u.save()

结语

Python中的一切都是对象,它们要么是类的实例,要么是元类的实例,除了type。type实际上是它自己的元类,在纯Python环境中这可不是你能够做到的,这是通过在实现层面耍一些小手段做到的。其次,元类是很复杂的。对于非常简单的类,你可能不希望通过使用元类来对类做修改。你可以通过其他两种技术来修改类:

1)Monkey patching

  1. 类装饰器

当你需要动态修改类时,99%的时间里你最好使用上面这两种技术。当然了,其实在99%的时间里你根本就不需要动态修改类

推荐阅读更多精彩内容