type与元类

原文

1、什么是元类

通过上文的描述，我们知道了Python中的类也是对象。元类就是用来创建这些类（对象）的，元类就是类的类，你可以这样理解为：

MyClass = MetaClass()    #元类创建
MyObject = MyClass()     #类创建实例
实际上MyClass就是通过type()来创创建出MyClass类，它是type()类的一个实例；同时MyClass本身也是类，也可以创建出自己的实例，这里就是MyObject

2、type

type我们经常用来查看对象类型，如

print type(int),type(2017)
print type(str),type('共产党好')

<type 'type'> <type 'int'>
<type 'type'> <type 'str'>

class Example(object):
    pass
print type(Example),type(Example())
class A(Example):
    pass
print type(A),type(A())

<type 'type'> <class '__main__.Example'>
<type 'type'> <class '__main__.A'>

那么type为什么有这么大的能力呢，正所谓能力越大，责任越大，python中所有类都是通过type创建的

help(type)

Help on class type in module __builtin__:

class type(object)
 |  type(object) -> the object's type
 |  type(name, bases, dict) -> a new type
......

type类继承object,type(name, bases, dict) -> a new type，返回一个新的类

创建类，并且添加属性与方法

def test(self, name):
    print 'test',name
Myclass = type('Myclass', (Example,), {'bar':True, 'test':test})
print hasattr(Myclass, 'bar'), hasattr(Example, 'bar')

True False

t = Myclass()
print t.bar
t.test('xxx')

True
test xxx

metaclass属性

例如：当我们写如下代码时 :

class Foo(Bar):
    pass

在该类并定义的时候，它还没有在内存中生成，知道它被调用。Python做了如下的操作：
1）Foo中有metaclass这个属性吗？如果是，Python会在内存中通过metaclass创建一个名字为Foo的类对象（我说的是类对象，请紧跟我的思路）。
2）如果Python没有找到metaclass，它会继续在父类中寻找metaclass属性，并尝试做和前面同样的操作。
3）如果Python在任何父类中都找不到metaclass，它就会在模块层次中去寻找metaclass，并尝试做同样的操作。
4）如果还是找不到metaclass,Python就会用内置的type来创建这个类对象。

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

自定义元类

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

metaclass实际上可以被任意调用，它并不需要是一个正式的类。所以，我们这里就先以一个简单的函数作为例子开始。

1、使用函数当做元类

def upper_attr(future_class_name, future_class_parents, future_class_attr):
    attr = ((name, value) for name,value in future_class_attr.items() if not name.startswith('__'))
    upper_future_class_attr = dict((name.upper(), value) for name, value in attr)
    return type(future_class_name, future_class_parents,upper_future_class_attr)

class Test(object):
    __metaclass__ = upper_attr
    aaa = 'AAAA'
    def bbb(self, param):
        print param
    
t = Test()
print t.AAA
t.BBB('xxxxxxxx')

把属性全部变成大写了

AAAA
xxxxxxxx

2、使用class来当做元类

由于metaclass必须返回一个类。

# 请记住，'type'实际上是一个类，就像'str'和'int'一样。所以，你可以从type继承
# __new__ 是在__init__之前被调用的特殊方法，__new__是用来创建对象并返回之的方法，__new_()是一个类方法
# 而__init__只是用来将传入的参数初始化给对象，它是在对象创建之后执行的方法。
# 你很少用到__new__，除非你希望能够控制对象的创建。这里，创建的对象是类，我们希望能够自定义它，所以我们这里改写__new__
# 如果你希望的话，你也可以在__init__中做些事情。还有一些高级的用法会涉及到改写__call__特殊方法，但是我们这里不用，下面我们可以单独的讨论这个使用

class UpperAttrMetaClass(type):
    def __new__(upperattr_metaclass, future_class_name, future_class_parents, future_class_attr):
        attrs = ((name, value) for name, value in future_class_attr.items() if not name.startswith('__'))
        uppercase_attr = dict((name.upper(), value) for name, value in attrs)
        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):
        attrs = ((name, value) for name, value in future_class_attr.items() if not name.startswith('__'))
        uppercase_attr = dict((name.upper(), value) for name, value in attrs)
 
        # 复用type.__new__方法
        # 这就是基本的OOP编程，没什么魔法。由于type是元类也就是类，因此它本身也是通过__new__方法生成其实例，只不过这个实例是一个类.
        return type.__new__(upperattr_metaclass, future_class_name, future_class_parents, uppercase_attr)

你可能已经注意到了有个额外的参数upperattr_metaclass，这并没有什么特别的。类方法的第一个参数总是表示当前的实例，就像在普通的类方法中的self参数一样。当然了，为了清晰起见，这里的名字我起的比较长。但是就像self一样，所有的参数都有它们的传统名称。因此，在真实的产品代码中一个元类应该是像这样的：

class UpperAttrMetaclass(type):
    def __new__(cls, name, bases, dct):
        attrs = ((name, value) for name, value in dct.items() if not name.startswith('__')
        uppercase_attr  = dict((name.upper(), value) for name, value in attrs)
        return type.__new__(cls, name, bases, uppercase_attr)
class Test(object):
    __metaclass__ = UpperAttrMetaClass
    def myprint(self, param):
        print param
    aaaa = 22222

t = Test()
print t.AAAA
t.MYPRINT('xxx')

如果使用super方法的话，我们还可以使它变得更清晰一些。

class UpperAttrMetaclass(type):
    def __new__(cls, name, bases, dct):
        attrs = ((name, value) for name, value in dct.items() if not name.startswith('__'))
        uppercase_attr = dict((name.upper(), value) for name, value in attrs)
        return super(UpperAttrMetaclass, cls).__new__(cls, name, bases, uppercase_attr)