2018-01-31

【转】python元类介绍

python元类

转自stackoverflow 神级人物e-satis的神级回复，以及国内翻译组汉化结果：

写在前面：

经常在stackoverflow上看见一些神一般的回答，也看到过很多次创建Foo类，特意上维基百科搜了，解释如下：

1
2
3

foobar是计算机程序领域里的术语炒作，并无实际用途和参考意义。 在计算机程序设计与计算机技术的相关文档中，术语foobar是一个常见的无名氏化名，常被作为“伪变量”使用。单词“foobar”或分离的“foo”与“bar”常出现于程序设计的案例中，如同Hello World程序一样，它们常被用于向学习者介绍某种程序语言。

“foo”常被作为函数／方法的名称，而“bar”则常被用作变量名。

正题

类也是对象（Classes as objects）

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

class ObjectCreator(object):
    pass
my_object = ObjectCreator()
print(my_object)

<__main__.ObjectCreator object at 0x000001899B36E550>

但是python中的类远不止如此。类同样也是一种对象 这个对象（类）自身用创建对象（类实例）的能力，而这就是为什么它是一个类的原因。但是，它本质上仍然是一个对象，所以，你可以对它进行如下操作：
1、将它赋值给一个变量
2、拷贝它
3、为它增加属性
4、将它作为函数参数进行传递

示例：

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

动态地创建类

因为类也是对象，你可以在运行时动态地创建它们，就想其他任何时候一样。首先，你可以在函数中创建类，使用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)
print(MyClass())
<class '__main__.choose_class.<locals>.Foo'>
<__main__.choose_class.<locals>.Foo object at 0x000002B57928B518>

但这还不够动态，因为你仍然需要自己编写整个类的代码。由于类也是对象，所以它们必须是用过什么东西来生成的才对。当你使用class关键字时，Python解释器自动创建这个对象，但就和python中的大多数事情一样，python仍然提供给你手动处理的方法。內建函数type，可以让你知道一个对象的类型是什么：

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

这里，type有一种完全不同的能力，它也能动态的创建类。type可以接受一个类的描述作为参数，然后返回一个类（同一个函数拥有两种完全不同的用法是一件很傻的事情，但这在Python中是为了保持向后的兼容性）

type可以像这样工作：

1	type(类名, 父类的元组（针对继承的情况，可以为空），包含属性的字典（名称知道）)

比如如下的代码：

1 2	class MyShinyClass(object): pass

可以手动像这样创建：

# 返回一个对象
MyShinyClass = type('MyShinyClASS', (), {})
print(MyShinyClass)
print(MyShinyClass())
<class '__main__.MyShinyClASS'>
<__main__.MyShinyClASS object at 0x00000214ED6FE5F8>

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

1 2	class Foo(object): bar = True

可以翻译为：

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

并且可以将Foo当做一个普通的类一样使用：

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

当然，你可以向这个类继承，所以，如下的代码：

1 2	class FooChild(Foo): pass

就可以写成：

1
2
3

FooChild = type('FooChild', (Foo,), {})
print(FooChild)
print(FooChild.bar)

到底什么是元类

元类就是用来创建类的“东西”，你创建类就是为了创建类的实例对象，但是我们知道python中的类也是对象，而元类就是用来创建这些类（对象）的，所以，元类就是类的类，可以这样理解：

1 2	MyClass = MetaClass() MyObject = MyClass()

你可以看到了type可以让你像这样做：

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

这是因为函数type实际上是一个元类，type就是python背后用来创建所有类的元类，所以type为什么不写成Type也就知道了吧，或许就是为了和str保持一致性，str是用来创建字符串对象的类，而int是用来创建整数对象的类。type即使创建类对象的类。你可以通过__class__属性来看到这一点。Python中的所有的东西，注意，所有的东西——都是对象。这包含整数、字符串、函数和类。它们都是对象，而且它们都是从一个类创建来的。

age = 24
print(age.__class__)
name = 'bob'
print(name.__class__)
def foo():
    pass
print(foo.__class__)
<class 'int'>
<class 'str'>
<class 'function'>

现在，对于任何一个__class__的__class__属性又是什么呢？

print(age.__class__.__class__)
print(name.__class__.__class__)
print(foo.__class__.__class__)
<class 'type'>
<class 'type'>
<class 'type'>

因此，元类就是窗累类这种对象的东西，如果你喜欢的话，可以把元类称谓”类工厂”（不是工厂类）,type就是python內建的元类，当然了，你也可以创建自己的元类。

`metaclass`属性

你可以在写一个类的时候为其添加__metaclass__属性。

1
2
3

class Foo(object):
    __metaclass__ = somethind,.,
[...]

如果你这么做了，python就会用元类来创建类Foo。这里面有技巧，你首先写下class Foo(object)，但是类对象Foo还没有在内存中创建。Python会在类的定义中寻找__metaclass__属性，如果找到了，Python就会用它创建类Foo，如果没找到，就会用內建的type来创建这个类。

当你写下如下代码时：

1 2	class Foo(Bar): pass

Python做了如下的操作：

