Python 元类详解 __new__、__init__、__c

了解元类之前，先了解几个魔术方法： __new__、__init__、__call__

__new__： 对象的创建，是一个静态方法，第一个参数是cls。(想想也是，不可能是self，对象还没创建，哪来的self)
__init__ ： 对象的初始化， 是一个实例方法，第一个参数是self。
__call__ ： 对象可call，注意不是类，是对象。

class Bar(object):
    def __new__(cls, *args):
        self = super(Bar, cls).__new__(cls)
        #self = super().__new__(cls) #py3
        print '__new__'
        return self

    def __init__(self, *args):
        print '__init__'
        self.name = args[0]

    def __call__(self, *args):
        print '__call__', args

#执行
b = Bar('haha')
print b.name
b()

# 结果
__new__
__init__
hah
__call__ ()

__new__ 、__init__ 详解

__new__方法先被调用，返回一个实例对象，接着 __init__ 被调用。
从输出结果来看，__new__方法的返回值就是类的实例对象，这个实例对象会传递给 __init__ 方法中定义的 self 参数，以便实例对象可以被正确地初始化。

如果 __new__ 方法不返回值（或者说返回 None）那么 __init__ 将不会得到调用，这个也说得通，因为实例对象都没创建出来，调用__init__也没什么意义，此外，Python 还规定，__init__ 只能返回 None 值，否则报错，这个留给大家去试。

__init__方法可以用来做一些初始化工作，比如给实例对象的状态进行初始化

def __init__(self, *args):
    self.name = args[0]

另外，__init__方法中除了self之外定义的参数，都将与__new__方法中除cls参数之外的参数是必须保持一致或者等效。因为Bar(x, y)传参的时候是先给到__new__(), 然后再传递给init

另外：
__new__方法在类定义中不是必须写的，如果没定义，默认会调用object.__new__去创建一个对象。如果定义了，就是override,可以custom创建对象的行为。

聪明的读者可能想到，既然__new__可以custom对象的创建，那我在这里做一下手脚，每次创建对象都返回同一个，那不就是单例模式了吗？没错，就是这样。可以观摩《飘逸的python - 单例模式乱弹》

定义单例模式时，因为自定义的__new__重载了父类的__new__，所以要自己显式调用父类的new，即object.__new__(cls, *args, **kwargs)，或者用super()。
不然就不是extend原来的实例了，而是替换原来的实例。

所以：
上面的__new__()方法我们是重写父类object的方法， 所以我们必须至少执行
object.__new__(cls, *args, **kwargs) 或者
super(Bar, cls).__new__(cls)
这两个是等效的， 用super()可以不用hardcode父类名字。

__call__ 详解

实例化后的对象，再当函数一样执行就会执行到这个__call__函数

b = Bar('hah')
b()
#  输出
__call__ 

总结
在python中，类的行为就是这样，__new__、__init__、__call__等方法不是必须写的，会默认调用，如果自己定义了，就是override,可以custom。既然override了，通常也会显式调用进行补偿以达到extend的目的。

元类

Python中的类还远不止如此。类同样也是一种对象。是的，没错，就是对象。只要你使用关键字class，Python解释器在执行的时候就会创建一个对象。下面的代码段：

class ObjectCreator(object):
…       pass

将在内存中创建一个对象，名字就是ObjectCreator。这个对象（类）自身拥有创建对象（类实例）的能力，而这就是为什么它是一个类的原因。但是，它的本质仍然是一个对象，于是乎你可以对它做如下的操作：

1. 你可以将它赋值给一个变量
2. 你可以拷贝它
3. 你可以为它增加属性
4. 你可以将它作为函数参数进行传递

>>> print ObjectCreator     # 你可以打印一个类，因为它其实也是一个对象
<class '__main__.ObjectCreator'>
>>> def echo(o):
…       print o
…
>>> echo(ObjectCreator)                 # 你可以将类做为参数传给函数
<class '__main__.ObjectCreator'>
>>> print hasattr(ObjectCreator, 'new_attribute')
Fasle
>>> ObjectCreator.new_attribute = 'foo' #  你可以为类增加属性
>>> print hasattr(ObjectCreator, 'new_attribute')
True
>>> print ObjectCreator.new_attribute
foo
>>> ObjectCreatorMirror = ObjectCreator # 你可以将类赋值给一个变量
>>> print ObjectCreatorMirror()
<__main__.ObjectCreator object at 0x8997b4c>

type有一种完全不同的能力，它也能动态的创建类。type可以接受一个类的描述作为参数，然后返回一个类。（我知道，根据传入参数的不同，同一个函数拥有两种完全不同的用法是一件很傻的事情，但这在Python中是为了保持向后兼容性）

