深入理解Python-1.什么是元类(metaclass)

1)类作为对象

在理解元类之前,你需要掌握Python中的类(class)。对于类是什么,Python有独特的看法,这借鉴于Smalktalk。

在大部分语言中,类仅仅是描述如何去产生一个对象的代码片段,在Python中也一样。

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

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

但是类在Python中不仅仅是这样,类也是对象。

当你使用关键字class时,Python执行它并创建了一个对象。这个语句

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

在内存中创建了一个名为“ObjectCreator”的对象。

这个对象(这个类)本身是能够创建对象(实例)的,这也是称之为类的原因。

但是,它仍然是一个对象,因此:

  • 你可以把它赋值给一个变量;
  • 你能复制它;
  • 你能给它添加属性;
  • 你能将它作为一个函数参数传递。

例如:

>>> print(ObjectCreator) # you can print a class because it's an object
<class '__main__.ObjectCreator'>
>>> def echo(o):
...       print(o)
...
>>> echo(ObjectCreator) # you can pass a class as a parameter
<class '__main__.ObjectCreator'>
>>> print(hasattr(ObjectCreator, 'new_attribute'))
False
>>> ObjectCreator.new_attribute = 'foo' # you can add attributes to a class
>>> print(hasattr(ObjectCreator, 'new_attribute'))
True
>>> print(ObjectCreator.new_attribute)
foo
>>> ObjectCreatorMirror = ObjectCreator # you can assign a class to a variable
>>> print(ObjectCreatorMirror.new_attribute)
foo
>>> print(ObjectCreatorMirror())
<__main__.ObjectCreator object at 0x8997b4c>

2)动态地创建类

因为类是对象,你能动态地创建它们,就像其他对象一样。

首先,你可以在一个函数中使用class创建一个类。

>>> def choose_class(name):
...     if name == 'foo':
...         class Foo(object):
...             pass
...         return Foo # return the class, not an instance
...     else:
...         class Bar(object):
...             pass
...         return Bar
...
>>> MyClass = choose_class('foo')
>>> print(MyClass) # the function returns a class, not an instance
<class '__main__.Foo'>
>>> print(MyClass()) # you can create an object from this class
<__main__.Foo object at 0x89c6d4c>

但是这不够动态,因为你仍然需要去完整地定义这个类。

因为类是对象,它们肯定能用其他方式生成。

当你使用class这个关键字时,Python自动创建了这个对象。但是正如在Python中做的大部分事情一样,Python同样提供了手动触发的方式。

还记得函数type吗?一个古老而又有用的函数,能够让你知道一个对象的类型是什么。

>>> print(type(1))
<type 'int'>
>>> print(type("1"))
<type 'str'>
>>> print(type(ObjectCreator))
<type 'type'>
>>> print(type(ObjectCreator()))
<class '__main__.ObjectCreator'>

type还有一个完全不同的功能,它也动态地创建对象。type能够接受一个类的描述作为参数,然后返回一个类。

type可以这样用:

type(name of the class,
     tuple of the parent class (for inheritance, can be empty),
     dictionary containing attributes names and values)

例如:

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

能用这种方式手动创建。

>>> MyShinyClass = type('MyShinyClass', (), {}) # returns a class object
>>> print(MyShinyClass)
<class '__main__.MyShinyClass'>
>>> print(MyShinyClass()) # create an instance with the class
<__main__.MyShinyClass object at 0x8997cec>

你将注意到,我们使用”MyShinyClass“作为这个类的名称,同样作为变量的名称,并将类引用赋值给它。它们可能有点区别,但是没必要把事情搞复杂。

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

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

能这样表达

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

而且被用来作为一个普通的类。

>>> print(Foo)
<class '__main__.Foo'>
>>> print(Foo.bar)
True
>>> f = Foo()
>>> print(f)
<__main__.Foo object at 0x8a9b84c>
>>> print(f.bar)
True

当然,你也能继承它,因此:

>>>   class FooChild(Foo):
...         pass

等价于

>>> FooChild = type('FooChild', (Foo,), {})
>>> print(FooChild)
<class '__main__.FooChild'>
>>> print(FooChild.bar) # bar is inherited from Foo
True

