前言：

最近才狠下心来准备做一个自己的博客原先FuckBlog项目由于后端小伙伴加班而搁置，因此作为团队PM的我自己也要开始做技术方面了，准备自己先写一个博客看看。

备注- ORM全称：object related mapping 对象关系映射

0x00 为什么需要写一个ORM

首先，我觉得数据库操作不封装是很傻比的。原来我写了一个数据库导入工具，全篇导出都是sql语句什么增删改查都他妈齐活的在各个py里面跑来跑去。给大家上一张图：

大家体会到这种乱跑的辛酸了么从那次失败的架构我就说：再不用orm我他妈就是一傻逼

其次就是不安全，我这里再给大家举一个反例使我们FuckBlog项目里面后端小伙伴采用了一个异常简单的后台模板我在查看代码的时候发现了问题我们看用户验证的代码：

看到了么传输的用户名密码居然是直接放进sql语句拼接的。大家知道怎么构造 password来达到我们想要的任意用户名都可以登录的效果了么有几个月了我简单说一下思路首先引号闭合闭合之后然后在+ or +构造万能查询语句只要能查询成功，就到让session进行赋值。

最后呢就是在web中因为：

一处异步调用处处异步调用

我们在查询数据库中肯定不能因为数据量过大而放弃其他的请求这样效率非常慢所以这方面的控制以及上文所述的问题需要我们去封装而方便我们的调用和请求。因此我们需要自己写一个orm工具类去完成异步的增删改查

0x01 `ORM` 编写的一些难点

我跟着廖雪峰大神的博客来学习期间也看了不少人的跑通代码自己的疑问点期初看的时候也很多当然自己慢慢一点一点啃啃几天就会发现豁然开朗。

代码加上测试一共三百多行，非常简洁，当然我估计注释就能占到八九十行，包括别人的也包括自己第一篇学习的困惑和不了解。也算是比较实用吧。我先贴我第一版学习跑通的代码然后呢我会慢慢在后面进行阐述。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367

# -*- coding: utf-8 -*-
# 2017/1/4 11:02

"""
-------------------------------------------------------------------------------
Function:   封装的ORM工具类
Version:    1.0
Author:     SLY
Contact:    [email protected] 
 
code is far away from bugs with the god animal protecting
               ┏┓      ┏┓
            ┏┛┻━━━┛┻┓
            ┃            ┃
            ┃  ┳┛  ┗┳  ┃
            ┃      ┻      ┃
            ┗━┓      ┏━┛
                ┃      ┗━━━┓
                ┃  神兽保佑    ┣┓
                ┃　永无BUG！   ┏┛
                ┗┓┓┏━┳┓┏┛
                  ┃┫┫  ┃┫┫
                  ┗┻┛  ┗┻┛
-------------------------------------------------------------------------------

"""

import sys

import asyncio

import logging

logging.basicConfig(level=logging.INFO)
# 一次使用异步 处处使用异步

import aiomysql
 

def log(sql,args=()):

    logging.info('SQL:%s' %sql)

@asyncio.coroutine

def create_pool(loop, **kw):

    logging.info(' start creating database connection pool')

    global __pool

    # 理解这里的yield from 是很重要的

    __pool=yield from aiomysql.create_pool(

        host=kw.get('host','localhost'),

        port=kw.get('port',3306),

        user=kw['user'],

        password=kw['password'],

        db=kw['db'],

        charset=kw.get('charset','utf8'),

        autocommit=kw.get('autocommit',True),

        maxsize=kw.get('maxsize',10),

        # 目前不清楚这个minsize是什么鬼

        minsize=kw.get('minsize',1),

        loop=loop

        )
 

@asyncio.coroutine

def destroy_pool():

    global __pool

    if __pool is not None :

        __pool.close()

        yield from __pool.wait_closed()
 
# 我很好奇为啥不用commit 事务不用提交么

@asyncio.coroutine

