首先要明確：
ORM的編寫較為複雜，但編寫完成後使用介面進行呼叫則顯得非常簡單。並且ORM編寫模式基本為
-Field模組
-元類MetaClass
-基類Model
有著較為固定的寫法，沒必要重複造輪子，能複用儘量複用。重要的是要理解元類這塊硬骨頭的妙用。
基本思路：
（收集資料；對這些資料進行分類，識別(相對應資料庫)，生成SQL語句；最後，連線資料庫，並執行SQL語句進行操作。）

• User類負責收集資料，並嘗試歸類出這些資料對應資料庫表的對映關係，類如對應表的欄位（包含名字、型別、是否為表的主鍵、預設值）等；
• 它的基類負責執行操作，比如資料庫的儲存、讀取，查詢等操作；
• 它的元類負責分類、整理收集的資料並以此建立一些類屬性(如SQL語句)供基類作為引數。

即

1. 在一個Web App中，所有的資料，包括使用者資訊，使用者釋出的日誌，評論都放在資料庫中，本次實戰使用MySQL作為資料庫。
2. Web App中，有許多地方都要用到資料庫，訪問資料要建立資料庫連線，建立遊標物件，執行SQL語句，然後要處理異常，清理資源等。
3. 首先，要封裝資料庫的SELECT,INSERT,UPDATE,DELETE語句
4. 其次，由於Web框架使用了基於asyncio的aiohttp，這是基於協程的非同步模型。Web App框架採用非同步IO程式設計，aiomysql為MySQL資料庫提供了非同步IO的驅動。
   一旦決定使用非同步，則系統每一層都必須是非同步，“開弓沒有回頭箭”。
   一步非同步，步步非同步
   
   期待程式碼

# 建立例項:
user = User(id=123, name='Michael')
# 存入資料庫:
user.insert()
# 查詢所有User物件:
users = User.findAll()

完整程式碼

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import asyncio, logging

import aiomysql


def log(sql, args=()):
    logging.info('SQL: %s' % sql)

async def create_pool(loop, **kw):
    logging.info('create database connection pool...')
    global __pool
    __pool = await 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=kw.get('minsize', 1),
        loop=loop
    )
#單獨封裝select，其他insert,update,delete一併封裝，理由如下：
#使用Cursor物件執行insert，update，delete語句時，執行結果由rowcount返回影響的行數，就可以拿到執行結果。
#使用Cursor物件執行select語句時，通過featchall()可以拿到結果集。結果集是一個list，每個元素都是一個tuple，對應一行記錄。
async def select(sql, args, size=None):
    log(sql, args)
    global __pool
    async with __pool.get() as conn:#開啟pool的方法：with await __pool as conn: 
        # 建立一個結果為字典的遊標
        async with conn.cursor(aiomysql.DictCursor) as cur:
            # 執行sql語句，將sql語句中的'?'替換成'%s'
            await cur.execute(sql.replace('?', '%s'), args or ())
            # 如果指定了數量，就返回指定數量的記錄，如果沒有，就返回所有記錄
            if size:
                rs = await cur.fetchmany(size)
            else:
                rs = await cur.fetchall()
        logging.info('rows returned: %s' % len(rs))
        return rs#返回的結果集

async def execute(sql, args, autocommit=True):
    log(sql)
    async with __pool.get() as conn:
        if not autocommit:
            await conn.begin()
        try:
            async with conn.cursor(aiomysql.DictCursor) as cur:
                await cur.execute(sql.replace('?', '%s'), args)
                # 獲取操作的記錄數
                affected = cur.rowcount
            if not autocommit:
                await conn.commit()
        except BaseException as e:
            if not autocommit:
                await conn.rollback()#資料回滾
            raise
        return affected
		
#用於輸出元類中建立sql_insert語句中的佔位符,計算需要拼接多少個佔位符
def create_args_string(num):
    L = []
    for n in range(num):
        L.append('?')
    return ', '.join(L)

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 '<%s, %s:%s>' % (self.__class__.__name__, self.column_type, self.name)

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=False):
        super().__init__(name, 'boolean', False, default)

class IntegerField(Field):

    def __init__(self, name=None, primary_key=False, default=0):
        super().__init__(name, 'bigint', primary_key, default)

