了解元类之前，先了解几个魔术方法： __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。这个对象（类）自身拥有创建对象（类实例）的能力，而这就是为什么它是一个类的原因。但是，它的本质仍然是一个对象，于是乎你可以对它做如下的操作：
- 你可以将它赋值给一个变量
- 你可以拷贝它
- 你可以为它增加属性
- 你可以将它作为函数参数进行传递
>>> 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个参数：
- class的名称；
- 继承的父类集合，注意Python支持多重继承，如果只有一个父类，别忘了tuple的单元素写法；
- 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'
案例讲解：
- __metaclass__没有定义在类里面，而是在模块里面，所以这个根据上面的寻址规则，本类->父类->模块 这里的定义会让模块所有类都使用这个__metaclass__
- 使用upper_attr来创建类，它要么包含了type(), 要么直接用type(), 要么子类化type(), 这里是使用了type()
- 创建类的元类
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) 完成创建类的过程。
- 说到底还是要使用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)
但就元类本身而言，它们其实是很简单的：
- 拦截类的创建
- 修改类
- 返回修改之后的类
为什么要用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 他们是同一个实例化对象
详细讲解这个单例模式是什么流程：
- 首先，我们在Foo里面定义了__metaclass__= Singleton，这个Singleton是type的子类，这里如果不写__metaclass__=Singleton默认会是__metaclass__= type， 创建类的时候，还是调用type.__new__方法。因为Foo就是type创建的实例。这里Singleton只是扩展了type，某些方法，但大部分功能还是继承type的，__new__这里没有重写，说明还是使用的type.__new__来创建这个Foo
- 既然我们子类Singleton 没有重写type的__new__, __init__方法，那么就说明在创建Foo这个类（对于type来说是实例对象）的时候，还是使用默认的方式！
- 我们在Singleton重写了__call__方法，也就是重写了type的这个方法，那么这个方法会在什么时候发挥作用呢？我们知道__call__是实例在像函数一样调用的时候，会触发的 比如f = Foo(), f(5) 这个f(5)就会调用Foo类的__call__方法。 而在我们Foo()获取单例的时候，实际上Foo也是type的实例，Foo虽然是类，它同时也是type的实例所以Foo()生成Foo的实例的同时，触发了Foo的类type的__call__方法！
- 所以就在这时，触发了它的元类也就是Singleton的__call__（如果没有定义__metaclass__，就会默认调用type.__call）方法，这个__call__方法判断了是否单例。注意Singleton重写了__call__方法以后，一定要重新调用原来的默认的type.__call__()方法, 所以也就看到了
foo_cls._instance = super(Singleton, foo_cls).__call__(*args, **kwargs)实际上就是type在调用__call__()
一开始误解很久的地方：
- 我以为__metaclass__=Singleton 在创建类Foo的时候调用Singleton() 就会马上执行它的__call__()方法，其实不然，可以直接把Singleton想象成在执行默认的type()，还是像原来的方式通过type.__new__() type.__init__()来创建类。
- 当然了既然Singleton是type的子类，也是它的实例，所以Singleton(), 也是会执行type.__call__()方法拉，这个方法应该就是返回Singleton的实例了。 也就是创建完的Foo类
- 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__的区别
- type.__new__()就是用来生成类的！所以只会调用一次，因为类Foo只需要一个！所以__new__是用来再创建类的时候，做拦截，加入一些我们自己的逻辑，比如这里我把所有类方法，类属性转成了大写！
- __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
这个流程比较清晰了：
- 定义Foo的时候没有定义__metaclass__ 所以由默认方式type()来创建
- 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：
- User()类定义的字段，就是数据表的字段，每个字段对应着一个Field实例。
- User继承了Model的方法和元类，save()和__metaclass__
3.__metaclass__最重要的功能就是，在创建类的时候，把定义再User类里面的字段关系，转成一个字段__mapping__保存到User类里面，这样使用save()方法的时候才能获取到这些映射关系。不然你直接定义的各个字段在save的时候，根本获取不到。
参考：
深刻理解Python中的元类(metaclass)
飘逸的python - 单例模式乱弹
stackoverflow 单例
使用元类