def select(sql, args, size=None):

    log(sql,args)

    global __pool

    # 666 建立游标

    # -*- yield from 将会调用一个子协程，并直接返回调用的结果

    # yield from从连接池中返回一个连接

    with (yield from __pool)as conn:

        cur = yield from conn.cursor(aiomysql.DictCursor)

        yield from cur.execute(sql.replace('?', '%s'), args)

        if size:

            rs = yield from cur.fetchmany(size)

        else:

            rs = yield from cur.fetchall()

        yield from cur.close()

        logging.info('rows have returned %s' %len(rs))

    return rs
 
 
# 封装INSERT, UPDATE, DELETE
# 语句操作参数一样，所以定义一个通用的执行函数
# 返回操作影响的行号
# 我想说的是 知道影响行号有个叼用
 

@asyncio.coroutine

def execute(sql,args, autocommit=True):

    log(sql)

    global __pool

    with (yield from __pool) as conn:

        try:

            # 因为execute类型sql操作返回结果只有行号，不需要dict

            cur = yield from conn.cursor()

            # 顺便说一下 后面的args 别掉了 掉了是无论如何都插入不了数据的

            yield from cur.execute(sql.replace('?', '%s'), args)

            yield from conn.commit()

            affected_line=cur.rowcount

            yield from cur.close()

            print('execute : ', affected_line)

        except BaseException as e:

            raise

        return affected_line
 
# 这个函数主要是把查询字段计数 替换成sql识别的?
# 比如说：insert into  `User` (`password`, `email`, `name`, `id`) values (?,?,?,?)  看到了么 后面这四个问号

def create_args_string(num):

    lol=[]

    for n in range(num):

        lol.append('?')

    return (','.join(lol))
 
# 定义Field类，负责保存(数据库)表的字段名和字段类型

class Field(object):

    # 表的字段包含名字、类型、是否为表的主键和默认值

    def __init__(self, name, column_type, primary__key, default):

        self.name = name

        self.column_type=column_type

        self.primary_key=primary__key

        self.default=default

    def __str__(self):

        # 返回 表名字 字段名 和字段类型

        return "&lt;%s , %s , %s&gt;" %(self.__class__.__name__, self.name, self.column_type)
# 定义数据库中五个存储类型

class StringField(Field):

    def __init__(self, name=None, primary_key=False, default=None, ddl='varchar(100)'):

        super().__init__(name,ddl,primary_key,default)
# 布尔类型不可以作为主键

class BooleanField(Field):

    def __init__(self, name=None, default=None):

        super().__init__(name,'Boolean',False, default)
# 不知道这个column type是否可以自己定义 先自己定义看一下

class IntegerField(Field):

    def __init__(self, name=None, primary_key=False, default=0):

        super().__init__(name, 'int', primary_key, default)

class FloatField(Field):

    def __init__(self, name=None, primary_key=False,default=0.0):

        super().__init__(name, 'float', primary_key, default)

class TextField(Field):

    def __init__(self, name=None, default=None):

        super().__init__(name,'text',False, default)
# class Model(dict,metaclass=ModelMetaclass):
 
# -*-定义Model的元类
 
# 所有的元类都继承自type
# ModelMetaclass元类定义了所有Model基类(继承ModelMetaclass)的子类实现的操作
 
# -*-ModelMetaclass的工作主要是为一个数据库表映射成一个封装的类做准备：
# ***读取具体子类(user)的映射信息
# 创造类的时候，排除对Model类的修改
# 在当前类中查找所有的类属性(attrs)，如果找到Field属性，就将其保存到__mappings__的dict中，同时从类属性中删除Field(防止实例属性遮住类的同名属性)
# 将数据库表名保存到__table__中
 
# 完成这些工作就可以在Model中定义各种数据库的操作方法
# metaclass是类的模板，所以必须从`type`类型派生：