class FloatField(Field):

    def __init__(self, name=None, primary_key=False, default=0.0):
        super().__init__(name, 'real', primary_key, default)

class TextField(Field):

    def __init__(self, name=None, default=None):
        super().__init__(name, 'text', False, default)

        
#定義Model的metaclass元類
#所有的元類都繼承自type
#ModelMetaclass元類定義了所有Model基類（繼承ModelMetaclass）的子類實現的操作

# -*-ModelMetaclass：為一個數據庫表對映成一個封裝的類做準備
# 讀取具體子類(eg：user)的對映資訊
#創造類的時候，排除對Model類的修改
#在當前類中查詢所有的類屬性(attrs),如果找到Field屬性，就儲存在__mappings__的dict裡，
#同時從類屬性中刪除Field（防止例項屬性覆蓋類的同名屬性）
#__table__儲存資料庫表名
class ModelMetaclass(type):
    # 呼叫__init__方法前會呼叫__new__方法
    def __new__(cls, name, bases, attrs):
    # cls：當前準備建立的類的物件，name：類的名稱，
    # bases：類繼承的父類集合，attrs：類的方法集合
        if name=='Model':
            return type.__new__(cls, name, bases, attrs)
        # 獲取table名稱，如果未設定，tableName就是類的名字
        tableName = attrs.get('__table__', None) or name
        logging.info('found model: %s (table: %s)' % (name, tableName))
        # 獲取所有的Field（類屬性）和主鍵名:
		mappings = dict() #儲存對映關係
        fields = [] #儲存除主鍵外的屬性
        primaryKey = None
        # key是列名，value是field的子類
        for k, v in attrs.items():
            if isinstance(v, Field):
                logging.info('  found mapping: %s ==> %s' % (k, v))
                mappings[k] = v
                if v.primary_key:
                    # 找到主鍵:
                    if primaryKey:
                        raise StandardError('Duplicate primary key for field: %s' % k)
                    primaryKey = k#此列設為列表的主鍵
                else:
                    #非主鍵，一律放在fields  
                    fields.append(k)
        if not primaryKey:# 如果遍歷了所有屬性都沒有找到主鍵，則主鍵沒定義
            raise StandardError('Primary key not found.')
        #從類屬性中刪除Field屬性
        for k in mappings.keys():
            attrs.pop(k)#從類屬性中刪除Field屬性,否則，容易造成執行時錯誤（例項的屬性會遮蓋類的同名屬性）
        
        # 儲存非主鍵屬性為字串列表形式
        # 將非主鍵屬性變成`id`,`name`這種形式（帶反引號）
        # repr函式和反引號的功能一致：取得物件的規範字符串表示
        # 將fields中屬性名以`屬性名`的方式裝飾起來
        escaped_fields = list(map(lambda f: '`%s`' % f, fields))
        attrs['__mappings__'] = mappings # 儲存屬性和列的對映關係
        attrs['__table__'] = tableName# 儲存表名
        attrs['__primary_key__'] = primaryKey # 主鍵屬性名
        attrs['__fields__'] = fields # 除主鍵外的屬性名
        
        # 構造預設的SELECT, INSERT, UPDATE和DELETE語句
        attrs['__select__'] = 'select `%s`, %s from `%s`' % (primaryKey, ', '.join(escaped_fields), tableName)
        attrs['__insert__'] = 'insert into `%s` (%s, `%s`) values (%s)' % (tableName, ', '.join(escaped_fields), primaryKey, create_args_string(len(escaped_fields) + 1))
        attrs['__update__'] = 'update `%s` set %s where `%s`=?' % (tableName, ', '.join(map(lambda f: '`%s`=?' % (mappings.get(f).name or f), fields)), primaryKey)
        attrs['__delete__'] = 'delete from `%s` where `%s`=?' % (tableName, primaryKey)
        return type.__new__(cls, name, bases, attrs)


