python type与__metaclass__的使用

1. 通过__metaclass__实现自定义列表add方法：

class ListMetaclass(type):
    """
    通过__metaclass__动态生成类，为新生成的类添加add方法
    """

    def __new__(cls, *args, **kwargs):
        """
        :param args: args包含了三个参数具体如下：
            args[0]: 调用ListMetaclass的类名，这边为"MyList"
            args[1]: 为MyList所继承的父类，这边为"(<type 'list'>,)"
            args[2]: 为MyList类所包含的属性与方法, {'__module__': '__main__', '__metaclass__': <class '__main__.ListMetaclass'>}
        :param kwargs:
        :return: 返回后必须将这三个参数全部返回
        """
        args[2]["add"] = lambda List, value: List.append(value)
        return type.__new__(cls, *args)

class MyList(list):
    __metaclass__ = ListMetaclass

c = MyList()
c.add(10)
print c

打印结果如下：

 2. 通过__metaclass__实现ORM的save方法：

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

class ModelMetaclass(type):

    def __new__(cls, name, bases, attrs):
        """
        :param name:
        :param bases:
        :param attrs:  这边attrs为User类中的数据属性，也就是每个变量对应一个文件类型的对象,具体如下：
            {
                'email': <__main__.StringField object at 0x0000000002827550>,
                '__module__': '__main__',
                'password': <__main__.StringField object at 0x0000000002827588>,
                'id': <__main__.IntegerField object at 0x00000000028274E0>,
                'name': <__main__.StringField object at 0x0000000002827518>
            }
        :param 在逻辑处理完成后， __mappings__数据为：
            {
                'password': <__main__.StringField object at 0x00000000028C75F8>,
                'email': <__main__.StringField object at 0x00000000028C75C0>,
                'name': <__main__.StringField object at 0x00000000028C7588>,
                'id': <__main__.IntegerField object at 0x00000000028C7550>
            }
        :return:
        这边的__metaclass__主要就是实现了对User类中文件对象的数据进行筛选，因为只有文件对象的数据才需要来拼接sql语句
        """
        if name =='Model':
            return type.__new__(cls, name, bases, attrs)
        print('Found model: %s' % name)
        mappings = dict()
        for k, v in attrs.iteritems():
            #判断attrs中key对应的value是否为文件对象， 如果是则将对象赋值到mappings字典中
            if isinstance(v, Field):
                print('Found mapping: %s ==> %s' % (k, v))
                mappings[k] = v

        # 先删除attr原先中文件对象，然后添加__mappings__方法，Model类中的save可以通过__mappings__中存放的文件对象来
        # 实现数据的获取
        for k in mappings.iterkeys():
            attrs.pop(k)
        attrs['__mappings__'] = mappings # 保存属性和列的映射关系
        attrs['__table__'] = name # 假设表名和类名一致
        return type.__new__(cls, name, bases, attrs)


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 = []
        for k, v in self.__mappings__.iteritems():
            fields.append(v.name)
            params.append(str(getattr(self, k, None)))
        args = " ("
        for i in params:
            args += "'{}',".format(i)
        sql = 'insert into %s (%s) values' % (self.__table__, ','.join(fields)) + args + ")"
        print('SQL: %s' % sql)

class BoolObj(object):
    pass


class User(Model):
    id = IntegerField('uid')
    name = StringField('username')
    email = StringField('email')
    password = StringField('password')

#这边User()实列化，由于User类继承了dict类,实际上就相当于dict(id=12345, name='Michael', email='test@orm.org', password='my-pwd')
#所有此时打印出来的u就是字典显示 {'email': 'test@orm.org', 'password': 'my-pwd', 'id': 12345, 'name': 'Michael'}
u = User(id=12345, name='Michael', email='test@orm.org', password='my-pwd')
u.save()

打印结果如下：

 

 3. python3__metaclass__实现

"""
@Version: 1.0
@Project: FluentyPython
@Author: Raymond
@Data: 2018/4/10 下午3:34
@File: MetaClass.py
@License: MIT
"""

import logging
from functools import wraps

logging.basicConfig(level=logging.INFO,
                    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

ENUM = (int, dict, list, tuple, str, set, type)


def log(func):
    @wraps(func)
    def wrap(*args, **kwargs):
        if isinstance(func, staticmethod):
            if len(args) > 0:
                args = args[1::] if not isinstance(args[0], ENUM) else args
            func_name = func.__func__.__name__
            result = func.__func__(*args, **kwargs)
        elif isinstance(func, classmethod):
            _args = [func.__class__]
            if len(args) > 0:
                args = args[1::] if not isinstance(args[0], ENUM) else args
            _args.extend(list(args))
            func_name = func.__func__.__name__
            result = func.__func__(*_args, **kwargs)
        else:
            func_name = func.__name__
            result = func(*args, **kwargs)
        logger.info("[ Func {} Called ]".format(func_name))
        logger.info("[ Func Paramter ]: Args: {}, Kwargs: {}".format(args, kwargs))
        logger.info("[ Func Result ]: {}({}, {})".format(func_name, args, kwargs))
        return result
    return wrap


class LoggerMeta(type):

    def __new__(mcs, name, bases, properties):
        wrap_properties = {}
        for key, value in properties.items():
            if isinstance(value, classmethod):
                wrap_properties[key] = classmethod(log(value.__func__))
            elif isinstance(value, staticmethod):
                wrap_properties[key] = staticmethod(log(value.__func__))
            elif key.startswith('__') or isinstance(value, property):
                wrap_properties[key] = value
            else:
                wrap_properties[key] = log(value)
        properties.update({"logger": logger})
        properties.update(**wrap_properties)
        return type.__new__(mcs, name, bases, properties)


class TestMetaLogger(metaclass=LoggerMeta):
    def __init__(self):
        self.index = 1
        self.end = 10

    @staticmethod
    def test_func_log(a, b):
        return a, b

    def test_aaa_log(self, a, b):
        return a, b

    @classmethod
    def test_bbb_log(cls, a, b):
        return a, b

    @staticmethod
    def test_ccc_log():
        return 111

    @classmethod
    def test_ddd_log(cls):
        return 222

    @property
    def test_property(self):
        return self.end


if __name__ == '__main__':
    instance = TestMetaLogger()
    TestMetaLogger.test_func_log(7, 8)
    TestMetaLogger.test_bbb_log(9, 10)
    instance.test_aaa_log(1, 2)
    instance.test_func_log(3, 4)
    instance.test_bbb_log(5, 6)
    TestMetaLogger.test_ccc_log()
    instance.test_ccc_log()
    TestMetaLogger.test_ddd_log()
    instance.test_ddd_log()
    print(instance.test_property)