class ModelMetaclass(type):

    # __new__控制__init__的执行，所以在其执行之前

    # cls:代表要__init__的类，此参数在实例化时由Python解释器自动提供(例如下文的User和Model)

    # bases：代表继承父类的集合

    # attrs：类的方法集合

    def __new__(cls, name, bases, attrs):

        # 排除model 是因为要排除对model类的修改

        if name=='Model':

            return type.__new__(cls, name, bases, attrs)

        # 获取table名称 为啥获取table名称 至于在哪里我也是不明白握草

        table_name=attrs.get('__table__', None) or name

        logging.info('found table: %s (table: %s) ' %(name,table_name ))

        # 获取Field所有主键名和Field

        mappings=dict()

        fields=[]

        primaryKey=None

        # 这个k是表示字段名

        for k, v in attrs.items():

            if isinstance(v, Field):

                logging.info('Found mapping %s===&gt;%s' %(k, v))

            # 注意mapping的用法

                mappings[k] = v

                if v.primary_key:

                    logging.info('fond primary key hahaha %s'%k)

                    # 这里很有意思 当第一次主键存在primaryKey被赋值 后来如果再出现主键的话就会引发错误

                    if primaryKey:

                        raise RuntimeError('Duplicated key for field')

                    primaryKey=k

                else:

                    fields.append(k)
 

        if not primaryKey:

            raise RuntimeError('Primary key not found!')

        # w下面位字段从类属性中删除Field 属性

        for k in mappings.keys():

            attrs.pop(k)
 

        # 保存除主键外的属性为''列表形式

        # 这一句的lambda表达式没懂

        escaped_fields=list(map(lambda f:'`%s`' %f, fields))

        # 保存属性和列的映射关系

        attrs['__mappings__']=mappings

        # 保存表名

        attrs['__table__']=table_name

        # 保存主键名称

        attrs['__primary_key__']=primaryKey

        # 保存主键外的属性名

        attrs['__fields__']=fields

        # 构造默认的增删改查 语句

        attrs['__select__']='select `%s`, %s from `%s` '%(primaryKey,', '.join(escaped_fields), table_name)

        attrs['__insert__'] = 'insert into  `%s` (%s, `%s`) values (%s) ' %(table_name, ', '.join(escaped_fields), primaryKey, create_args_string(len(escaped_fields)+1))

        attrs['__update__']='update `%s` set %s where `%s` = ?' %(table_name, ', '.join(map(lambda f:'`%s`=?' % (mappings.get(f).name or f), fields)), primaryKey)

        attrs['__delete__']='delete `%s` where `%s`=?' %(table_name, primaryKey)

        return type.__new__(cls, name, bases, attrs)
 
 
# 定义ORM所有映射的基类：Model
# Model类的任意子类可以映射一个数据库表
# Model类可以看作是对所有数据库表操作的基本定义的映射
 
 
# 基于字典查询形式
# Model从dict继承，拥有字典的所有功能，同时实现特殊方法__getattr__和__setattr__，能够实现属性操作
# 实现数据库操作的所有方法，定义为class方法，所有继承自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("'Model' object have no attribution: %s"% key)

    def __setattr__(self, key, value):

        self[key] =value

    def getValue(self, key):

        # 这个是默认内置函数实现的

        return getattr(self, key, None)
 

    def getValueOrDefault(self, key):

        value=getattr(self, key , None)

        if value is None:

            field = self.__mappings__[key]

            if field.default is not None:

                value = field.default() if callable(field.default) else field.default

                logging.info('using default value for %s : %s ' % (key, str(value)))

                setattr(self, key, value)
 

        return value
 

    @classmethod

    # 类方法有类变量cls传入，从而可以用cls做一些相关的处理。并且有子类继承时，调用该类方法时，传入的类变量cls是子类，而非父类。

    @asyncio.coroutine
 

    def find_all(cls, where=None, args=None, **kw):

        sql = [cls.__select__]

        if where:

            sql.append('where')

            sql.append(where)

        if args is None:

            args = []
 

        orderBy = kw.get('orderBy', None)

        if orderBy:

            sql.append('order by')

            sql.append(orderBy)

        # dict 提供get方法 指定放不存在时候返回后学的东西 比如a.get('Fuck',None)

        limit = kw.get('limit', None)

        if limit is not None:

            sql.append('limit')

            if isinstance(limit, int):

                sql.append('?')

                args.append(limit)

            elif isinstance(limit, tuple) and len(limit) ==2:

                sql.append('?,?')

                args.extend(limit)

            else:

                raise ValueError('Invalid limit value : %s '%str(limit))
 

        rs = yield from select(' '.join(sql),args)

        return [cls(**r) for r in rs]

    @classmethod

    @asyncio.coroutine

    def findNumber(cls, selectField, where=None, args=None):

        '''find number by select and where.'''

        sql = ['select %s __num__ from `%s`' %(selectField, cls.__table__)]

        if where:

            sql.append('where')

            sql.append(where)

        rs = yield from select(' '.join(sql), args, 1)

        if len(rs) == 0:

            return None

        return rs[0]['__num__']
 

    # 这个黑魔法我还在研究呢~

    @classmethod

    @asyncio.coroutine

    def find(cls, primarykey):

        '''find object by primary key'''

        rs = yield from select('%s where `%s`=?' %(cls.__select__, cls.__primary_key__), [primarykey], 1)

        if len(rs) == 0:

            return None

        return cls(**rs[0])
 

    @classmethod

    @asyncio.coroutine

    def findAll(cls, **kw):

        rs = []

        if len(kw) == 0:

            rs = yield from select(cls.__select__, None)

        else:

            args=[]

            values=[]

            for k, v in kw.items():

                args.append('%s=?' % k )

                values.append(v)

            rs = yield from select('%s where %s ' % (cls.__select__,  ' and '.join(args)), values)

        return rs
    

    @asyncio.coroutine

    def save(self):

        args = list(map(self.getValueOrDefault, self.__fields__))

        print('save:%s' % args)

        args.append(self.getValueOrDefault(self.__primary_key__))

        rows = yield from execute(self.__insert__, args)

        if rows != 1:

            print(self.__insert__)

            logging.warning('failed to insert record: affected rows: %s' %rows)
 

    @asyncio.coroutine

    # 显示方言错误是什么鬼。。。

    def update(self):

        args = list(map(self.getValue, self.__fields__))

        args.append(self.getValue(self.__primary_key__))

        rows = yield from execute(self.__update__, args)

        if rows != 1:

            logging.warning('failed to update record: affected rows: %s'%rows)
 

    @asyncio.coroutine

    def remove(self):

        args = [self.getValue(self.__primary_key__)]

        rows = yield from execute(self.__updata__, args)

        if rows != 1:

            logging.warning('failed to remove by primary key: affected rows: %s' %rows)
 
 

