Python黑科技之元类

本文翻译自stackoverflow的一篇回答，原地址是 what-is-a-metaclass-in-python

Python中的类

在理解元类之前，你需要了解Python中的类。Python中的类借鉴自Smalltalk。
在大多数编程语言中，类只是描述对象生成方式的一段代码，在Python里面看起来也是这样。比如下面的代码

>>> class ObjectCreator(object):pass
...
>>> my_object = ObjectCreator()
>>> print(my_object)
<__main__.ObjectCreator object at 0x1008e4a90>

但在Python中，类也是对象。是的，类是对象
class关键字声明了一个类，Python会执行class这一段代码，生成一个对象，下面的操作在内存中创建一个对象，取名为"ObjectCreator"。

>>> class ObjectCreator(object): pass

这个类可以创建自己的对象，这也是类的功能。

但是它本身也是一个对象，因此

• 可以将它赋值给一个变量
• 可以复制
• 可以往里边添加属性
• 也可以将其作为参数传入一个函数

举个例子

>>> class ObjectCreator(object): pass
...
>>> print(ObjectCreator)
<class '__main__.ObjectCreator'>
>>> def echo(o): print(o)
...
>>> echo(ObjectCreator)
<class '__main__.ObjectCreator'>
>>> ObjectCreator.new_attribute = 'foo'
>>> print(hasattr(ObjectCreator, 'new_attribute'))
True
>>> print(ObjectCreator.new_attribute)
foo
>>> ObjectCreatorMirror = ObjectCreator
>>> print(ObjectCreatorMirror.new_attribute)
foo
>>> id(ObjectCreatorMirror)
140433925632016
>>> id(ObjectCreator)
140433925632016
>>> print(ObjectCreatorMirror())
<__main__.ObjectCreator object at 0x1072342d0>

动态生成类

就像对象一样，类也可以动态生成，因为它本身就是对象。
可以在函数中用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 0x107234290>

上面的函数这也并不是那么智能，因为还是要完成得定义一个类。
既然类也是对象，那么一定有办法可以生成类。
当使用class关键字时，Python会自动创建类。和其他特性一样，Python也提供了手动创建类的方式。
还记得type这个函数吗？这个函数可以让你知道一个对象的类型：

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

这个函数还有另外的功能，就是动态创建类，它通过传入类的描述作为参数来做到这一点。
(同一个函数根据不同的参数有完全不同的两个共同，这看起来确实有点奇怪。这是Python为了向后兼容而引入的一个问题)。

可以这样使用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', (), {})
>>> print(MyShinyClass)
<class '__main__.MyShinyClass'>
>>> print(MyShinyClass())
<__main__.MyShinyClass object at 0x109250ad0>
>>>

可以看到，类的名称被当作是参数传给了type。type通过字典来定义类的属性，比如

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

等同于

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

通过type定义的类可以像用class定义的类一样使用

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

当然也可以编写子类类继承它

>>> class FooChild(Foo): pass

等同于

>>> FooChild = type('FooChild', (Foo,), {})
>>> print(FooChild)
<class '__main__.FooChild'>
>>> print(FooChild.bar)
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中类也是对象。
元类就是类的类，它用来创建类。大概像下面这样

MyClass = MetaClass()
MyObject = MyClass()

之前讲过，可以这样用type

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

可以这样用，是因为type函数实际上是一个元类，Python就是用type来创建类。

也许你会问，那为什么type不写成Type呢？
我只能猜测这是为了和str，int这样能创建对象的关键词保持一致，所以首字母用了小写。
通过查看__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.__class__
<type 'type'>

所以元类就是类的类，它创建的对象是类。
也可以叫它“工厂类”。
type是Python内置的元类，但是你也可以创建自己的元类。

__metaclass__属性

在创建一个类的时候可以加上__metaclass__属性，比如下面这样

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

如果这样写，Python会用自定义的元类来创建Foo。
小心，这样可能会带来风险。
在写class Foo(object)的时候，Foo这个类并没有在内存中创建这个类的实例。
Python会在类的定义中寻找__metaclass__这个属性，如果找到了，就用这个元类创建Foo，如果找不到，就用type来创建这个类。

所以在下面的代码中

class Foo(Bar): pass

Python会执行下面的逻辑

