ORM对象关系映射
ORM
ORM对象关系映射：将对象映射成数据表中的一条条记录
类 映射为 ---> 数据表名
对象 ---> 数据记录（一条条数据 比如： "张三 18岁 男"）
对象.属性 ---> 数据字段（一条条数据中的具体数据 比如： "男" 或者 "18岁" 或者 "张三"）
# 演示映射关系（伪代码）
""" 比如User表中有名字，年龄，性别： User表： 名字、 年龄、 性别 apple、80、female class User: # User为表名 pass user_obj = User() # 获取记录 user_obj.name属性 # 获取user表中的name数据信息 user_obj.age属性 = 80 # 给user表添加数据 """
# 字段类型的定义，每个字段都应该有 字段名、字段类型、是否为主键、是否有默认值
# 字段类型父类 class Field: def __init__(self, name, column_type, primary_key=False, default=None): self.name = name self.column_type = column_type self.primary_key = primary_key self.default = default # varchar字段类型 class StringField(Field): def __init__(self, name, column_type="varchar(64)", primary_key=False, default=None): super().__init__(name, column_type, primary_key, default) # int字段类型 class IntegerField(Field): def __init__(self, name, column_type="int", primary_key=False, default=0): super().__init__(name, column_type, primary_key, default)
# Models类
# 问题1：每一张表类，都必须定义一个__init__方法，但是无法确定每张表的字段个数以及字段名字
# 解决1：通过继承dict字典类，让用户输入所需要添加的字段以及字段名字，解决该问题
# 问题2：继承的字典无法通过 "对象.属性" 的取值方式来取值，也无法通过 "对象.属性=属性值" 的方式来赋值
# 解决2：__getattr__方法解决了取值方式，__setattr__方法解决了赋值方式
# 1.让Models类继承dict字典类，所有子类继承Models就等于继承了dict类 class Models(dict): # 2.在 "对象.属性" 获取属性时，若 "没有该属性" 时触发 __getattr__ def __getattr__(self, item): # print(item) return self.get(item) # 2.当 "对象.属性 = 属性值" ，"添加或修改属性" 时触发 __setattr__ def __setattr__(self, key, value): self[key] = value # 假如User表中有 用户名和密码 两个字段 class User(Models): pass if __name__ == '__main__': # print(dict(username='apple', password='123')) # {'username': 'apple', 'password': '123'} # User类继承了dict类，相当于 User(username='apple', password='123') == dict(username='apple', password='123') user_obj = User(username='apple', password='123') print(user_obj) # print(res.get("username")) # 字典的取值方式一 # print(res["username"]) # 字典的取值方式二 print(user_obj.username) # 字典的取值方式三，也是我们需要实现的取值方式 ---> " user_obj.name属性 # 获取user表中的name数据信息 " print('添加属性前: ---> ', user_obj) # User类实例化出来的 user_obj 普通对象 添加属性的方式 user_obj.user_type = "admin" # 实现通过 对象.属性=属性值 添加数据 ---> " user_obj.age属性 = 80 # 给user表添加数据 " print(user_obj.user_type) print('添加属性后: ---> ', user_obj) # 验证是否将 user_type="admin" 添加到名称空间中
执行结果：
{'username': 'apple', 'password': '123'}
apple
添加属性前: ---> {'username': 'apple', 'password': '123'}
admin
添加属性后: ---> {'username': 'apple', 'password': '123', 'user_type': 'admin'}
ORM的作用（两点）
第一个作用：控制表类的创建，也就是使用元类控制表创建的过程
第二个作用：给表类封装 查、改(增、改、删)的方法，MySQL类的封装
一、元类控制表类的创建
字段类型的定义 + Model类 + 元类
# 创建表的三个注意点：
1.保证一张表必须要有表名字
2.保证一张表中只能有一个主键
3.将所有 "字段名"与"字段对象" 添加到一个独立的字典(mappings)中，以key(字段名):value(字段对象) 添加到类的名称空间中，方便后期使用
# 字段类型父类 class Field: 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 # varchar字段类型 class StringField(Field): def __init__(self, name, column_type="varchar(64)", primary_key=False, default=None): super().__init__(name, column_type, primary_key, default) # int字段类型 class IntegerField(Field): def __init__(self, name, column_type="int", primary_key=False, default=0): super().__init__(name, column_type, primary_key, default) # 自定义OrmMetaclass元类：控制类的创建过程 class OrmMetaclass(type): # __call__：先调用__new__，只要定义类就会触发__new__ def __new__(cls, class_name, class_bases, class_dict): # class_name：类名 class_bases：基类 class_dict：类的名称空间 # print(f"类名：{class_name}") # print(f"基类：{class_bases}") # print(f"类的名称空间：{class_dict}") # 过滤掉Models类，我们限制的是用户创建表的过程（可以说是用户创建表的规范），所以在此处过滤掉Models类，因为我们不限制Models类 if class_name == 'Models': return type.__new__(cls, class_name, class_bases, class_dict) # 第一个注意点：保证表必须要有表名。 获取table表名，若自定义则获取、没有则默认使用类名 # dict.get(key, class_name) key若有返回对应的值，若没有则返回默认值class_name就是默认值 table_name = class_dict.get("table_name", class_name) # 获取类名称空间的自定义表名table_name，若没有则默认以类名为表名 print(table_name) # userinfo，若未定义表名，那么表名为类名，此处即User # 自定义一个主键值标识，后面做逻辑判断使用 # 主键值：主键名为 字段名 primary_key = None # 比如主键是id，那么id字段就是主键值的名字(primary_key = id) # 第三个注意点：定义一个字典用来存放 "字段名"与"字段对象" mappings = {} print(class_dict) # 打印类中的名称空间 """ 执行结果： {'__module__': '__main__', '__qualname__': 'User', 'table_name': 'userinfo', 'id': <__main__.IntegerField object at 0x000000000287F1C8>, 'username': <__main__.StringField object at 0x000000000287F088>, 'password': <__main__.StringField object at 0x000000000287F388>} 上面class_dict的名称空间中，我们需要的仅仅是后面的id、username、password键值对属性，前两个不需要，我们需要将其剔除，后面将剔除后的结果重新放进mappings字典中 """ # 使用for循环将类中的名称空间字典 迭代依次取出 for k, v in class_dict.items(): # k为字段名，v为字段对象 # 将类中的名称空间无需的属性进行剔除筛选 # isinstance()：判断一个对象是否是另一个类的实例 if isinstance(v, Field): # id、username、password的value都是Field的实例 # print(k, v) # print(v.__dict__) # {'name': 'password', 'column_type': 'varchar(64)', 'primary_key': False, 'default': None} # 第三个注意点：将所有的 "字段名" 与 "字段对象" 添加到一个定义好的独立的字典(mappings)中 mappings[k] = v """ # 此处有一个坑： # class_attr.pop(k) # 这里当字典被迭代时，不能修改其属性 """ # 第二个注意点：保证一张表只能有一个唯一的主键 # 判断字段对象如果有主键 primary_key，则为primary_key变量赋值 if v.primary_key: # 如果建的表中有主键，执行下一步，若没有不执行下一步 # 若第二次执行到此处，primary_key有值，证明有主键，抛出异常 if primary_key: raise TypeError("一张表只能有一个主键！") primary_key = v.name # 将自定义的主键值标识修改为 字段对象中的名字(和字段名一样) # 给类的名称空间 添加table_name、primary_key、mappings属性 class_dict["table_name"] = table_name # 将表名添加到类的名称空间中 class_dict["primary_key"] = primary_key # 将主键添加到类的名称空间中 class_dict["mappings"] = mappings # 将存放 "字段名"与"字段对象"的字典添加到类的名称空间中 print(class_dict) """ 执行结果： {'__module__': '__main__', '__qualname__': 'User', 'table_name': 'userinfo', 'id': <__main__.IntegerField object at 0x000000000237F1C8>, 'username': <__main__.StringField object at 0x000000000237F088>, 'password': <__main__.StringField object at 0x000000000237F388>, 'table_name': 'User', 'primary_key': 'id', 'mappings': {'id': <__main__.IntegerField object at 0x000000000237F1C8>, 'username': <__main__.StringField object at 0x000000000237F088>, 'password': <__main__.StringField object at 0x000000000237F388>}} 上面class_dict的名称空间中，有重复的"字段名"与"字段对象"，在此将class_dict中重复的"字段名"与"字段对象"过滤掉 """ # 过滤掉类名称空间中重复的字段属性 for key in mappings.keys(): # 根据mappings中的字段属性来过滤掉class_dict中的字段属性,因为mappings中的字段属性在class_dict中的字段属性都存在 class_dict.pop(key) print(class_dict) """ 执行结果: {'__module__': '__main__', '__qualname__': 'User', 'table_name': 'userinfo', 'primary_key': 'id', 'mappings': {'id': <__main__.IntegerField object at 0x000000000283F1C8>, 'username': <__main__.StringField object at 0x000000000283F088>, 'password': <__main__.StringField object at 0x000000000283F388>}} 过滤完成！ """ # 若建立的表中所有字段都没有主键(规定每一张表中都需要有一个主键)，抛出异常 if not primary_key: raise TypeError("表中必须要有一个主键！") return type.__new__(cls, class_name, class_bases, class_dict) # 让Models类继承dict字典类，所有子类继承Models就等于继承了dict类 class Models(dict, metaclass=OrmMetaclass): # 在 "对象.属性" 获取属性时，若 "没有该属性" 时触发 __getattr__ def __getattr__(self, item): # print(item) return self.get(item) # 当 "对象.属性 = 属性值" ，"添加或修改属性" 时触发 __setattr__ def __setattr__(self, key, value): self[key] = value # 假如User表中有 id、用户名和密码 三个字段 class User(Models): table_name = "userinfo" # 自定义一个表名，若此处不写，表名默认即为类名User # 字段类中的name属性必须与User表中类属性同名 id = IntegerField(name="id", primary_key=True) username = StringField(name="username") password = StringField(name="password")
测试代码：
（错误演示）第一种：创建字段时不添加主键primary_key
（错误演示）第二种：创建字段时添加多个主键primary_key
（正确演示）：创建字段时只添加一个主键primary_key
二、MySQL类的封装
给表类封装 查、改(增、改、删)的方法
mysql_setting.py：编写代码
import pymysql # MySQL连接类 class MySQL: __instance = None @classmethod def Singleton(cls): if not cls.__instance: cls.__instance = cls() # 调用类产生对象，将对象赋值给__instance return cls.__instance # 实例化MySQL类时，获取数据库连接对象，获取游标对象 def __init__(self): self.client = pymysql.connect( host="127.0.0.1", port=3306, user="root", passwd="123", db="data", charset="utf8", autocommit=True ) # 获取游标 self.cursor = self.client.cursor(pymysql.cursors.DictCursor) # 自定义查询数据方法 def select(self, sql, args=None): # 1.先提交查询sql语句 # sql = "select * from table" # sql = "select * from table where id=%s" self.cursor.execute(sql, args) # 假如查询语句中有where条件，则需要传入参数(避免sql注入，在execute中传参) # 2.获取返回的查询结果 res = self.cursor.fetchall() for data in res: print(data) # return res # 自定义提交修改数据方法（添加、更新、删除） def execute(self, sql, args=None): # 提交sql语句 # sql = "insert into table(id, username) values(%s, %s)" try: self.cursor.execute(sql, args) # 此处一定会传入参数 except Exception as e: print(e) # 关闭游标、关闭连接 def close(self): self.cursor.close() self.client.close()
mysql_test.py：测试代码
from orm.orm_demo.mysql_setting import MySQL # 导入封装好的MySQL模块 if __name__ == '__main__': # 查询数据 def select_data(sql, args=None): mysql_obj = MySQL() # sql = 'select * from userinfo where id=%s' mysql_obj.select(sql, args) print(id(mysql_obj.Singleton())) # 插入数据 def execute_data(sql, args=None): mysql_obj = MySQL() mysql_obj.execute(sql, args) print(id(mysql_obj.Singleton())) # 调用查询数据：查询插入数据前的数据 select_data("select * from userinfo") """ 执行结果： {'id': 1, 'username': 'tom', 'password': '123456', 'gender': '三年四班', 'sex': 'male', 'phone_number': 13511111111} {'id': 2, 'username': 'jack', 'password': '456789', 'gender': '三年一班', 'sex': 'male', 'phone_number': 13622222222} {'id': 3, 'username': 'jerry', 'password': '147258', 'gender': '三年二班', 'sex': 'male', 'phone_number': 13733333333} 1990595350992 """ # 插入数据 execute_data("insert into userinfo(username, password, gender, sex, phone_number) values(%s, %s, %s, %s, %s)", ("owen", "321456", "三年三班", "female", "15244444444")) """ 执行结果： 1990595350992 """ # 调用查询数据：查询插入数据后的数据 select_data("select * from userinfo") """ 执行结果： {'id': 1, 'username': 'tom', 'password': '123456', 'gender': '三年四班', 'sex': 'male', 'phone_number': 13511111111} {'id': 2, 'username': 'jack', 'password': '456789', 'gender': '三年一班', 'sex': 'male', 'phone_number': 13622222222} {'id': 3, 'username': 'jerry', 'password': '147258', 'gender': '三年二班', 'sex': 'male', 'phone_number': 13733333333} {'id': 4, 'username': 'owen', 'password': '321456', 'gender': '三年三班', 'sex': 'female', 'phone_number': 15244444444} 1990595350992 """ # 更新数据 execute_data("update userinfo set username=%s where username=%s", ("lucy", "owen")) """ 执行结果： 1990595350992 """ # 调用查询数据：查询更新数据后的数据 select_data("select * from userinfo") """ 执行结果： {'id': 1, 'username': 'tom', 'password': '123456', 'gender': '三年四班', 'sex': 'male', 'phone_number': 13511111111} {'id': 2, 'username': 'jack', 'password': '456789', 'gender': '三年一班', 'sex': 'male', 'phone_number': 13622222222} {'id': 3, 'username': 'jerry', 'password': '147258', 'gender': '三年二班', 'sex': 'male', 'phone_number': 13733333333} {'id': 4, 'username': 'lucy', 'password': '321456', 'gender': '三年三班', 'sex': 'female', 'phone_number': 15244444444} 1990595350992 """ # 删除数据 execute_data("delete from userinfo where username=%s", "lucy") """ 执行结果： 1990595350992 """ # 调用查询数据：查询删除数据后的数据 select_data("select * from userinfo") """ 执行结果： {'id': 1, 'username': 'tom', 'password': '123456', 'gender': '三年四班', 'sex': 'male', 'phone_number': 13511111111} {'id': 2, 'username': 'jack', 'password': '456789', 'gender': '三年一班', 'sex': 'male', 'phone_number': 13622222222} {'id': 3, 'username': 'jerry', 'password': '147258', 'gender': '三年二班', 'sex': 'male', 'phone_number': 13733333333} 1990595350992 """
ORM完整版代码
1、封装数据库连接池 mysql_pool.py
安装第三方模块：
# pip3 install DBUtils
mysql_pool.py：
''' 数据库连接池 ''' import pymysql from dbutils.pooled_db import PooledDB POOL = PooledDB( creator=pymysql, # 使用链接数据库的模块 maxconnections=6, # 连接池允许的最大连接数，0和None表示不限制连接数 mincached=2, # 初始化时，链接池中至少创建的空闲的链接，0表示不创建 maxcached=5, # 链接池中最多闲置的链接，0和None不限制 maxshared=3, # 链接池中最多共享的链接数量，0和None表示全部共享。 # PS: 无用，因为pymysql和MySQLdb等模块的 threadsafety都为1，所有值无论设置为多少，_maxcached永远为0，所以永远是所有链接都共享。 blocking=True, # 连接池中如果没有可用连接后，是否阻塞等待。True，等待；False，不等待然后报错 maxusage=None, # 一个链接最多被重复使用的次数，None表示无限制 setsession=[], # 开始会话前执行的命令列表。如：["set datestyle to ...", "set time zone ..."] ping=0, # ping MySQL服务端，检查是否服务可用。# 如：0 = None = never, 1 = default = whenever it is requested, 2 = when a cursor is created, 4 = when a query is executed, 7 = always host='127.0.0.1', port=3306, user='root', password='123', database='db2', charset='utf8', autocommit=True )
2、封装MySQL类 mysql.py
mysql.py：
import pymysql from orm.orm_demo.mysql_pool import POOL # MySQL连接类 class MySQL: __instance = None @classmethod def Singleton(cls): if not cls.__instance: cls.__instance = cls() # 调用类产生对象，将对象赋值给__instance return cls.__instance # 实例化MySQL类时，获取数据库连接对象，获取游标对象 def __init__(self): self.client = POOL.connection() # 获取游标 self.cursor = self.client.cursor(pymysql.cursors.DictCursor) # 自定义查询数据方法 def select(self, sql, args=None): # 1.先提交查询sql语句 # sql = "select * from table" # sql = "select * from table where id=%s" self.cursor.execute(sql, args) # 假如查询语句中有where条件，则需要传入参数(避免sql注入，在execute中传参) # 2.获取返回的查询结果 res = self.cursor.fetchall() return res # 自定义提交修改数据方法（添加、更新、删除） def execute(self, sql, args=None): # 提交sql语句 # sql = "insert into table(id, username) values(%s, %s)" try: self.cursor.execute(sql, args) # 此处一定会传入参数 except Exception as e: print(e) # 关闭游标、关闭连接 def close(self): self.cursor.close() self.client.close()
3、ORM类 orm.py
ORM类中包括查（select_data）、增（insert_data）、改（update_data）的方法对数据进行操作
orm.py：
from orm.orm_demo.mysql import MySQL # 字段类型父类 class Field: 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 # varchar字段类型 class StringField(Field): def __init__(self, name, column_type="varchar(64)", primary_key=False, default=None): super().__init__(name, column_type, primary_key, default) # int字段类型 class IntegerField(Field): def __init__(self, name, column_type="int", primary_key=False, default=0): super().__init__(name, column_type, primary_key, default) # 自定义OrmMetaclass元类：控制类的创建过程 class OrmMetaclass(type): # __call__：先调用__new__，只要定义类就会触发__new__ def __new__(cls, class_name, class_bases, class_dict): # class_name：类名 class_bases：基类 class_dict：类的名称空间 # print(f"类名：{class_name}") # print(f"基类：{class_bases}") # print(f"类的名称空间：{class_dict}") # 过滤掉Models类，我们限制的是用户创建表的过程（可以说是用户创建表的规范），所以在此处过滤掉Models类，因为我们不限制Models类 if class_name == 'Models': return type.__new__(cls, class_name, class_bases, class_dict) # 第一个注意点：保证表必须要有表名。 获取table表名，若自定义则获取、没有则默认使用类名 # dict.get(key, class_name) key若有返回对应的值，若没有则返回默认值class_name就是默认值 table_name = class_dict.get("table_name", class_name) # 获取类名称空间的自定义表名table_name，若没有则默认以类名为表名 # print(table_name) # userinfo，若未定义表名，那么表名为类名，此处即User # 自定义一个主键值标识，后面做逻辑判断使用 # 主键值：主键名为 字段名 primary_key = None # 比如主键是id，那么id字段就是主键值的名字(primary_key = id) # 第三个注意点：定义一个字典用来存放 "字段名"与"字段对象" mappings = {} # print(class_dict) # 打印类中的名称空间 """ 执行结果： {'__module__': '__main__', '__qualname__': 'User', 'table_name': 'userinfo', 'id': <__main__.IntegerField object at 0x000000000287F1C8>, 'username': <__main__.StringField object at 0x000000000287F088>, 'password': <__main__.StringField object at 0x000000000287F388>} 上面class_dict的名称空间中，我们需要的仅仅是后面的id、username、password键值对属性，前两个不需要，我们需要将其剔除，后面将剔除后的结果重新放进mappings字典中 """ # 使用for循环将类中的名称空间字典 迭代依次取出 for k, v in class_dict.items(): # k为字段名，v为字段对象 # 将类中的名称空间无需的属性进行剔除筛选 # isinstance()：判断一个对象是否是另一个类的实例 if isinstance(v, Field): # id、username、password的value都是Field的实例 # print(k, v) # print(v.__dict__) # {'name': 'password', 'column_type': 'varchar(64)', 'primary_key': False, 'default': None} # 第三个注意点：将所有的 "字段名" 与 "字段对象" 添加到一个定义好的独立的字典(mappings)中 mappings[k] = v """ # 此处有一个坑： # class_attr.pop(k) # 这里当字典被迭代时，不能修改其属性 """ # 第二个注意点：保证一张表只能有一个唯一的主键 # 判断字段对象如果有主键 primary_key，则为primary_key变量赋值 if v.primary_key: # 如果建的表中有主键，执行下一步，若没有不执行下一步 # 若第二次执行到此处，primary_key有值，证明有主键，抛出异常 if primary_key: raise TypeError("一张表只能有一个主键！") primary_key = v.name # 将自定义的主键值标识修改为 字段对象中的名字(和字段名一样) # 给类的名称空间 添加table_name、primary_key、mappings属性 class_dict["table_name"] = table_name # 将表名添加到类的名称空间中 class_dict["primary_key"] = primary_key # 将主键添加到类的名称空间中 class_dict["mappings"] = mappings # 将存放 "字段名"与"字段对象"的字典添加到类的名称空间中 # print(class_dict) """ 执行结果： {'__module__': '__main__', '__qualname__': 'User', 'table_name': 'userinfo', 'id': <__main__.IntegerField object at 0x000000000237F1C8>, 'username': <__main__.StringField object at 0x000000000237F088>, 'password': <__main__.StringField object at 0x000000000237F388>, 'table_name': 'User', 'primary_key': 'id', 'mappings': {'id': <__main__.IntegerField object at 0x000000000237F1C8>, 'username': <__main__.StringField object at 0x000000000237F088>, 'password': <__main__.StringField object at 0x000000000237F388>}} 上面class_dict的名称空间中，有重复的"字段名"与"字段对象"，在此将class_dict中重复的"字段名"与"字段对象"过滤掉 """ # 过滤掉类名称空间中重复的字段属性 for key in mappings.keys(): # 根据mappings中的字段属性来过滤掉class_dict中的字段属性,因为mappings中的字段属性在class_dict中的字段属性都存在 class_dict.pop(key) # print(class_dict) """ 执行结果: {'__module__': '__main__', '__qualname__': 'User', 'table_name': 'userinfo', 'primary_key': 'id', 'mappings': {'id': <__main__.IntegerField object at 0x000000000283F1C8>, 'username': <__main__.StringField object at 0x000000000283F088>, 'password': <__main__.StringField object at 0x000000000283F388>}} 过滤完成！ """ # 若建立的表中所有字段都没有主键(规定每一张表中都需要有一个主键)，抛出异常 if not primary_key: raise TypeError("表中必须要有一个主键！") return type.__new__(cls, class_name, class_bases, class_dict) # 让Models类继承dict字典类，所有子类继承Models就等于继承了dict类 class Models(dict, metaclass=OrmMetaclass): # 在 "对象.属性" 获取属性时，若 "没有该属性" 时触发 __getattr__ def __getattr__(self, item): # print(item) return self.get(item) # 当 "对象.属性 = 属性值" ，"添加或修改属性" 时触发 __setattr__ def __setattr__(self, key, value): self[key] = value # 查询数据 @classmethod def select_data(cls, **kwargs): # name='张三' 转化为 {['name': '张三']} mysql_obj = MySQL() # 若kwargs为False代表没有查询条件 if not kwargs: # 1.查表中所有数据（select * from 表名） sql = f'select * from {cls.table_name}' # 表名可以通过传入的类来调用 res1 = mysql_obj.select(sql) return res1 else: # 获取字段名 column_name = list(kwargs.keys())[0] # 获取字段值 column_value = kwargs.get(column_name) # kwargs是一个字典 # 2.根据条件查询数据（select * from 表名 where 字段名=字段值） sql = f'select * from {cls.table_name} where {column_name}=%s' res2 = mysql_obj.select(sql, column_value) return [cls(**r) for r in res2] # 这里是把列表中的一个个字典[{}, {}...] 转化为列表中的一个个对象[obj, obj...] # 插入方法（insert into 表名(字段名1, 字段名2...) value(字段值1, 字段值2...)） def insert_data(self): mysql_obj = MySQL() # 1.获取表名 self.table_name # 2.字段名与字段值 self.mappings column_name = [] # 存放字段名的列表 [字段名1, 字段名2...] column_values = [] # 存放字段值的列表 [字段值1, 字段值2...] replace_list = [] # 设置一个替换替换值的列表 [?, ?...] for k, v in self.mappings.items(): # column_name.append(k) column_name.append(v.name) # 获取字段名追加到列表中, 是因为不知道传入的字段值有多少个 # 反射：根据字符串操作对象中的属性或方法 column_values.append(getattr(self, v.name, v.default)) # 获取字段值追加到列表中 replace_list.append('?') # 循环多少次，就说明有传入了多少个字段，列表内就有多少个 ? # sql = f'insert into {self.table_name}({",".join(column_name)}) values({",".join(replace_list)})' sql = 'insert into %s(%s) values(%s)' % (self.table_name, ",".join(column_name), ",".join(replace_list)) sql = sql.replace('?', '%s') # 将列表内的 ? 替换为 %s mysql_obj.execute(sql, column_values) # 更新方法（update 表名 set 字段名=字段值 where pk=主键值） def update_data(self): mysql_obj = MySQL() column_name = [] # 存放字段名的列表 [字段名1, 字段名2...] column_values = [] # 存放字段值的列表 [字段值1, 字段值2...] # 主键值 pk = None for k, v in self.mappings.items(): # 判断mappings中哪一个字段是主键 if v.primary_key: # 获取主键的值 pk = getattr(self, v.name) else: column_name.append(v.name + '=?') # 添加字段名 column_values.append(getattr(self, v.name)) # 添加字段值 # sql = f'update {self.table_name} set {",".join(column_name)} where {self.primary_key}={pk}' sql = 'update %s set %s where %s=%s' % (self.table_name, ",".join(column_name), self.primary_key, pk) sql = sql.replace('?', '%s') mysql_obj.execute(sql, column_values) # 假如User表中有 id、用户名和密码 三个字段 class User(Models): table_name = "user4" # 自定义一个表名，若此处不写，表名默认即为类名User # 字段类中的name属性必须与User表中类属性同名 id = IntegerField(name="id", primary_key=True) username = StringField(name="username") password = StringField(name="password") if __name__ == '__main__': # 演示查询数据 # # select_data()：括号中不传参指的是 查询所有数据 # res = User.select_data() # print(res) # # select_data(name='张三')：括号中的参数代表查询条件 # user_obj = User.select_data(id=1)[0] # print(user_obj) # print(user_obj.username) # 演示插入数据 # user_obj = User(username='孙七', password='789654') # user_obj.insert_data() # 演示更新数据 # # 先查看需要修改的数据 # user_obj = User.select_data(username='孙悟空')[0] # # print(user_obj.username) # 孙悟空，获取主键id为25的用户名 # # 修改对象中属性的值，即更新数据 # user_obj.username = '孙七' # # 然后调用update_data()将更新后的数据存到数据库中 # user_obj.update_data() pass