最终,你需要添加给这个类添加一些方法。仅需要定义好函数,并将它赋值给一个属性即可。

>>> def echo_bar(self):
...       print(self.bar)
...
>>> FooChild = type('FooChild', (Foo,), {'echo_bar': echo_bar})
>>> hasattr(Foo, 'echo_bar')
False
>>> hasattr(FooChild, 'echo_bar')
True
>>> my_foo = FooChild()
>>> my_foo.echo_bar()
True

而且,甚至在类动态创建之后,你也能添加更多的方法,就像给一个普通创建的类对象添加方法一样。

>>> def echo_bar_more(self):
...       print('yet another method')
...
>>> FooChild.echo_bar_more = echo_bar_more
>>> hasattr(FooChild, 'echo_bar_more')
True

如你所见:在Python中,类也是对象,而且你能动态地创建一个类。

这就是当你使用class这个关键字时Python所做的,Python使用元类来完成这项工作。

3)什么是元类

元类就是我们创建对象的东东。

你定义一个类是为了创建对象,对吗?

但是刚才我们了解到了Python类也是对象。

元类是创建这些对象的东东。他们是类的类,你可以用这种方式去描述它。

MyClass = MetaClass()
my_object = MyClass()

我们已经看到了type能让你像这样做。

MyClass = type('MyClass', (), {})

这是因为type这个函数事实上是一个元类。type是Python在背后用来创建所有类的元类。

现在你可能想知道,为什么type首字母要小写,而不是写成Type

我猜,这与语言一致性有关,例如str是创建字符串对象的类,int是创建整数对象d的类,type就是用来创建类对象的类。

你可以检查__class__属性看到。

在Python中一切皆对象。包括整数、字符串、函数和类。它们都是对象,而且它们都是由类产生的。

>>> age = 35
>>> age.__class__
<type 'int'>
>>> name = 'bob'
>>> name.__class__
<type 'str'>
>>> def foo(): pass
>>> foo.__class__
<type 'function'>
>>> class Bar(object): pass
>>> b = Bar()
>>> b.__class__
<class '__main__.Bar'>

现在,如何__class____class__是什么呢?

>>> age.__class__.__class__
<type 'type'>
>>> name.__class__.__class__
<type 'type'>
>>> foo.__class__.__class__
<type 'type'>
>>> b.__class__.__class__
<type 'type'>

因此,元类就是创建类对象的东东。

如果你愿意,可以称它为"类工厂"。

type是Python使用的内置的元类,当然,你也能创建自己的元类。

4)__metaclass__ 属性

当你定义一个类时,可以添加一个__metaclass__属性。

class Foo(object):
    __metaclass__ = something...
    [...]

如果你这样做的话,Python将使用这个元类去创建类Foo

小心,这有陷阱。

你首先写了class Foo(object),但是这个类对象Foo在内存中并没有被创建。

Python将在类定义中寻找__metaclass__如果Python发现了它,Python将使用它去创建类对象Foo,如果没有,Python将使用type去创建这个类。

重温几次。

当你定义:

class Foo(Bar):
    pass

Python将做以下事情: 在Foo中有__metaclass__属性吗?

如果有,就使用__mataclass__中定义的东东在内存中创建类对象,类名为Foo

如果Python没有找到__metaclass__属性,它将在MODULE层寻找一个__metaclass__,去做相同的事情(对于类,不继承任何东西,基础的老式类)。

然后如果Python不能找到任何的__metaclass__,它将使用Bar(第一个父类)自己的元类(可能是type)去创建类对象。

这里小心__metaclass__属性将不会被继承,父类的元类(Bar.__class__)会被继承。如果Bar使用了一个用type(不是type.__new__())创建Bar__metaclass__属性,那么它的子类将会继承这个行为。

现在最大的问题是,你能在__metaclass__中定义什么?

答案就是,能够创建类的东东。

什么能创建类呢?type,或者它的子类,或者用了它的任何东西。

5)自定义元类

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

经常为了API这么做,API中需要创建类去匹配当前的上下文。