Foo中有__metaclass__这个属性吗？如果有，python会在内存中通过__metaclass__创建一个名字为Foo的类对象（注意是类对象）。如果python没有找到__metaclass__，它会继续在Bar（父类）中寻找__metaclass__属性，并尝试做和前面同样的操作。如果python在任何父类中都找不到__metaclass__，它就会在模块层面中去寻找__metaclass__，并尝试做同样的操作。如果还是找不到__metaclass__，python就会用内置的type来创建这个类对象。

现在的问题就是，你可以在__metaclass__中放置些什么代码呢？答案是：可以是可以创建一个类的东西。那什么可以用来创建一个类呢？type，或者任何使用到type或者子类化type的东西都可以。

自定义元类

元类的主要目的就是为了当创建类时能够自动地改变类。通常，你会为API做这样的事情，你希望可以创建符合当前上下文的类。假想一个很傻的例子，你决定你的模块里所有的类的属性都应该是大写形式，有好几种方法可以实现，单其中一种就是通过在模块级别设定__metaclass__，采用这种方法，这个模块中的所有类都会通过这个元类来创建，我们只需要告诉元类把所有的属性都改写成大写形式就解决了。

幸运的是，__metaclass__实际上可以被任意调用，它并不需要是一个正式的类（我们都知道，名字里面带’class’的东西，并不一定是个class）

我们这里先以一个简单的函数作为例子开始：

# 元类会自动将你通常传给'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__来只对这个类生效
    bar = 'bip'

print(hasattr(Foo, 'bar'))
print(hasattr(Foo, 'BAR'))

现在让我们再做一次，这一次用一个真正的class来当元类

# 请记住，'type'实际上是一个类，就像'str'和'int'一样
# 所以，你可以从type继承
class UpperAttrMetaclass(type):
    # __new__ 是在 __init__之前被调用的特殊方法
    # __new__是用来创建对象并返回的方法
    # __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_at

但是这不是OOP（Object-oriented programming，面向对象编程）。我们直接调用了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

        # 复用type.__new__方法
        # 这就是基本的OOP编程，没什么魔法
        return type.__new__(upperattr_metaclass, future_class_name, 
                            future_class_parents, uppercase_attr)

你可以已经注意到了有个额外的参数uppersttr_metaclass，这并没有什么特别的。类方法的第一个参数总是表示当前的实例，就想在普通的类方法中的self参数一样。当然了，为了清晰起见，这边将名字起的比较长。但是就想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)

如果使用super方法的话，我们还可以使它变得更清晰一些，这会缓解继承（是的，你可以拥有元类，从元类继承，从type继承）

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)

就是这样，除此之外，关于元类真的没有别的可说的了。使用到元类的代码比较复杂，这背后的原因倒不是因为元类本身，二十因为你通常会使用元类去做一些晦涩的事情，依赖于自省，控制继承等等。确实，用元类来搞些“黑魔法”是特别有用的，因而会搞出些复杂的东西来。但是元类本身而言，它们其实是很简单的：

1，拦截类的创建
2，修改类
3，返回修改之后的类

为什么要用metaclass类而不是函数

由于__metaclass__可以接受任何可调用的对象，那为什么还要使用类呢，因为很显然使用类会更加复杂，这里有好几个原因：

1，意图会更加清晰，当你读到UpperAttrMetaclass(type)时，你知道接下来要发生什么
2，你可以使用OOP编程。元类可以从元类中继承，改写父类方法，甚至可以使用元类
3，你可以把代码组织的更好，当你使用元类的时候肯定不会像上述的简单场景，通常都是针对比较复杂的问题。将多个方法归总到一个类中会很有帮助，也会使得代码更容易阅读。
4，你可以使用__new__，__init__以及__call__这样的特殊方法。它们能帮你处理不同的任务。就算通常你可以把所有的东西都在__new__里处理掉，有些人还是觉得用__init__更舒服点。

究竟为什么要使用元类

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

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

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

1
2
3

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

但是如果你像这样做的话：

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

这并不会返回一个IntegerFied对象，而是会放回一个int，甚至可以直接从数据库中取出数据。这是有可能的，因为models.Model定义了__metaclass__，并且使用了一些魔法能够将你刚刚定义的简单的Person类转变成对数据库的一个复杂hook。Django框架将这些看起来很复杂的东西通过暴露出一个简单的使用元类的API将其化简，通过这个API重新创建代码，在背后完成真正的工作。

结语

首先，你知道了类其实是能够创建出类实例的对象。事实上，类本身也是实例，当然，它们是元类的实例：

class Foo(object):
    pass
print(id(Foo))
1973075749880

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

1 2	Monkey patching class decorators

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

原链接

stackoverflow原链接
 国内翻译站

本文标题:【转】python元类介绍

文章作者:Kyle

发布时间:2018-01-31, 07:26:59

最后更新:2020-12-21, 14:39:16

原始链接:https://spindriftks.github.io/2018/01/31/%E3%80%90%E8%BD%AC%E3%80%91python%E5%85%83%E7%B1%BB%E4%BB%8B%E7%BB%8D/

许可协议: "署名-非商用-相同方式共享 4.0" 转载请保留原文链接及作者。