python学习(十)元类学习和应用

python 可以通过type函数创建类,也可通过type判断数据类型

import socket
from io import StringIO
import sys
class TypeClass(object):
    def typeprint(self, name = 'typeclass'):
        print('class name is %s' %(name))

typeclasses = TypeClass()
print(type(TypeClass))
print(type(typeclasses))

def printHW(self):
    print('Hello world!!!')
TypeClass2 = type('TypeClass2', (object,), dict(typeprinthw = printHW))
typeclass2 = TypeClass2()
typeclass2.typeprinthw()

type创建类格式为type(‘类名’,(基类1,基类2…), dict(成员函数名=函数名))
第一个参数为类名，第二个参数为一个tuple,如果继承的基类只有一个，要注意tuple写法(基类,),第三个参数为dict构造的类成员函数
除了可以用type创建类之外，可以用metaclass限制类的行为

使用metaclass需要先定义一个特定功能的元类，这个元类一般按照功能名字命名，末尾以Metaclass结束，表示一个特定功能的元类,这个元类必须继承于type类,内部必须实现
__new__借口完成类的限定。__new__的调用先于__init__，在对象构造之前调用。

class DictMetaclass(type):
	def __new__(cls, name, bases, attrs):
		def insertfunc(self, key, value):
			self[key]=value
		attrs['insert'] = insertfunc
		return type.__new__(cls,name,bases,attrs)

class MyDict(dict, metaclass = DictMetaclass):
    pass

mydict = MyDict()
mydict.insert('nice', 3)
print(mydict['nice'])

定义了一个DictMetaclass元类，继承于type类，内部实现了__new__方法，__new__方法四个参数分别为准备创建的类对象，类名字，该类的基类集合，类的方法集合。并且__new__内部调用了type类的__new__函数，完成了新功能属性的绑定。下面同样实现一个list类的扩展

class ListMetaclass(type):
    def __new__(cls, name, bases, attrs):
        attrs['insert'] = lambda self, value: self.append(value)
        return type.__new__(cls,name,bases,attrs)

class Mylist(list,metaclass = ListMetaclass):
    pass

mylist = Mylist()
mylist.insert('name')
mylist.insert('age')
print(mylist)

下面为在廖雪峰官网学习的ORM框架例子
ORM全称“Object Relational Mapping”，即对象-关系映射，就是把关系数据库的一行映射为一个对象，也就是一个类对应一个表，这样，写代码更简单，不用直接操作SQL语句。
要编写一个ORM框架，所有的类都只能动态定义，因为只有使用者才能根据表的结构定义出对应的类来。
让我们来尝试编写一个ORM框架。
先实现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 IntegerField(Field):
    def __init__(self, name):
        super(IntegerField,self).__init__(name, 'bigint')

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

Field类用来管理数据库的字段和字段类型
实现ModelMetaclass这个元类，用于限制User类

class ModelMetaclass(type):
    def __new__(cls,name,bases,attrs):
        if  name == 'Model':
            return type.__new__(cls, name, bases, attrs)
        print('Founc model: %s' % name)
        mappings = dict()
        for k, v in attrs.items():
            if isinstance(v,Field):
                print('Found mapping: %s ==> %s' %(k,v))
                mappings[k] = v
        for k in mappings.keys():
            attrs.pop(k)
        attrs['__mappings__'] = mappings
        attrs['__table__'] = name
        return type.__new__(cls, name, bases, attrs)

ModelMetaclass类中过滤了Model类的处理，将其他类的属性删除，将映射关系存储至__mappings__属性字段，并且__table__字段用来存储类名。
下面实现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__.items():
            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))

Model 类继承了dict, 实现save函数，save函数将__mappings__属性值内容取出来，就是在ModelMetaclass中构造的mappings,其他类继承Model，调用save函数可以动态调用sql语句。
定义User类并且调用save

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

输出如下：