python中的metaclass
首先看下面的代码：
# coding: utf-8
class Test(object):
pass
print Test.__class__ # type
print Test.__base__ # object
t = Test()
print t.__class__ # Test
print t.__class__.__class__ # type
print Test.__class__.__class__.__class__ # type
a = type('Foo', (), {})
print a # class Foo
t = a()
print type(t) # Foo
print t.__class__ # Foo
print t.__class__.__class__ # type
从代码中可以看出：
- t的__class__，为Test，这是它所属的类
- Test.class 为type，也就是说，Test这个类也是个对象，他是type这个类的对象。
在Python中，一切都是对象，所以类本身也是对象，类对象所属的类是type类。
那么，Python中的类都是type类的对象，而type类实现了__call__调用，实现__call__的类的对象都可以当做函数一样调用，所以所有的type对象都是函数，也就是说，所有的类都是函数。
以前一直以为type是个函数，但实际上，type本身是个类。
所以，Python中的类型体系可以看成：
type -> Test -> t
而Python中对象的类型可以这样追溯:
t -> Test -> type -> type -> ...
metaclass
我们使用类来创建对象，而Python中可以通过元类来动态创建类。
metaclass可以是一切可以执行的东西，也就是说，可以是函数，也可以是类。
# coding: utf-8
def upper_attrs(class_name, class_parents, class_attrs):
attrs = {}
for key in class_attrs:
if not key.startswith('__'):
attrs[key.upper()] = class_attrs[key]
return type(class_name, class_parents, attrs)
class Foo:
__metaclass__ = upper_attrs
bar = 'haha'
if __name__ == '__main__':
print hasattr(Foo, 'bar')
print hasattr(Foo, 'BAR')
print type(Foo)
这里我们将upper_attrs当做一个元类，它的作用是将类的属性改为大写。所以Foo中的bar属性改为BAR属性。
metaclass的作用主要是：
- 拦截类的创建
- 修改类
- 返回被修改的类
使用类实现metaclass
# coding: utf-8
class UpperAttrsMeta(object):
def __new__(metaclass, class_name, class_parents, class_attrs):
print metaclass
attrs = {}
for key in class_attrs:
if not key.startswith('__'):
attrs[key.upper()] = class_attrs[key]
return type(class_name, class_parents, attrs)
class Test:
__metaclass__ = UpperAttrsMeta
foo = 'bar'
if __name__ == '__main__':
print hasattr(Test, 'foo')
print hasattr(Test, 'FOO')
t = Test
print t.FOO
print type(t)
print type(Test)
print type(UpperAttrsMeta)
使用metaclass实现一个简易的ORM
假设我们想实现一个ORM，这样去使用：
class User(Model):
id = IntegerField('id')
name = StringField('username')
email = StringField('email')
password = StringField('password')
u = User(id=123455, name='haha', email='haha@301.com', password='hhhhh')
u.save()
我们先实现各种Field：
# coding: utf-8
class Field(object):
def __init__(self, name, column_type):
self.name = name # 列名
self.column_type = column_type # 列的类型
def __str__(self):
# 实质是打印table名称和列名
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')
Field的主要作用是记录列名和类型之间的关系。就好比 name 和 varchar
上面实现了Field，代表数据类型。下面我们需要实现数据库的table，每种类型我们称为一种model。
下面我们使用metaclass实现model。
class ModelMetaClass(type):
def __new__(cls, name, bases, attrs):
if name == 'Model':
return type.__new__(cls, name, bases, attrs)
mappings = dict()
for k, v in attrs.iteritems():
if isinstance(v, Field):
# 记录name -> StringField
print 'Found mapping: %s->%s' % (k, v)
mappings[k] = v
for k in mappings.iterkeys():
# 防止重复 a.name
attrs.pop(k)
attrs['__table__'] = name # 表名称
attrs['__mappings__'] = mappings # 属性和列名的映射关系
return type.__new__(cls, name, bases, attrs)
上面提过，metaclass的主要作用是拦截类的生成，并进行修改。
这里的ModelMetaClass，将类的属性中定义的 列名和数据类型单独摘取出来，并将它们保存在__mappings__中。
另外，提取出列名和类型后，需要将这些属性去掉。
以User为例，提取完id,name,email和password后，需要将它们删除，因为这四个属性为类属性，根据User定义的对象u也具有这四个属性，此时u.name为StringField对象，这样显然不合理，所以需要将这些属性去掉。
这些属性的唯一价值也是提供给metaclass使用。
下面实现Model：
class Model(dict):
__metaclass__ = ModelMetaClass
def __init__(self, **kwargs):
super(Model, self).__init__(**kwargs)
def __getattr__(self, key):
try:
return self[key]
except KeyError:
raise AttributeError("'%s' object has not Attribute: %s" % (self.__class__.__name__, key))
def __setattr__(self, key, value):
self[key] = value
def save(self):
fields = []
params = []
args = []
# 注意k 和v.name可能不同 数据库中以v为主
for k, v in self.__mappings__.iteritems():
fields.append(v.name) # 列名
params.append('?')
args.append(getattr(self, k, None))
_fields = ','.join(fields)
_params = ','.join(params)
sql = 'insert into %s (%s) value (%s)' % (
self.__table__, _fields, _params)
print 'SQL: %s' % sql
print str(args)
save函数的过程就是根据__mappings__中记录的列名，从dict中提取出值。将其保存在args中。fields中保存的是列名。
运行结果如下：
Found mapping: email-><StringField:email>
Found mapping: password-><StringField:password>
Found mapping: id-><IntegerField:id>
Found mapping: name-><StringField:username>
SQL: insert into User (password,email,username,id) value (?,?,?,?)
['hhhhh', 'haha@301.com', 'haha', 123455]
参考资料：
http://blog.jobbole.com/21351/
http://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493182103fac9270762a000/001386820064557c69858840b4c48d2b8411bc2ea9099ba000
