type与元类
1、什么是元类
通过上文的描述，我们知道了Python中的类也是对象。元类就是用来创建这些类（对象）的，元类就是类的类，你可以这样理解为：
MyClass = MetaClass() #元类创建
MyObject = MyClass() #类创建实例
实际上MyClass就是通过type()来创创建出MyClass类，它是type()类的一个实例；同时MyClass本身也是类，也可以创建出自己的实例，这里就是MyObject2、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 Falset = Myclass()
print t.bar
t.test('xxx')True
test xxxmetaclass属性
例如：当我们写如下代码时 :
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
xxxxxxxx2、使用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)