• Foo中有__metaclass__这个属性吗？
• 如果有，就用__metaclass__定义的元类来创建Foo这个类；
• 如果找不到__metaclass__这个属性，Python会在模块中寻找__metaclass__，如果找到了，就用它来创建Foo这个类；
• 如果还是找不到，Python会用Bar的元类（应该是type）来创建Foo这个类。

注意，子类不会继承__metaclass__这个属性，但是会继承父类的元类。就是说，如果Bar使用__metaclass__这个属性来创建Bar这个类，子类不会继承这个行为。
现在问题来了，__metaclass__里面的内容可以是什么呢？
答案是：可以创建类的内容
什么可以创建一个类呢？type，type的子类，或者用到了type的类

自定义元类

元类的主要作用是在创建类的时候改变这个类。
根据当前的上下文创建类，这个特性可以用来开发API。
举个简单例子，现在你想要模块中所有的类中的属性都是大写开头的。有很多种方式来实现这一点，现在我们通过使用修改模版中的__metaclass__属性来做到这一点。
这样，这个模块中所有的类都会用自定义的元类来创建，我们只需要在元类中将类中的所有属性首字母改成大写。
幸运的是，__metaclass__是可以被调用的，所以不必是“类”。
下面来看看例子吧

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
    return type(future_class_name, future_class_parents, uppercase_attr)

__metaclass__ = upper_attr


class Foo():
    bar = 'bip'

print(hasattr(Foo, 'bar'))
# 输出: False
print(hasattr(Foo, 'BAR'))
# 输出: True
f = Foo()
print(f.BAR)
# 输出：bip

现在我们用类来实现一个元类

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
        return type(future_class_name, future_class_parents, uppercase_attr)

但是上面的方法没有用到type类中的方法，我们可以通过调用type中的__new__方法来实现

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
        return type.__new__(upperattr_metaclass, future_class_name,
                            future_class_parents, uppercase_attr)

可能你注意到了上面代码中的upperattr_metaclass参数，这没有什么特别的，__new__方法总是会将定义它的类作为第一个参数传入，这就和self一样，上面的例子中，把
upperattr_metaclass打印出来，可以看到类似<class '__main__.UpperAttrMetaclass'>的结果。
当然，这里的取名只是为了说清明这些变量，但就和self一样，这些参数都有固定的取名，比如下面这样

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)

为了让UpperAttrMetaclass继承自type这一特性表现的更清楚，可以使用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)

代码中使用元类，可以实现一些黑科技。而元类本身只实现下面的功能。

• 中断类的创建
• 修改类
• 返回修改后的类

元类实现的取舍

既然__metaclass__可以是任意可调用的对象，为什么要用类而不是函数来实现它呢？

主要考虑到下面几个原因

• 语义上更清晰。
• 面向对象。元类可以继承自元类，元类甚至可以使用元类。
• 代码结构更清晰。
• 可以根据不同想法，在__new__,__init__,__call__不同的函数中实现不同的功能
• 既然都叫元类了，那肯定就是类嘛！

为什么要使用元类

现在还有一个问题，为什么要使用这样一个令人费解的功能呢？
当然，一般情况下，这个功能不会被用到

99%的人都不会用到元类，如果你还在想是否要用它，那么你就不需要用到它（真正有需求用它的人不会问这个问题） Python Guru Tim Peters

元类的主要功能是用来开发API。一个典型的例子就是Django ORM，它可以这样定义一个model

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

但是下面的代码却不会返回一个IntegerField的对象，而是返回一个int，甚至可以从数据库中去取这个值。

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

之所以能这样实现，是因为model.Model中定义了__metaclass__，通过定义的元类将Person类转换成一条SQL语句。
Django通过元类将代码改写，这样就可以只暴露简单的API，而实现复杂的功能。

结语

类可以用来创建对象。
而事实上，类本身也是对象，元类的对象。

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

Python中万物都是对象，它们要么是类的实例，要么是元类的实例。
除了type。
type是它自己的元类，Python在实现层面，做了一些工作来实现这一点。
元类是很复杂的。比较简单的场景不一定要用到它，要改变一个类，可以通过下面两种技术实现

• monkey patching
• 装饰器

如果需要改变类的行为，99%情况下应该使用上面的两种方法。
但是99%情况下，根本就不需要改变类的行为

“本译文仅供个人研习、欣赏语言之用，谢绝任何转载及用于任何商业用途。本译文所涉法律后果均由本人承担。本人同意简书平台在接获有关著作权人的通知后，删除文章。”