由ORM谈Python元类

本文主要介绍了什么是类，如何动态的建立类，什么是元类，类的_metaclass_属性以及如何本身实现ORM。
上篇文章回顾： 浅谈TLS 1.3

在谈Python元类以前，咱们先来看看ORM是什么：

ORM 为Object Relational Mapping 的简称，中文意思为对象关系映射，ORM的出现，是为了解决面向对象和关系数据库之间不相匹配而出现的技术，目的是使用面向对象的思想来实现对数据库中表的操做，从而屏蔽掉底层的SQL操做。

简单了解了ORM的概念，许多同窗可能会想了解ORM是怎么实现的，如下代码摘自django项目ORM的部分实现代码：

def subclass_exception(name, parents, module, attached_to=None):
    """ Create exception subclass. Used by ModelBase below. If 'attached_to' is supplied, the exception will be created in a way that allows it to be pickled, assuming the returned exception class will be added as an attribute to the 'attached_to' class. """
    class_dict = {'__module__': module}
    if attached_to is not None:
            def __reduce__(self):
               # Exceptions are special - they've got state that isn't
               # in self.__dict__. We assume it is all in self.args.
               return (unpickle_inner_exception, (attached_to, name), self.args)

            def __setstate__(self, args):
               self.args = args

        class_dict['__reduce__'] = __reduce__
        class_dict['__setstate__'] = __setstate__

    return type(name, parents, class_dict)复制代码

不少同窗会好奇，type 不是通常来检测Python变量的类型的嘛，怎么在这里居然能够接受这么多参数，在这里他的用法究竟是什么呢？ 这就涉及到了Python 的元类(metaclass)相关知识，而ORM，则是元类的应用之一。

什么是类？

简单来讲，类就是用一种使用相对固定的格式，来描述如何生成对象的一段代码，在Python中，咱们使用以下格式来生成类：

class MyClass(object):
    pass复制代码

可是同时，类又是一种特殊的对象，称之为classobj，可使用type来测定出：

>>> class MyClass():
...     pass
...
>>> type(MyClass)
<type 'classobj'
>>>> type(MyClass())
<type 'instance'>复制代码

同时，它也具备对象的所有特征，如你能够对他进行赋值，拷贝，增长属性等的操做，以下示例：

>>> class MyClass():
...     pass
...
>>> print MyClass
__main__.MyClass
>>> a = MyClass
>>> print a
__main__.MyClass
>>> MyClass.__dict__
{'__module__': '__main__', '__doc__': None}
>>> MyClass.a = 100
>>> MyClass.__dict__
{'a': 100, '__module__': '__main__', '__doc__': None}
>>>
>>> MyClass.a = 200
>>> MyClass.a200
>>>复制代码

如何动态的建立类？

最简单的方法，就是采用以下方法：

def create_class(class_name):
    if class_name == "MyClass":
        class MyClass():
            pass
        return MyClass
    else:
        class OtherClasss():
            pass
        return OtherClasss复制代码

可是此类方法，不能称之为真正的动态，由于只能支持有限的类的建立，那有什么方法，能真正实现动态建立一些类呢？ 因此，这里就不得不提到关键词type了，首先，咱们大多数人谈起type，首先想到的是，type不就是用来测试变量类型的嘛，以下：

>>> print type(1)<type 'int'
>>>> print type("1")<type 'str'
>>>> class A():
...     pass
...
>>> type(A)<type 'classobj'
>>>> type(A())
<type 'instance'>复制代码

可是与此同时，type还有另外一个神奇的能力，就是它也能动态的建立类。type能够接受一个类的相关信息做为参数，而后返回一个类。 下面是其用法：

type(类名, 父类的元组，包含属性的字典)复制代码

什么是元类？

上面提到了类是一种特殊的对象，对象就必须有类来建立，而元类，就是用来建立这种类的。简单来讲，用于建立类的类，就是元类。 能够理解为一下这种方式：

MyClass = MetaClass()
MyObject = MyClass()复制代码

而type，就是元类，因而建立一个类，就可使用以下这种方式：

MyClass = type("MyClass", (), {})
MyObject = MyClass()复制代码

类的_metaclass_属性

当咱们建立一个类的时候为其添加__metaclass__属性：

class Foo(object):
    __metaclass__ = something…
[…]复制代码

那么，Python就会采用你指定的方法，来建立这个类，不然，会使用type来建立这个类，下面演示如何自定义的指定metaclass属性：

def lower_attr(class_name, class_parents, class_attr):
    lower_attr = {}
    for name, val in class_attr.items():
        if name.startswith('__'):
           lower_attr[name] = val
        else:
           lower_attr[name.lower()] = val
    return type(class_name, class_parents, lower_attr)

class MyClss():
    __metaclass__ = lower_attr
    A = 'A'
    b = 'b'

my_class = MyClss()

print hasattr(my_class, 'A') # False
print hasattr(my_class, 'b') # True
print hasattr(my_class, 'a') # True复制代码

如何本身实现ORM？

首先来定义Field类，它负责保存数据库表的字段名和字段的类型：

class Field(object):
    def __init__(self, name, column_type):
        self.name = name
        self.column_type = column_type复制代码

在Field的基础上，进一步定义各类具体类型的Field，好比StringField，IntegerField等等：

class StringField(Field):
    def __init__(self, name, max_length):
        super(StringField, self).__init__(name, 'varchar(%d)' % max_length)

class IntegerField(Field):
    def __init__(self, name):
        super(IntegerField, self).__init__(name, 'int')复制代码

下一步，就是编写最复杂的ModelMetaclass了：

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

以及基类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))复制代码

建立User类，并调用save方法，保存：

class User(Model):
    id = IntegerField('id')
    name = StringField('username', max_length=48)
    email = StringField('email', max_length=128)
    password = StringField('password', max_length=24)

# 建立一个实例：
u = User(id=12345, name='xiaoming', email='xiaoming@xiaomi.com', password='test')
# 保存到数据库：
u.save()复制代码

上面，咱们就简单实现了一个ORM。

参考连接

stackoverflow：

https://stackoverflow.com/questions/100003/what-are-metaclasses-in-python

廖雪峰的官方网站：

https://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493182103fac9270762a000/001386820064557c69858840b4c48d2b8411bc2ea9099ba000

本文首发于公众号“小米运维”，点击查看原文。