type可以像这样工作：

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

比如下面的代码：

class Hello(object):
    def hello(self, name='world'):
        print('Hello, %s.' % name)

当Python解释器载入hello模块时，就会依次执行该模块的所有语句，执行结果就是动态创建出一个Hello的class对象，测试如下：

>>> from hello import Hello
>>> h = Hello()
>>> h.hello()
Hello, world.
>>> print(type(Hello))
<type 'type'>
>>> print(type(h))
<class 'hello.Hello'>

type()函数可以查看一个类型或变量的类型，Hello是一个class，它的类型就是type，而h是一个实例，它的类型就是class Hello。

我们说class的定义是运行时动态创建的，而创建class的方法就是使用type()函数。

type()函数既可以返回一个对象的类型，又可以创建出新的类型，比如，我们可以通过type()函数创建出Hello类，而无需通过class Hello(object)...的定义：

>>> def fn(self, name='world'): # 先定义函数
...     print('Hello, %s.' % name)
...
>>> Hello = type('Hello', (object,), dict(hello=fn)) # 创建Hello class
>>> h = Hello()
>>> h.hello()
Hello, world.
>>> print(type(Hello))
<type 'type'>
>>> print(type(h))
<class '__main__.Hello'>

要创建一个class对象，type()函数依次传入3个参数：

1. class的名称；
2. 继承的父类集合，注意Python支持多重继承，如果只有一个父类，别忘了tuple的单元素写法；
3. class的方法名称与函数绑定，这里我们把函数fn绑定到方法名hello上。

通过type()函数创建的类和直接写class是完全一样的，因为Python解释器遇到class定义时，仅仅是扫描一下class定义的语法，然后调用type()函数创建出class。

正常情况下，我们都用class Xxx...来定义类，但是，type()函数也允许我们动态创建出类来，也就是说，动态语言本身支持运行期动态创建类。

你可以看到，在Python中，类也是对象，你可以动态的创建类。这就是当你使用关键字class时Python在幕后做的事情，而这就是通过元类来实现的。

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

这是因为函数type实际上是一个元类。type就是Python在背后用来创建所有类的元类。现在你想知道那为什么type会全部采用小写形式而不是Type呢？好吧，我猜这是为了和str保持一致性，str是用来创建字符串对象的类，而int是用来创建整数对象的类。type就是创建类对象的类。你可以通过检查class属性来看到这一点。Python中所有的东西，注意，我是指所有的东西——都是对象。这包括整数、字符串、函数以及类。它们全部都是对象，而且它们都是从一个类创建而来。

>>> a = 1
>>> b = 'hello'
>>> a.__class__
<type 'int'>
>>> b.__class__
<type 'str'>

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

上面看得出，哪怕int ，str的类，他们的__class__都是<type 'type'>, 说明他们都是由type元类实例化出来的对象，所以说元类(type)就是类的类

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

__metaclass__

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

class Foo(object):
    __metaclass__ = something…

如果你这么做了，Python就会用元类来创建类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’的参数作为自己的参数传入
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)

    # 通过'type'来做类对象的创建
    return type(future_class_name, future_class_parents, uppercase_attr)

__metaclass__ = upper_attr  #  这会作用到这个模块中的所有类

class Foo(object):
    # 我们也可以只在这里定义__metaclass__，这样就只会作用于这个类中
    bar = 'bip'

print hasattr(Foo, 'bar')
# 输出: False
print hasattr(Foo, 'BAR')
# 输出:True

f = Foo()
print f.BAR
# 输出:'bip'

案例讲解：

1. __metaclass__没有定义在类里面，而是在模块里面，所以这个根据上面的寻址规则，本类->父类->模块 这里的定义会让模块所有类都使用这个__metaclass__
2. 使用upper_attr来创建类，它要么包含了type(), 要么直接用type(), 要么子类化type(), 这里是使用了type()
3. 创建类的元类type()会依次传入3个参数：
   • class的名称；
   • 继承的父类集合，注意Python支持多重继承，如果只有一个父类，别忘了tuple的单元素写法；
   • class的方法名称与函数绑定，这里我们把函数fn绑定到方法名hello上。
     所以我们看到传到upper_attr()会有三个参数， future_class_name, future_class_parents, future_class_attr，分别代表上面的参数。

4.然后我们处理完类属性，把他们转成大小后，调用return type(future_class_name, future_class_parents, uppercase_attr) 完成创建类的过程。

5. 说到底还是要使用type() 来创建类，只不过我们在默认的创建前拦截掉了，然后加入我们自己处理，比如属性转大写

