前提
new、init、call的介绍
在讲到使用元类创建单例模式之前，比需了解new这个内置方法的作用，在上面讲元类的时候我们用到了new方法来实现类的创建。然而我在那之前还是对new这个方法和init方法有一定的疑惑。因此这里花点时间对其概念做一次了解和区分。
new
该方法负责创建一个实例对象，在对象被创建的时候调用该方法它是一个类方法。new方法在返回一个实例之后，会自动的调用init方法，对实例进行初始化。如果new方法不返回值，或者返回的不是实例，那么它就不会自动的去调用init方法。
init
该方法负责将该实例对象进行初始化，在对象被创建之后调用该方法，在new方法创建出一个实例后对实例属性进行初始化。init方法可以没有返回值。
call
该方法其实和类的创建过程和实例化没有多大关系了，定义了call方法才能被使用函数的方式执行。
#coding:utf-8
class Foo(object):
def __new__(cls, *args, **kwargs):
#__new__是一个类方法，在对象创建的时候调用
print "excute __new__"
return super(Foo,cls).__new__(cls,*args,**kwargs)
def __init__(self,value):
#__init__是一个实例方法，在对象创建后调用，对实例属性做初始化
print "excute __init"
self.value = value
f1 = Foo(1)
print f1.value
f2 = Foo(2)
print f2.value
#输出===：
excute __new__
excute __init
excute __new__
excute __init
#====可以看出new方法在init方法之前执行
type
type(类名, 父类的元组（针对继承的情况，可以为空），包含属性的字典（名称和值）)
元类的作用是产生类实例
def choose_class(name):
if name == 'foo':
class Foo(object):
pass
return Foo # 返回的是类，不是类的实例
else:
class Bar(object):
pass
return Bar
MyClass = choose_class('foo')
print MyClass # 函数返回的是类，不是类的实例
#输出：<class '__main__.Foo'>
print MyClass() # 你可以通过这个类创建类实例，也就是对象
#输出：<__main__.Foo object at 0x1085ed950
在Python中，类也是对象，你可以动态的创建类。这就是当我们使用关键字class时Python在幕后做的事情，而这就是通过元类来实现的
元类
什么是元类
通过上文的描述，我们知道了Python中的类也是对象。元类就是用来创建这些类（对象）的，元类就是类的类，你可以这样理解为：
MyClass = MetaClass() #元类创建
MyObject = MyClass() #类创建实例
实际上MyClass就是通过type()来创创建出MyClass类，它是type()类的一个实例；同时MyClass本身也是类，也可以创建出自己的实例，这里就是MyObject
metaclass属性
你可以在写一个类的时候为其添加metaclass属性,定义了metaclass就定义了这个类的元类。
class Foo(object): #py2
__metaclass__ = something…
class Foo(metaclass=something): #py3
__metaclass__ = something…
例如：当我们写如下代码时 :
class Foo(Bar):
pass
在该类并定义的时候，它还没有在内存中生成，知道它被调用。Python做了如下的操作：
1）Foo中有metaclass这个属性吗？如果是，Python会在内存中通过metaclass创建一个名字为Foo的类对象（我说的是类对象，请紧跟我的思路）。
2）如果Python没有找到metaclass，它会继续在父类中寻找metaclass属性，并尝试做和前面同样的操作。
3）如果Python在任何父类中都找不到metaclass，它就会在模块层次中去寻找metaclass，并尝试做同样的操作。
4）如果还是找不到metaclass,Python就会用内置的type来创建这个类对象。
现在的问题就是，你可以在metaclass中放置些什么代码呢？
答案就是：可以创建一个类的东西。那么什么可以用来创建一个类呢？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)#返回一个类
class Foo(object):
__metaclass__ = upper_attr
bar = 'bip'
使用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)
orm
#coding:utf-8
#一、首先来定义Field类，它负责保存数据库表的字段名和字段类型：
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')
#二、定义元类，控制Model对象的创建
class ModelMetaclass(type):
'''定义元类, __new__必须要有返回值，返回实例化出来的实例,此处返回Model类实例'''
def __new__(cls, name, bases, attrs):
if name=='Model':
# 实例化出<class '__main__.Model'>
# super(ModelMetaclass,cls) 等于type
'''
__new__()方法接收到的参数依次是：
1、当前准备创建的类的对象；
2、类的名字；
3、类继承的父类集合；
4、类的方法或者属性集合。
'''
cc = super(ModelMetaclass,cls).__new__(cls, name, bases, attrs)
return cc
mappings = dict()
for k, v in attrs.iteritems():
# 保存类属性和列的映射关系到mappings字典
if isinstance(v, Field):
print('Found mapping: %s==>%s' % (k, v))
mappings[k] = v
for k in mappings.iterkeys():
#将类属性移除，使定义的类字段不污染User类属性，只在实例中可以访问这些key
attrs.pop(k)
attrs['__table__'] = name.lower() # 假设表名和为类名的小写,创建类时添加一个__table__类属性
attrs['__mappings__'] = mappings # 保存属性和列的映射关系，创建类时添加一个__mappings__类属性
dd = super(ModelMetaclass,cls).__new__(cls, name, bases, attrs)
return dd
#三、编写Model基类
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__.iteritems():
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))
#最后，我们使用定义好的ORM接口，使用起来非常的简单。
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()
元类是生成类的类 所以都放在初始化new函数中，让生成类更加灵活。
元类单例模式
new方法实现单例
class Singleton(object):
def __new__(cls, *args, **kwargs):
if not hasattr(cls,"_instance"):
cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
return cls._instance
s1 = Singleton()
s2 = Singleton()
print s1 is s2
元类实现单例
class Singleton(type):
def __init__(self, *args, **kwargs):
print "__init__"
self.__instance = None
super(Singleton,self).__init__(*args, **kwargs)
def __call__(self, *args, **kwargs):
print "__call__"
if self.__instance is None:
self.__instance = super(Singleton,self).__call__(*args, **kwargs)
return self.__instance
class Foo(object):
__metaclass__ = Singleton #在代码执行到这里的时候，元类中的__new__方法和__init__方法其实已经被执行了，而不是在Foo实例化的时候执行。且仅会执行一次。
foo1 = Foo()
foo2 = Foo()
print Foo.__dict__ #_Singleton__instance': <__main__.Foo object at 0x100c52f10> 存在一个私有属性来保存属性，而不会污染Foo类（其实还是会污染，只是无法直接通过__instance属性访问）
print foo1 is foo2 # True