if __name__=="__main__":

    class User(Model):

        id = IntegerField('id',primary_key=True)

        name = StringField('username')

        email = StringField('email')

        password = StringField('password')

    #创建异步事件的句柄

    loop = asyncio.get_event_loop()
 

    #创建实例

    @asyncio.coroutine

    def test():

        yield from create_pool(loop=loop,host='localhost', port=3308, user='sly', password='070801382', db='test')

        user = User(id=8, name='sly', email='[email protected]', password='fuckblog')

        yield from user.save()

        r = yield from User.find('11')

        print(r)

        r = yield from User.findAll()

        print(1, r)

        r = yield from User.findAll(id='12')

        print(2, r)

        yield from destroy_pool()
 

    loop.run_until_complete(test())

    loop.close()

    if loop.is_closed():

        sys.exit(0)

NO1：为何要使用`asyncore` 和 `aiomysql` 这两个库

假设我们调用数据库的请求不知一个，比如用户小王访问我们网站，获取你以前的文章，那么东北社会你关哥也在同一时间访问我们网站，而文章比较多，小王的请求需要5秒才能返回结果。采用同步的话，那社会你关哥就要等着小王请求王城才能进行请求（获得服务器关注）么？显然不行，因此需要采用异步的收发请求。而Python 中实现这个的就是asyncore 他封装了HTTP UDP SSL 的异步协议可以让单线程也可以异步收发请求。（如果你想自己实现套字节的异步收发返回，可以小小参考一下我的这篇网络脚本编写）

那aiohttp是什么鬼 aiomysql 又是什么叼东西。他们都是基于asyncore 实现的异步http库异步mysql 库调用他们就可以实现异步请求在http 和 mysql 上。记住：一处异步处处异步

NO2：关于日志的记录

引用日志模块logging 没有什么好说的需要注意的是在我们编写服务端的时候良好的日志记录习惯很重要不要被pycharm惯坏了动不动print大法 debug大法另外我想补充的是：logging这个吊玩儿，在多线程记录的时候会出错，需要改写其中的某些方法，别问我是如何知道的。对了，

level=logging.INFO

这个INFO大写。