当然了，用函数赋值给__metaclass__是可以的，但是不够OOP
现在让我们再做一次，这一次用一个真正的class来当做元类：

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)

但就元类本身而言，它们其实是很简单的：

1. 拦截类的创建
2. 修改类
3. 返回修改之后的类

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

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

1） 意图会更加清晰。当你读到UpperAttrMetaclass(type)时，你知道接下来要发生什么。
2） 你可以使用OOP编程。元类可以从元类中继承而来，改写父类的方法。元类甚至还可以使用元类。
3） 你可以把代码组织的更好。当你使用元类的时候肯定不会是像我上面举的这种简单场景，通常都是针对比较复杂的问题。将多个方法归总到一个类中会很有帮助，也会使得代码更容易阅读。
4） 你可以使用__new__, __init__以及__call__这样的特殊方法。它们能帮你处理不同的任务。就算通常你可以把所有的东西都在__new__里处理掉，有些人还是觉得用__init__更舒服些。
5） 重点：如果使用函数像第一个方法，必须显式调用type.__new__()方法，如果是下面的子类继承type类OOP的方式，则不用

例子：单利模式

先看一个单例：使用__metalcass__

class Singleton(type):
    def __call__(cls, *args, **kwargs):
        if not hasattr(cls, '_instance'):
            cls._instance = super(Singleton, cls).__call__(*args, **kwargs)
        return cls._instance

class Foo():
    __metaclass__ = Singleton

f = Foo()
f2=Foo()
# 输出f == f2 他们是同一个实例化对象

详细讲解这个单例模式是什么流程：

1. 首先，我们在Foo里面定义了__metaclass__= Singleton，这个Singleton是type的子类，这里如果不写__metaclass__=Singleton默认会是__metaclass__= type， 创建类的时候，还是调用type.__new__方法。因为Foo就是type创建的实例。这里Singleton只是扩展了type，某些方法，但大部分功能还是继承type的，__new__这里没有重写，说明还是使用的type.__new__来创建这个Foo
2. 既然我们子类Singleton 没有重写type的__new__, __init__方法，那么就说明在创建Foo这个类（对于type来说是实例对象）的时候，还是使用默认的方式！
3. 我们在Singleton重写了__call__方法，也就是重写了type的这个方法，那么这个方法会在什么时候发挥作用呢？我们知道__call__是实例在像函数一样调用的时候，会触发的 比如f = Foo(), f(5) 这个f(5)就会调用Foo类的__call__方法。 而在我们Foo()获取单例的时候，实际上Foo也是type的实例，Foo虽然是类，它同时也是type的实例所以Foo()生成Foo的实例的同时，触发了Foo的类type的__call__方法！
4. 所以就在这时，触发了它的元类也就是Singleton的__call__（如果没有定义__metaclass__，就会默认调用type.__call）方法，这个__call__方法判断了是否单例。注意Singleton重写了__call__方法以后，一定要重新调用原来的默认的type.__call__()方法, 所以也就看到了
   foo_cls._instance = super(Singleton, foo_cls).__call__(*args, **kwargs)实际上就是type在调用__call__()

一开始误解很久的地方：

1. 我以为__metaclass__=Singleton 在创建类Foo的时候调用Singleton() 就会马上执行它的__call__()方法，其实不然，可以直接把Singleton想象成在执行默认的type()，还是像原来的方式通过type.__new__() type.__init__()来创建类。
2. 当然了既然Singleton是type的子类，也是它的实例，所以Singleton(), 也是会执行type.__call__()方法拉，这个方法应该就是返回Singleton的实例了。 也就是创建完的Foo类
3. Singleton为什么要用__call()__ 用__new()__可以么？看下面

class Singleton(type):
    def __new__(cls, future_class_name, future_class_parents, future_class_attrs):
        print '__new__', cls, future_class_name, future_class_parents, future_class_attrs
        attrs = [(k, v) for k, v in future_class_attrs.items() if not k.startswith('__')]
        new_attrs = dict([(k.upper(), v)for k, v in attrs])
        print new_attrs
        return super(Singleton, cls).__new__(cls, future_class_name, future_class_parents, new_attrs)

    def __call__(foo_cls, *args, **kwargs):
        if not hasattr(foo_cls, '_instance'):
            foo_cls._instance = super(Singleton, foo_cls).__call__(*args, **kwargs)
        return foo_cls._instance

f = Foo()
print hasattr(f, 'bar') # False
print hasattr(f, 'BAR') # True
f.GET_NAME() # haha
print f.bar  # error
print f.BAR # hello world

