元类typ和metaclass

关于metaclass和type类，请仔细阅读这篇博文http://blog.jobbole.com/21351/和廖雪峰博客

• 类本身就是对象，因此它具备对象的特性1.你可以将它赋值给一个变量；2.你可以拷贝它；3.你可以为它增加属性；4. 你可以将它作为函数参数进行传递
• 类对象的产生：类既然本身是一个对象，我们可以动态的创建类，使用type关键字（事实上，当我们用class定义类的时候，系统就是用type类在内存中创建的类[对象]）
• 我们可以使用metaclass关键字指定自己定制的元类，通过该元类来创建类(对象)

元类就是用来创建类的“东西”。你创建类就是为了创建类的实例对象，不是吗？但是我们已经学习到了Python中的类也是对象。好吧，元类就是用来创建这些类（对象）的，元类就是类的类，你可以这样理解 为：

MyClass = MetaClass()
MyObject = MyClass()

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

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

这是因为函数type实际上是一个元类。type就是Python在背后用来创建所有类的元类。现在你想知道那为什么type会全部采用小写形式而不是Type呢？好吧，我猜这是为了和str保持一致性，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__的__class__属性又是什么呢？

>>> a.__class__.__class__
<type 'type'>
>>> age.__class__.__class__
<type 'type'>
>>> foo.__class__.__class__
<type 'type'>
>>> b.__class__.__class__
<type 'type'>

因此，元类就是创建类这种对象的东西。如果你喜欢的话，可以把元类称为“类工厂”（不要和工厂类搞混了） type就是Python的内建元类，当然了，你也可以创建自己的元类。

__metaclass__

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

class Foo(object):
    __metaclass__ = mymetaclass

如果你这么做了，Python就会用mymetaclass元类来创建类Foo。小心点，这里面有些技巧。你首先写下class Foo(object)，但是类对象Foo还没有在内存中创建。Python会在类的定义中寻找__metaclass__属性，如果找到了，Python就会用它来创建类Foo，如果没有找到，就会用内建的type来创建这个类。把下面这段话反复读几次。当你写如下代码时 :

class Foo(Bar):
    pass

Python做了如下的操作：

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

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

记住：创建类对象是type类，创建实例对象是__new___函数

以下两种写法是等价形式：

class Model(dict, metaclass=ModelMetaclass):  #python3中的写法
    pass
    
class Model(dict):
    __metaclass__=ModelMetaclass         ##python2中的写法
    pass

类对象是在定义的时候去创建的，并不是实例化对象的时候再去创建的。

class Foo: 
    a = 10
    b = 20
    
    def __init(self): # 只有在实例化foo = Foo()的时候才会执行
        pass

以上代码的执行顺序：class Foo->a=10->b=20->查询是否有metaclass->调用自定义的元类或type创建Foo类对象

自定义ORM，该例子摘自廖雪峰博客

class Field(object):
    def __init__(self, name, column_type):
        self.name = name
        self.column_type = column_type

    def __str__(self):
        return '<%s:%s>' % (self.__class__.__name__, self.name)

class StringField(Field):
    def __init__(self, name):
        super(StringField, self).__init__(name, 'varchar(100)')

class IntegerField(Field):
    def __init__(self, name):
        super(IntegerField, self).__init__(name, 'bigint')

class ModelMetaclass(type):

    def __new__(cls, name, bases, attrs):
        if name=='Model':
            print(name)
            return type.__new__(cls, name, bases, attrs)  #创建Model类对象,并退出
        print('Found model: %s' % name)
        mappings = dict()
        for k, v in attrs.items():
            if isinstance(v, Field):
                print('Found mapping: %s ==> %s' % (k, v))
                mappings[k] = v
        for k in mappings.keys():
            attrs.pop(k)
        attrs['__mappings__'] = mappings # 保存属性和列的映射关系
        attrs['__table__'] = name # 假设表名和类名一致
        return type.__new__(cls, name, bases, attrs) # #创建User类对象

class Model(dict, metaclass=ModelMetaclass):

    def __init__(self, **kw):
        super(Model, self).__init__(**kw)

    def __getattr__(self, key):
        try:
            return self[key]
        except KeyError:
            raise AttributeError(r"'Model' object has no attribute '%s'" % key)

    def __setattr__(self, key, value):
        self[key] = value

    def save(self):
        fields = []
        params = []
        args = []
        for k, v in self.__mappings__.items():
            fields.append(v.name)
            params.append('?')
            args.append(getattr(self, k, None))
        sql = 'insert into %s (%s) values (%s)' % (self.__table__, ','.join(fields), ','.join(params))
        print('SQL: %s' % sql)
        print('ARGS: %s' % str(args))

class User(Model):
    # 定义类的属性到列的映射：
    id = IntegerField('id')
    name = StringField('username')
    email = StringField('email')
    password = StringField('password')

# 创建一个实例：
u = User(id=12345, name='Michael', email='test@orm.org', password='my-pwd')
# 保存到数据库：
u.save()

具体的程序执行流程：

• 当程序跑到class User(Model)的时候，执行下面的四句话，创建4个实例对象到内存中
• 解释器会查找是User是否定制了metaclass（元类的作用是创建类[对象]），如果没有，向父类Model查找
• 依次解释执行Model类里面的方法，包括__init__，__getattr__， __setattr__，save，在内存中建立对应的命名空间（这些命名空间是创建Model类的attrs）
• 解释执行完Model类内部的属性（其实方法就是属性），发现Model有metaclass属性，便用ModelMetaclass这个元类来创建Model类对象，即调用ModelMetaclass的__new__方法：当执行到name=='Model'后，便在内存中产生了Model类对象（等价于type(Model,(dict,),{attrs})）
• 接下来User类会调用ModelMetaclass的__new__方法，在内存中创建User类对象
• 以下省略