了解元类之前，先了解几个魔术方法： __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 # 你可以打印一个类，因为它其实也是一个对象

>>> def echo(o):

… print o

…

>>> echo(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()

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))

>>> print(type(h))

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))

>>> print(type(h))

要创建一个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__

>>> b.__class__

>>> a.__class__.__class__

>>> b.__class__.__class__

上面看得出，哪怕int ，str的类，他们的__class__都是, 说明他们都是由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 '' % (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的时候，根本获取不到。

参考：