解答元类__new__和 __call__的区别

1. type.__new__()就是用来生成类的！所以只会调用一次，因为类Foo只需要一个！所以__new__是用来再创建类的时候，做拦截，加入一些我们自己的逻辑，比如这里我把所有类方法，类属性转成了大写！
2. __call__则是每次类调用的时候也就是Foo()会触发，每次都会触发。

圈重点了

使用__new__写单例

class Singleton(object):
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls, '_instance'):
            cls._instance = object.__new__(cls, *args, **kwargs)
        return cls._instance

class Foo(Singleton):
    a = 1

这个流程比较清晰了：

1. 定义Foo的时候没有定义__metaclass__ 所以由默认方式type()来创建
2. Foo()创建实例的时候，首先执行__new__()方法，创建实例，就再此时拦截掉默认的创建实例方法
   object.__new()__ 我们加入判断类是否有这个单例的属性，有则直接返回，没有则先用object.__new__创建，然后返回

例子：ORM

ORM提供简单接口给用户调用

class User(Model):
    # 这些定义的类变量
    id = IntegerField('id')
    name = StringField('name')
    email = StringField('email')
    password = StringField('password')

user = User(name="lisalian", email="lisalian@qq.com")
user.password = '123456'
user.save()

定义好一个User表的类，然后传入参数，user.save()就能完成插入数据库的功能

首先来定义Field类，它负责保存数据库表的字段名和字段类型：

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

    def __str(self):
        return '<%s:%s>' % (self.__class__.__name__, self.column)

在Field的基础上，进一步定义各种类型的Field，比如StringField，IntegerField等等：

class IntegerField(Field):
    def __init__(self, column):
        super(IntegerField, self).__init__(column, 'int')

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

__meataclass__的编写：

class MetaModel(type):
    def __new__(cls, name, bases, attrs):
        """这个__metaclass__同样适用于Model，只不过它也适用于子类User
            如果是创建Model类，则跳过__maping__的处理
        """
        if name == "Model":
            return super(MetaModel, cls).__new__(cls, name, bases, attrs)

        __maping__ = {}
        for k, v in attrs.iteritems():
            if isinstance(v, Field):
                print 'find field %s' % v.column
                __maping__[k] = v

        attrs['__maping__'] = __maping__
        attrs['__table__'] = name
        for k in __maping__.keys():
            attrs.pop(k)

        # 显式调用__new__() 是要传cls参数，
        # 平常我们不是显示调用才不需要self, cls这样的参数
        return super(MetaModel, cls).__new__(cls, name, bases, attrs)

以及Model基类

class Model(object):
    __metaclass__ = MetaModel

    field_dict = {}
    def __init__(self, **kw):
        self.field_dict.update(kw)
        # 如果Model(dict)这样定义的话就这样执行，这样Model就是dict的子类，一个字典
        #super(Model, self).__init__(self, **kw)

    # 实例对象设置新属性时调用
    def __setattr__(self, name, value):
        self.field_dict[name] = value

    # 实例对象调用不存在属性时调用
    def __getattr__(self, name):
        try:
            return self.field_dict[name]
        except KeyError:
            raise AttributeError('Model object has no attributes %s' % name)

    """save 方法定义在Model这里，就可以让所有继承了Model的数据表
        都有save()
       save方法作用是获取子类的实例的各个字段值，拼凑出insert的SQL
       那么问题来了：怎么获取子类的实例的字段，子类的字段都是随便定义的
       不是Model这里继承过去，Model不能知道有什么字段

       这个save方法被继承于User,最后执行也是再User里面执行
       所以在定义User类的时候，就生成一些字段的映射关系，这就要利用元类了
    """
    def save(self):
        args = []
        params = []
        fields = []
        for k, v in self.__maping__.iteritems():
            fields.append(k)
            args.append(self.field_dict.get(k, None))
            params.append('?')

        print fields
        print params
        print args
        sql = 'insert into %s (%s) values (%s)' % (self.__table__, ','.join(fields), ','.join(params))
        print sql

详解ORM：

1. User()类定义的字段，就是数据表的字段，每个字段对应着一个Field实例。
2. User继承了Model的方法和元类，save()和__metaclass__
   3.__metaclass__最重要的功能就是，在创建类的时候，把定义再User类里面的字段关系，转成一个字段__mapping__保存到User类里面，这样使用save()方法的时候才能获取到这些映射关系。不然你直接定义的各个字段在save的时候，根本获取不到。

参考：

深刻理解Python中的元类(metaclass)
飘逸的python - 单例模式乱弹
stackoverflow 单例
使用元类