python中的元类

类也是对象，但是类有创建对象的能力

动态创建一个类：

class monkey():
    def banana(self):
        print 'banana!'

def apple(self):
    print 'i want apple!'

monkey_child = type('monkey_child', (monkey,), {'apple': apple})

hasattr(monkey, 'apple')
false
hasattr(monkey_child, 'apple')
true

type的语法：type(类名, 父类的元组（针对继承的情况，可以为空），包含属性的字典（名称和值）)

创建类的就是元类，type是所有类的元类，类属性__class__可以看到元类是什么

>>> a=1
>>> type(a)
<type 'int'>
>>> type(a.__class__)
<type 'type'>

 

创建一个类的过程：搜索__metaclass__是否有指定，否则搜索父类中的__metaclass__，最终应该找到type或是type的子类

 

由于python中鸭子类型的概念，__metaclass__实际上不一定是一个类，也可以是一个函数

def upper_attr(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)

class Foo(object):
    __metaclass__ = upper_attr
    bar = 'aip'

print Foo.BAR
>>>'aip'

 在Python3中我们在定义类时通过传入metaclass的参数来设定，如上代码就应该写成class Foo(metaclass=upper_attr)。

 

metaclass可以是一个类

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)

__new__在__init__之前被调用，用于创建和返回对象，由__new__是一个类方法，我们需要传入实例对象cls。

为了表明继承关系，以上代码可以写成

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)

 

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

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

1）  意图会更加清晰。当你读到UpperAttrMetaclass(type)时，你知道接下来要发生什么。

2） 你可以使用OOP编程。元类可以从元类中继承而来，改写父类的方法。元类甚至还可以使用元类。

3）  你可以把代码组织的更好。当你使用元类的时候肯定不会是像我上面举的这种简单场景，通常都是针对比较复杂的问题。将多个方法归总到一个类中会很有帮助，也会使得代码更容易阅读。

4） 你可以使用__new__, __init__以及__call__这样的特殊方法。它们能帮你处理不同的任务。就算通常你可以把所有的东西都在__new__里处理掉，有些人还是觉得用__init__更舒服些。

 

 

根据http://python3-cookbook.readthedocs.io/zh_CN/latest/c08/p07_calling_method_on_parent_class.html 可以知道，我们应该在继承并改写的代码中尽量使用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)

 

参考：http://blog.jobbole.com/21351/

其中有一个Django的ORM的例子，学习之