NO3：*args **kw是什么东西？

*args 和 **kwargs 主要用于函数定义。 **kw就是**kwargs的缩写，可以传递数量不一的变量，他们的核心是前面的星号一颗星和两颗星而不是后面的args 你写成*fuckyou 都没事。只不过是约定俗称而已。那么这个屌丝东西怎么用呢？我们看一段示例代码：（我改自gitbook Python进阶）

1

2

3

4

5

6


def
test_var_args(f_arg,
*fuckyou):

    print("first
normal arg:",
f_arg)

    for
arg
in
fuckyou:

        print("another
arg through *fuckyou:",
arg)

 

test_var_args('yasoob',
'python',
'变量',
'test',
111)

输出结果：

我们再来看**kwargs

**kwargs ：该参数允许你将不定长度的键值对, 作为参数传递给一个函数。如果你想要在一个函数里处理带名字的参数, 你应该使用**kwargs。

你肯定回想啥叫键值对带名字的参数又是什么鬼我们来看这个例子：

1
2
3
4
5


def greet_me(**kwargs):

    for key, value in kwargs.items():

        print("{0} ==&gt; {1}".format(key, value))
 

greet_me(name='sly',email='[email protected]', qq='[email protected]', sex='man')

怎么样现在传的时候是不是有点小明白就像传递一个字典一样，比如这样：

1

2

3

4

5


def
greet_me(**fuckhahahhaa):

    for
key,
value
in
my_info.items():

        print("{0}
==&gt; {1}".format(key,
value))

my_info={'name':'sly','email':'[email protected]'}

greet_me(**my_info)

主要传进去my_info 是一个字典就好了。

一般来讲传递的顺序是 var *args **kwargs

这里面就顺便提一下，字典的get方法用法是get(key,value) 如果没有key对应的键值则返回设定value

比如

1
2
3
4
5
6
7


def greet_me(**fuckhahah):

    for key, value in my_info.items():

        print("{0} ==&gt; {1}".format(key, value))

        print(my_info.get(key))

        print('Fuck','None')

my_info={'name':'sly','email':'[email protected]'}

greet_me(**my_info)

返回就是：

email ==> [email protected]
[email protected]
Fuck None
name ==> sly
sly
Fuck None

NO3: `yield` 和 `yield from` 语法

我们都知道yield 或者说对yield 比较熟悉因为我们教学的案例常常就是 yield result 当一个生成器（英文：generator）。但是我们为了弄清楚这一系列的东西我们需要首先弄清楚迭代器生成器这些鬼东西。在这方面除了官方文档我还查阅了这个这个还有这个当然 IBM的也不错等等我就不一一列出了。

生成器的简析：

我们为啥需要生成器？假设我们需要处理草榴的所有用户信息，如果一次性就处理1000万的用户信息列表非常耗费内存，我们的本地电脑内存不够用，那么就需要一个分批处理草榴用户信息生成器的东西，当我们调用一次的时候返回1000用户信息列表即可，下一次调用就返回uid在1001-2000的用户就好了。但是你可能会问：函数里面的return咋知道你是下一次调用还是第三次第四次调用给你返回你想要的值呢？而这就是yield 存在的神奇方法，它能够记住。

而正因为yield 存在才使得我们不需要拥有存储 1000万草榴用户信息列表，就能逐步得到这些信息。内存占用极小。

那么可能会有人问：适用于生成器的对象自身需要可迭代能力么也就是说我必须要是一个字典列表啥的才行么？

事实上生成器调用的对象自身必须拥有可迭代能力，之所以你认为传递列表或者字典是你把迭代在Python里面的识别狭义化了。

什么是可迭代？什么东西可以记住当前调用位置？

可迭代是指一种可以在容器中逐个提取元素的能力。

（容器：将多个元素组合在一起的数据结构，常见的容器有 dict list tuple str 文本流以及他们这些的变形比如OrderedDict）

迭代器的内部状态可以记住当前调用位置

Python是如何识别一个对象拥有可迭代能力？

一个可迭代对象必须具备：

__iter__()

（为啥该命名方法前后有__因为这是Python特殊方法，以示区分，在OOP编程的后续会给大家讲到）