想象一个非常蠢的例子,你决定你的模块中的所有类它们的属性应该大写。有好几种方式可以完成这件事,其中一种方式就是在模块层设置__metaclass__

使用这种方式,模块内所有的类都会使用这个元类创建,而且我们必须告诉元类要将所有的属性转为大写。

幸运的是,__metaclass__确实是可调用的,它不需要是一个正式的类(在名字中带有类,但是不必要是一个类,区分一下,但是这很有用)。

接下来我们使用函数写个简单的例子。

# coding=utf-8
# 适用于python2
# 元类将自动获取到相同的你经常传给`type`的参数。
# 即参数列表与`type`的一致。
def upper_attr(future_class_name, future_class_parents, future_class_attr):
    """
      将属性名转为大写后,返回一个类对象。
    """

    # 筛选出所有不以__开头的属性,转为大写。
    uppercase_attr = {}
    for name, val in future_class_attr.items():
        if not name.startswith('__'):
            uppercase_attr[name.upper()] = val
        else:
            uppercase_attr[name] = val

    # 使用type创建类
    return type(future_class_name, future_class_parents, uppercase_attr)

__metaclass__ = upper_attr # 这将影响这个模块内的所有类。

class Foo(): # 虽然全局的 __metaclass__ 对 “object”无效
    # 但是我们可以在这里定义 __metaclass__ 而不是仅仅影响这个类。
    # 这将影响“object”的children
    bar = 'bip'

print(hasattr(Foo, 'bar'))
# Out: False
print(hasattr(Foo, 'BAR'))
# Out: True

f = Foo()
print(f.BAR)
# Out: 'bip'

现在,我们用一个真实的类作为元类去做相同的事情。

# coding=utf-8
# 记住`type`事实上是一个类似于`str`和`int`的类
# 所以你能继承它
class UpperAttrMetaclass(type):
    # __new__ 方法在 __init__ 前执行,这个方法创建对象并返回。
    # __init__方法仅仅初始化作为参数传入的对象。
    # 你很少使用__new__方法,除非你想控制类是如何创建的。
    # 这里创建的对象是一个类,我们想自定义它,因此需要覆盖 __new__。
    # 你也能在__init__中做一些事情,如果愿意的话。
    # 一些高级用法还包括覆盖__call__方法,这里不使用。
    def __new__(upperattr_metaclass, future_class_name,
                future_class_parents, future_class_attr):

        uppercase_attr = {}
        for name, val in future_class_attr.items():
            if not name.startswith('__'):
                uppercase_attr[name.upper()] = val
            else:
                uppercase_attr[name] = val

        return type(future_class_name, future_class_parents, uppercase_attr)

事实上这并不OOP,我们直接调用了type函数,没有覆盖或者是调用父类的__new__,改一下:

# coding=utf-8
class UpperAttrMetaclass(type):

    def __new__(upperattr_metaclass, future_class_name,
                future_class_parents, future_class_attr):

        uppercase_attr = {}
        for name, val in future_class_attr.items():
            if not name.startswith('__'):
                uppercase_attr[name.upper()] = val
            else:
                uppercase_attr[name] = val

        # 重用了type.__new__方法,这种写法是OOP的
        return type.__new__(upperattr_metaclass, future_class_name,
                            future_class_parents, uppercase_attr)

你可能注意到额外的参数upperattr_metaclass,这没什么特别的:__new__方法总是接受定义的类作为第一个参数,就像普通方法接受实例作为第一个参数传入self,类方法传入定义类一样。

当然,为了可读性,我在这里使用的名字太长了。但是就如self一样,所有的参数都有约定俗成的名字,因此一个真实的正式的metaclass应该像这样写:

class UpperAttrMetaclass(type):

    def __new__(cls, clsname, bases, dct):

        uppercase_attr = {}
        for name, val in dct.items():
            if not name.startswith('__'):
                uppercase_attr[name.upper()] = val
            else:
                uppercase_attr[name] = val

        return type.__new__(cls, clsname, bases, uppercase_attr)

我们使用super让代码看上去更清晰一些,