#定義ORM所有對映的基類：Model
#Model類的任意子類可以對映一個數據庫表
#Model類可以看做是對所有資料庫表操作的基本定義的對映
#基於字典查詢形式
#Model從dict繼承，擁有字典的所有功能，同時實現特殊方法__getattr__和__setattr__,能夠實現屬性操作
#實現資料庫操作的所有方法，定義為class方法，所有繼承自Model都具有資料庫操作方法
        
        
class Model(dict, metaclass=ModelMetaclass):
    #也可在此處寫  __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 getValue(self, key):
		# 返回物件的屬性，如果沒有對應屬性，則會呼叫__getattr__
		#直接調回內建函式，注意這裡沒有下劃符,注意這裡None的用處,是為了當user沒有賦值資料時，返回None，調用於update
        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.debug('using default value for %s: %s' % (key, str(value)))
				# 將預設值設定進行
                setattr(self, key, value)
        return value
	 # 類方法第一個引數為cls，而例項方法第一個引數為self
    @classmethod
	    #這裡可以使用User.findAll()是因為：用@classmethod修飾了Model類裡面的findAll()
        #一般來說，要使用某個類的方法，需要先例項化一個物件再呼叫方法
        #而使用@staticmethod或@classmethod，就可以不需要例項化，直接類名.方法名()來呼叫
		#申明是類方法：有類變數cls傳入，cls可以做一些相關的處理
		#有子類繼承時，呼叫該方法，傳入的類變數cls是子類，而非父類
    async def findAll(cls, where=None, args=None, **kw):
        ' find objects by where clause. '
        sql = [cls.__select__]
        # 如果where查詢條件存在
        if where:
            sql.append('where')# 新增where關鍵字
            sql.append(where)  # 拼接where查詢條件
        if args is None:
            args = []
        orderBy = kw.get('orderBy', None)# 獲取kw裡面的orderby查詢條件
        if orderBy:
            sql.append('order by')# 拼接orderBy字串
            sql.append(orderBy)# 拼接orderBy查詢條件
        limit = kw.get('limit', None)# 獲取limit查詢條件
        if limit is not None:
            sql.append('limit')
            if isinstance(limit, int):# 如果limit是int型別
                sql.append('?')# sql拼接一個佔位符
                args.append(limit)# 將limit新增進引數列表，之所以新增引數列表之後再進行整合是為了防止sql注入
            elif isinstance(limit, tuple) and len(limit) == 2:# 如果limit是一個tuple型別並且長度是2
                sql.append('?, ?')# sql語句拼接兩個佔位符
                args.extend(limit)# 將limit新增進引數列表
            else:
                raise ValueError('Invalid limit value: %s' % str(limit))
        rs = await select(' '.join(sql), args) # 將args引數列表注入sql語句之後，傳遞給select函式進行查詢並返回查詢結果
        return [cls(**r) for r in rs]

    @classmethod
    #查詢某個欄位的數量
    async def findNumber(cls, selectField, where=None, args=None):
        ' find number by select and where. '
		 # 將列名重新命名為_num
        sql = ['select %s _num_ from `%s`' % (selectField, cls.__table__)]
        if where:
            sql.append('where')
            sql.append(where)
			# 限制結果數為1
        rs = await select(' '.join(sql), args, 1)
        if len(rs) == 0:
            return None
        return rs[0]['_num_']

    @classmethod
    
    async def find(cls, pk):
        ' find object by primary key. '
        rs = await select('%s where `%s`=?' % (cls.__select__, cls.__primary_key__), [pk], 1)
        if len(rs) == 0:
            return None
        return cls(**rs[0])
		#返回一條記錄，以dict的形式返回，因為cls的父類繼承了dict類


    async def save(self):
		# 獲取所有value
        args = list(map(self.getValueOrDefault, self.__fields__))
        args.append(self.getValueOrDefault(self.__primary_key__))
        rows = await execute(self.__insert__, args)
        if rows != 1:
            logging.warn('failed to insert record: affected rows: %s' % rows)

    async def update(self):
        args = list(map(self.getValue, self.__fields__))
        args.append(self.getValue(self.__primary_key__))
        rows = await execute(self.__update__, args)
        if rows != 1:
            logging.warn('failed to update by primary key: affected rows: %s' % rows)

    async def remove(self):
        args = [self.getValue(self.__primary_key__)]
        rows = await execute(self.__delete__, args)
        if rows != 1:
            logging.warn('failed to remove by primary key: affected rows: %s' % rows)