ITPub博客

首页 > 应用开发 > Python > 由ORM谈Python元类

由ORM谈Python元类

原创 Python 作者:小米运维 时间:2019-01-02 15:29:25 0 删除 编辑

本文主要介绍了什么是类,如何动态的创建类,什么是元类,类的_metaclass_属性以及如何自己实现ORM。


在谈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


来自 “ ITPUB博客 ” ,链接:http://blog.itpub.net/31559359/viewspace-2287154/,如需转载,请注明出处,否则将追究法律责任。

请登录后发表评论 登录
全部评论

注册时间:2018-10-26

  • 博文量
    59
  • 访问量
    59917