class UpperAttrMetaclass(type):

    def __new__(cls, clsname, bases, dct):

        uppercase_attr = {}
        for name, val in dct.items():
            if not name.startswith('__'):
                uppercase_attr[name.upper()] = val
            else:
                uppercase_attr[name] = val

        return super(UpperAttrMetaclass, cls).__new__(cls, clsname, bases, uppercase_attr)

以上就是全部了,关于元类已经没有什么内容了。

使用元类的代码复杂的原因并不在于元类本身,而是因为你经常使用元类去做一些扭曲的事情,操纵继承,遍历属性(vars)例如__dict__等等。

事实上,元类在做一些黑科技时非常有用,因此往往是一些复杂的东西。但是就元类本身而言,是简单的。

  • 拦截类的创建。
  • 修改类。
  • 返回修改后的类。

6)为什么使用元类时用类而不用函数?

因为__metaclass__能够接受任何可调用的东西,为什么要去使用明显更为复杂的类呢?

这么做有几个原因:

  • 目的更明确,当你阅读UpperAttrMetaclass(type),你知道接下来会发生什么。
  • 更OOP。元类能够继承元类,覆盖父类的方法。元类甚至能使用元类。
  • 一个类的子类可以是它的元类的实例如果你指定了一个元类类(metaclass-class),而不是一个元类函数(metaclass-function)。
  • 能更好地组织代码。你从来没有像上面的例子这样试验性地使用元类。元类经常用于一些复杂场景。为了代码可读性,将好几个方法组织在一个类中的能力是非常重要的。
  • 你能覆盖__new____init____call__,这些方法将允许你做不同的事情。即时即经常只需要修改__new__,一些人觉得使用__init__更舒服。
  • 它们被称为元类,实际就应该和它的名称一致。

7)为什么使用元类

现在最大的问题,为什么要使用这么晦涩的容易出错的特性?

通常不要用:

元类是深魔法,99%的用户都不需要关心它。如果你在想是否需要它们,就不要用(需要元类的人确切地知道需要它,无需解释)。 Python Guru Tim Peters

元类主要的使用场景是创建API,一个典型的例子是Django的ORM。

它允许你去这样定义:

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

但是如果你这样做:

guy = Person(name='bob', age='35')
print(guy.age)

它将不会返回一个IntegerFiled对象,它将返回一个int,而且甚至直接传给数据库。

这是可能的,因为models.Model定义了__metaclass__而且进行了一些特殊处理,将你刚刚简单几句话定义的Person转变为数据库字段的复杂钩子。

Django通过使用元类暴露简单的API,让一些复杂的事情看上去简单,通过这些API背后重新创建代码去做真实的事情。

8)最后一点

首先,你知道类是能够创建实例的对象。

事实上,类本身就是对象,元类也是。

>>> class Foo(object): pass
>>> id(Foo)
142630324

Python中一切皆对象,而且他们也是类的实例或类的实例。

除了type

type确实是自己的元类,这只用Python是产生不了的,这是在实现层面做的。

第二,元类是复杂的。你可能想去使用他们去做简单的类修改。你能使用2种其他的技术去做这件事。

类修改99%的场景适合以上方式。

但是98%的场景,根本不需要去修改类。

9)Python3补充

Python3和Python2中元类使用有区别。

以下是使用元类实现追踪类定义顺序的例子。

class MyMeta(type):

    counter = 0

    def __init__(cls, name, bases, dic):
        type.__init__(cls, name, bases, dic)
        cls._order = MyMeta.counter
        MyMeta.counter += 1

class MyType(object):              # Python 2
    __metaclass__ = MyMeta

class MyType(metaclass=MyMeta):    # Python 3
    pass

Python3中元类有2个关键的方法。

  • __prepare__
  • __new__

__prepare__让你提供一个自定义的字典(例如OrderedDict)作为元类创建时的命名空间。无论选择什么命名空间,都必须返回一个实例。如果没有实现__prepare__,将会使用一个普通的dict

class Meta(type):

    def __prepare__(metaclass, cls, bases):
        return dict()

    def __new__(metacls, cls, bases, clsdict):
        return super().__new__(metacls, cls, bases, clsdict)

标签:

本站使用 「署名 4.0 国际」 创作共享协议,转载请注明出处