而迭代器呢则必须具备以下特殊方法：2.x是next()

__iter__()
__next__()

我们来看廖雪峰在IBM workplace上给的yield 斐波拉切数列案例

1

2

3

4

5

6

7

8

9

10

11


def
fab_yield(max):

    n,
a,
b
=
0,
0,
1

    while
n
&lt;
max:

        yield
b

        #
print b

        a,
b
=
b,
a
+
b

        n
=
n
+
1

f=fab_yield(100)

print(type(f))

for
i
in
f:

    print(i)

你最终会发现这个yield 让返回的对象变成了 generator 一个生成器。它让你关注的点更多的在算法实现上，而非存储上面。

那么我们该如何自己去实现这个迭代器呢？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17


class Fab(object):
 

    def __init__(self, max):

        self.max = max

        self.n, self.a, self.b = 0, 0, 1
 

    def __iter__(self):

        return self
 

    def __next__(self):

        if self.n &lt; self.max:

            r = self.b

            self.a, self.b = self.b, self.a + self.b

            self.n = self.n + 1

            return r
 

        raise StopIteration()

调用和拥有yield 的函数一样，同上。

如果还有疑问或者我的描述有错误的可以在博客评论中提出（mail写好我回复你会收到邮件~）

解释了yield 我们来看一下 yield from

关于yield from 这个Python 3.3 才支持的东西我们看一下：

首先，yield from 是为了解决什么问题而出现的。

看到上文我们发现一个问题，yield 不能脱离代码单独出来用，在一个生成器中调用另外一个生成器想要用，咋办那么我们就需要yield from

yield from的的历史可以参考这个PEP：

总之大意是原本的yield语句只能将CPU控制权还给直接调用者，当你想要将一个generator或者coroutine里带有yield语句的逻辑重构到另一个generator（原文是subgenerator）里的时候，会非常麻烦，因为外面的generator要负责为里面的generator做消息传递；所以某人有个想法是让python把消息传递封装起来，使其对程序猿透明，于是就有了yield from。

对于简单的迭代器，yield from iterable本质上等于for item in iterable: yield item的缩写版 yield from允许子生成器直接从调用者接收其发送的信息或者抛出调用时遇到的异常，并且返回给委派生产器一个值

那么在本次学习orm的过程中你就把他理解为异步执行即可先别管原理了。

如果大家仍旧很感兴趣可以参考这篇文章我能力有限就不画蛇添足了。

NO4. pool 和这个init__ 这些东西是啥？

这个就简单说一下前面一条杠就是非公开变量两条杠私有变量一条杠能调用两条杠就不允许外部调用。不像Java 那样有什么private 什么的别再和我说不能阻止外部调用很不安全私有变量不可以 You are Adult.

__str__ __init__ __name__ 这些都是特殊方法（或者魔术方法）内置的详细干嘛自己去Python官网看。

NO5. `@asyncore.coroutine` 是什么鬼？

它能够将一个生成器generator标记为coroutine类型，然后扔进Eventloop 异步执行。

这里我们需要回去复习廖雪峰大神关于asyncore的讲解。（这告诉我们翘课早晚是要还的不管你是网课还是自学）

1

2

3

4

5

6

7

8

9

10

11

12

13

14

# 引用这个模块主要是方便我们查看是不是一个进程完成的

import
threading

import
asyncio

@asyncio.coroutine

def
hello():

    print('Hello
world! (%s)'
%
threading.currentThread())

    yield
from
asyncio.sleep(3)

    print('Hello
again! (%s)'
%
threading.currentThread())

loop
=
asyncio.get_event_loop()

tasks
=
[hello(),
hello(),hello()]

loop.run_until_complete(asyncio.wait(tasks))

loop.close()

运行这段代码首先你会看到三个 hello world 然后过了三秒看到三个hello again这说明主进程并未在sleep停留而是直接将任务继续引入Eventloop中进行执行这相比那种单步一直让社会你关哥等的那种先进了一些。

0x03 撰写Python orm 的一些个人解释

NO1：设计Field类意义在哪里？

将数据库的类型与Python进行对应。比如说我们需要对数据库建表或者增删改查数据库的字段不仅有不同类型还有是否为主键的设置，这需要我们定一个class 类来进行定义。

