理解Python元类——e-satis
什么是元类？我们什么时候使用它？
翻译自StackOverflow：e-satis大神的回答
类也是对象
在理解元类之前，你需要掌握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”的对象
这个对象（类）有能力创建对象（实例），这就是为什么它是一个类
但它仍然是一个对象，所以：
- 你可以把它赋值给变量
- 你可以复制它
- 你可以给它增加属性
- 你可以把它作为函数参数
e.g…
>>> 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>
动态创建类
因为类是对象，所以你可以像创建其它任何对象一样动态地创建它们。
首先，你可以在函数里使用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里的大多数事物一样，你可以手动创建它。
还记得type函数吗？这个古老而优秀的函数可以告诉你一个对象的类型是什么：
>>> print(type(1))
<type 'int'>
>>> print(type("1"))
<type 'str'>
>>> print(type(ObjectCreator))
<type 'type'>
>>> print(type(ObjectCreator()))
<class '__main__.ObjectCreator'>
其实type还有一个完全不同的能力，它可以动态地创建一个类。type可以接受一个类的描述作为参数然后返回一个类。（好吧，我知道一个函数根据参数的不同而拥有完全不同的能力是一件很蠢的事，但这是Python为了向后兼容考虑的）
type的语法如下：
type(name of the class,
tuple of the parent class (for inheritance, can be empty),
dictionary containing attributes names and values)
e.g.:
>>> 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):
...
可以转换成:
>>> 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里面类也是对象
所以元类就是创建类对象的东西，它们是类的类，你可以这样描述它们：
MyClass = MetaClass()
MyObject = MyClass()
前面我们已经知道type让我们可以像下面这样写代码：
MyClass = type('MyClass', (), {})
这是因为type这个函数实际上是元类，它是Python在背后用来创建所有类的元类
你可能想知道为什么它是以小写形式书写而不是Type ？
我猜这是为了和其他类保持一致，例如创建字符串对象的str， 创建整数对象的int，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__ 呢？
>>> age.__class__.__class__
<type 'type'>
>>> name.__class__.__class__
<type 'type'>
>>> foo.__class__.__class__
<type 'type'>
>>> b.__class__.__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的类对象（我说的是类对象，跟上我的思路）
如果Python找不到__metaclass__ 特性，它会在模块层次寻找__metaclass__ 并尝试做同样的事情（只适用于那些不继承任何类的类，基本上是旧式类)
如果仍然找不到__metaclass__ ，Python会使用Bra（类的直接父类）的__metaclass__ （它也许是默认的type）来创建这个类对象
要注意__metaclass__ 特性不会被继承，父类（Bar.__class__）的元类会被继承。如果Bar的__metaclass__ 特性使用type( )而不是type._new_( )创建Bar类，那么它的子类不会继承这一行为
那么问题来了：究竟可以往__metaclass__ 里写些什么？
答案就是：可以创建类的东西
那什么东西可以创建类？type，或者它的子类和任何使用它的东西
定制元类
使用元类的主要目的就是控制类的创建过程
当你在API中为了创建匹配当前内容的类时经常这样干。
想象一下这个愚蠢的例子：你希望在模块中所有类的特性都是大写的。当然你有好几种方法可以实现它，其中一个方法就是设置模块层次的__metaclass__ 特性。
在这种方法中，模块中的所有类都会由这个元类创建，而我们只需要告诉元类把所有类特性都转换为大写就行了。
幸运的是__metaclass__ 可以是任何可以被调用对象（callable)，它不一定是一个类（我知道，并不是所有名字里有class的就一定是类，搞清楚这点很有帮助）
那就以一个简单的例子开始吧，先写个函数：
# the metaclass will automatically get passed the same argument
# that you usually pass to `type`
def upper_attr(future_class_name, future_class_parents, future_class_attr):
"""
Return a class object, with the list of its attribute turned
into uppercase.
"""
# pick up any attribute that doesn't start with '__' and uppercase it
uppercase_attr = {}
for name, val in future_class_attr.items():
if not name.startswith('__'):
uppercase_attr[name.upper()] = val
else:
uppercase_attr[name] = val
# let `type` do the class creation
return type(future_class_name, future_class_parents, uppercase_attr)
__metaclass__ = upper_attr # this will affect all classes in the module
class Foo(): # global __metaclass__ won't work with "object" though
# but we can define __metaclass__ here instead to affect only this class
# and this will work with "object" children
bar = 'bip'
print(hasattr(Foo, 'bar'))
# Out: False
print(hasattr(Foo, 'BAR'))
# Out: True
f = Foo()
print(f.BAR)
# Out: 'bip'
现在用一个类作为元类来完成同样的工作：
# remember that `type` is actually a class like `str` and `int`
# so you can inherit from it
class UpperAttrMetaclass(type):
# __new__ is the method called before __init__
# it's the method that creates the object and returns it
# while __init__ just initializes the object passed as parameter
# you rarely use __new__, except when you want to control how the object
# is created.
# here the created object is the class, and we want to customize it
# so we override __new__
# you can do some stuff in __init__ too if you wish
# some advanced use involves overriding __call__ as well, but we won't
# see this
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__ 。再改一下：
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
# reuse the type.__new__ method
# this is basic OOP, nothing magic in there
return type.__new__(upperattr_metaclass, future_class_name,
future_class_parents, uppercase_attr)
你可能注意到了这个额外的参数：upperattr_metaclass，其实这没什么特别的，__new__ 接受它所属的类作为第一个参数，就像接受self作为第一个参数的函数和接受cls作为第一个参数的类函数
为了清楚起见，在这里我使用了很长的名字。但就像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可以让OOP的思想更清晰，这可以缩短继承链（你的元类可以继承其他元类，也可以继承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)
到这里，关于元类真的没有什么好再讲的了。
在代码中使用元类会显得复杂，这倒不是因为元类本身，而是因为我们经常使用元类做一些隐晦的工作例如内省，操控继承等。
其实，元类很适合用来实现“黑魔法”，所以有时会搞的复杂，但就元类自身而言，它们是很简单的：
- 截断类的创建
- 修改类
- 返回修改好的类
为什么使用元类而不是函数？
既然__metaclass__ 接受任何的可调用对象(callable)，为什么我们还是应该使用更复杂的类呢？
理由如下：
意图更明显。当你读到像UpperAttrMetaclass(type)这样的代码时你很清楚接下来会是什么
体现面向对象的思想。元类可以继承自其他元类，可以改写父类的方法，甚至还可以拥有自己的__metaclass__
- 如果为某个类指定了元类，那么该类的子类也是指定元类的实例
- 可以更好的组织代码。一般来说你不会把元类用于处理琐碎的（就像上面的例子）而是用于处理复杂的事物，那么把函数都封装在类里面对于提高代码可读性是很有用的。
- 你可以使用__metaclass__ ， __intit__ 和 __call__ 等函数。这些函数可以处理不同的事情（虽然你可以在__new__ 里面都处理完，噢当然了，有些人更喜欢用 __intit__
- 它的名字叫元类，该死，这肯定很难搞
为什么使用元类？
这里有个问题，为什么你要使用这些隐晦且易于出错的特性？
好吧，通常来说你根本用不上：
元类是99%的人都无需担心的黑魔法。如果你在想你什么时候需要它那么你根本不需要它（真正需要它的人知道自己为什么需要并且无需解释为什么）——Tim Peters
元类的主要用途是创建API，Django ORM就是一个典型的例子。
Django ORM允许你像下面这样定义一个类：
class Person(models.Model):
name = models.CharField(max_length=30)
age = models.IntegerField()
不过如果你这样做：
guy = Person(name='bob', age='35')
print(guy.age)
这并不会返回IntegerField对象而是返回一个int值，这个值可能是直接从数据库获取的
之所以会这样是因为models.Model定义了__metaclass__ ，它使用了一些魔法把你定义的Person转换为一个和数据库关联的复杂钩子。
通过使用元类和提供易于使用的API，Django让一些复杂的事物看起来很简单。API里面的代码在幕后完成真正的工作。
写在最后
首先，你知道了类是能创建实例的对象
实际上，类是它们的元类的实例
>>> class Foo(object): pass
>>> id(Foo)
142630324
Python里的所有事物都是对象，要么是类的实例要么是元类的实例
除了type
type实际上是它自身的元类。这不是你在纯Python环境中可以重现的东西，这是在实现层面通过一些小手段来实现的。
然后，元类是复杂的，你不会把它用于简单的类修改的。这里有两种途径可以修改类：
- monkey patching
- class decorators
当你需要修改类时，99%的情况下你应该选择这两种方法。
但是在98%的情况下你根本不需要修改类