1
2
3
4
5
6
7
8
9
10


class Field(object):

    # 表的字段包含名字、类型、是否为表的主键和默认值

    def __init__(self, name, column_type, primary__key, default):

        self.name = name

        self.column_type=column_type

        self.primary_key=primary__key

        self.default=default

    def __str__(self):

        # 返回 表名字 字段名 和字段类型

        return "&lt;%s , %s , %s&gt;" %(self.__class__.__name__, self.name, self.column_type)

这个__str__你可以理解为这个类的注释说明。在廖雪峰的定制类一篇有详细说明

print打印出来的信息就是来源于这个类。如果是调试显示的话是__repr__

这里提下：repr()方法可以强制返回类似于字符串的东西 str未必

这里有牛人的解释。

其次是后续的继承：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18


# 定义数据库中五个存储类型

class
StringField(Field):

    def
__init__(self,
name=None,
primary_key=False,
default=None,
ddl='varchar(100)'):

        super().__init__(name,ddl,primary_key,default)

# 布尔类型不可以作为主键

class
BooleanField(Field):

    def
__init__(self,
name=None,
default=None):

        super().__init__(name,'Boolean',False,
default)

# 不知道这个column type是否可以自己定义 先自己定义看一下

class
IntegerField(Field):

    def
__init__(self,
name=None,
primary_key=False,
default=0):

        super().__init__(name,
'int',
primary_key,
default)

class
FloatField(Field):

    def
__init__(self,
name=None,
primary_key=False,default=0.0):

        super().__init__(name,
'float',
primary_key,
default)

class
TextField(Field):

    def
__init__(self,
name=None,
default=None):

        super().__init__(name,'text',False,
default)

这个super()方法用于多态继承的，更新变量使用。

理解Python 中的元类（英文：`metalclass`）

我们都知道我们创建的实例一开始都继承object 这个基类那么当我们想创建类的时候我们需要继承怎么办？于是就有了基类。用 Tim Peters 的话来说就是我们一般不用这个，只有在写一些orm 或者高级封装的时候才会用到这个黑魔法。

Well, usually you don’t:

Metaclasses are deeper magic that 99% of users should never worry about. If you wonder whether you need them, you don’t (the people who actually need them know with certainty that they need them, and don’t need an explanation about why).

Python Guru Tim Peters

现在我们按照廖雪峰大神的例子场景还原：我们需要一个自定义的list 这个list能干嘛呢多一个fuck方法调用一次加一个‘fuck’在list末尾。是不是觉得很爽？

看看我改写的代码：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

# metaclass是类的模板，所以必须从`type`类型派生：

# __new__控制__init__的执行，所以在其执行之前

# cls:代表要__init__的类，此参数在实例化时由Python解释器自动提供

# bases：代表继承父类的集合

# attrs：类的方法集合

class
ListMetaclass(type):

    def
__new__(cls,
name,
bases,
attrs):

        attrs['fuck']
=
lambda
self:
self.append('fuck')

        return
type.__new__(cls,
name,
bases,
attrs)

class
mylist(list,metaclass=ListMetaclass):

    pass

a=mylist()

a.fuck()

print(a)

如何需要深入了解比如继承父类集合或者cls 是如何由Python 解释器自动提供我觉得额最好赶快去看源代码谢谢 ~

对了顺便提一下 @classmethod 作为一个装饰器为metalclass 提供方便。

一般来说，要使用某个类的方法，需要先实例化一个对象再调用方法。

而使用@staticmethod或@classmethod，就可以不需要实例化，直接类名.方法名()来调用。

如果你觉得有更好的在这方面的解释文章可以分享，可以推荐给我哈~

0x04 后记

忙完PornDetective 这三天就一直忙于这个ORM的学习，在学习过程中很有趣也很有意思。自己的能力也有所提高。希望这篇文章对大家能够有所帮助。

转载请注明：灯塔水母 » Python 编写ORM时的重难点掌握

Python 编写ORM时的重难点掌握

前言：

0x00 为什么需要写一个ORM

0x01 ORM 编写的一些难点

NO1： 为何要使用asyncore 和 aiomysql 这两个库