orm简单配置：
''' ORM: 对象关系映射 表 ---> 类 一条条的记录 ---> 对象 一条条记录下的字段 ---> 对象.属性 字段类型: varchar: 字段名 字段类型 是否为主键 默认值 从底层的字段类型开始编写 然后创建类对象 ''' from mysql_control 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 # 这里我们只使用int和varchar类型的字段类型，并继承Field这个父类 class IntegerField(Field): # 初始化（生成对象的时候）设置一些默认值 def __init__(self, name, column_type='int', primary_key=False, default=0): super().__init__(name, column_type, primary_key, default) class StringField(Field): def __init__(self, name, column_type='varchar(255)', primary_key=False, default=None): super().__init__(name, column_type, primary_key, default) # 创建类（表）对象 # 创建类（表）对象时候需要对其进行一定的限制--->元类可以控制创建的类 # 定义自己的元类，名字随便（见名知意即可） class OrmMetaClass(type): # 创建类的时候需要指定三个参数 分别为 类名、类的父类、类的名称空间 # 创建一个类一定触发 __new__ 方法 所以对此方法进行修改 def __new__(cls, class_name, class_base, class_attr): # 因为我们是在创建具体一个类的时候进行限定，所以对这些类的抽象父类不进行限定 # 过滤出抽象父类 if class_name == 'Models': # 这里面的Models是自己创建的抽象父类名称，可以随意同步更改 return type.__new__(cls, class_name, class_base, class_attr) # 如果是抽象父类，则不进行修改直接返回 # 不是抽象父类 # 需要对表（orm 将类映射为表）的 表名、主键、字段 进行限制 # 1.如果这个表没有定义表名，那么就把类名当作表名 table_name = class_attr.get('table_name', class_name) # 使用get获取字典的值，没有值则返回默认值--->类名 # 2.限定表只有一个主键 primary_key = None # 先将主键设为空 mappings = {} # 用来存放所以的表字段（仅仅存放表字段）,方便取值 for key, value in class_attr.items(): # 遍历类名称空间中的所有items ---> 键值对的形式 # 将字段类的对象添加到 mappings 中 # 判断 value 是否为字段类的对象 if isinstance(value, Field): mappings[key] = value # 仅仅将表的字段名加进去，其他的类属性不要 # 判断这个表对象的主键属性是否为True if value.primary_key: # 判断主键是否已经设定（是否已经有一个主键了）---> 设定过后全局名称空间中的 primary_key 就会被修改，不在为None if primary_key: # 不为 None 则报下面的错 raise TypeError('only one primary_key should be set in one table!') # 报错信息：一张表只能设置一个主键 # 没有设定则获取主键，同时全局变量 primary_key 也被修改了 primary_key = value.name else: pass else: pass # 删除名称空间中与 mappings 重复的属性，节省资源（额外操作，可有可无） for key in mappings.keys(): # mappings是个字典，使用key()方法可以取出所有的 key class_attr.pop(key) # 判断是否有主键 if not primary_key: raise TypeError('must have one primary_key!') # 对名称空间中的值进行修改（重新赋值） class_attr['table_name'] = table_name class_attr['primary_key'] = primary_key class_attr['mappings'] = mappings return type.__new__(cls, class_name, class_base, class_attr) # 元类创建好了，但是所有的表对象都需要写 init 方法，所以我们可以将 init 方法抽象为一个父类 # 由于我们不知道子类中有多少属性，所以可以使用 **kwargs 来接收任意关键字参数--->继承字典类型 class Models(dict, metaclass=OrmMetaClass): # 继承字典，获取字典的方法；并指定元类，限制类的生成 def __init__(self, **kwargs): # **能够将字典中的键值对打散 super().__init__(**kwargs) # 掩盖了父类的初始化方法，就需要重新调用一下 # 由于字典类没有 点属性法 查看值以及修改值，所以我们需要自己设定 # 对象.属性没有时候会触发 __getattr__ 方法 def __getattr__(self, item): return self.get(item, '没有这个key') # 自定义返回值，且可以设定返回的默认值 # 对象.属性 = 属性值 的时候触发 __setattr__ 方法 def __setattr__(self, key, value): self[key] = value # 功能函数内进行复制操作，达到点属性赋值一样的效果 # 每个类对象（表）都应具备查询数据的功能，且应为--->非绑定方法 @classmethod # 非绑定方法的关键词 def select(cls, **kwargs): # 查看的时候一般都是关键字参数条件 # 先获取数据库连接对象 ms = Mysql() # 判断**kwargs，若没有则代表没有查询条件，默认为查询所有 if not kwargs: # sql语句格式本应为 select * from 表名，我们先用占位符 %s 占位 sql = 'select * from %s' % cls.table_name # 类对象中有类名这个属性--->也就是表名 # 接收查询的结果，且返回的结果为大列表字典类型 res = ms.my_select(sql) # 因为没有条件，所以不需要进行sql语句的拼接 # 若有 kwargs，则代表查询时候有限制条件 else: # sql语句格式本应为 select * from 表名 where 条件（kwargs的字段名=kwargs的值） # 分别获取sql语句所需要的所有关键信息，并生成sql语句 # 1.获取条件的key,也就是字段名 key = list(kwargs.keys())[0] # 条件为字典，用keys()方法取值；并将结果变成有序的列表形式，依据索引取值 # 2.获取条件的value，也就是字段的值 value = kwargs.get(key) # 字典的取值方法 # 3.获取表名，也就是 cls.table_name # 生成sql语句 sql = 'select * from %s where %s = ?' % (cls.table_name, key) # 为了防止sql注入问题，关键的值不要手动拼接； # 所以先用？替换（不进行占位），然后再替换回来，再用cursor方法拼接 sql = sql.replace('?', '%s') # 替换的过程也是占位的过程 # 接收 连接对象提交sql语句执行后返回的结果；结果为 大列表套字典 类型 res = ms.my_select(sql, value) # 防止sql注入问题，能自动识别sql语句的 %s # 判断返回的结果有无，并将结果以对象的形式返回 if res: # 使用列表生成式，得到的是列表套对象 return [cls(**result) for result in res] # 将结果遍历，得到一个个字典；将字典变成对象，然后用一个大列表包裹 else: pass # 插入数据 def insert(self): # 先获取数据库连接对象 ms = Mysql() # sql语句格式本应为 insert into 表名(字段名) values(各个字段对应的值); 我们先用占位符 %s 占位 # sql = 'insert into %s(%s) values(%s)' % (...) # 表名---> cls.table_name # 字段名以及字段的值不知道 # 1.定义存放字段名、字段值以及用于存放对应字段的？号的空列表 fields = [] # 存放字段名 values = [] # 存放字段的值 args = [] # 存放对应字段的？号 # 2.获取字段名，字段值；（过滤掉主键，因为插入数据时候不需要给主键传值） for k, v in self.mappings.items(): # mappings在定义元类的时候就已经限制把表中的字段名与之存放其中了 # 过滤主键 if not v.primary_key: # 判断值这个对象的主键属性是否为 True，不是则继续 fields.append(v.name) # 将字段的名添加进去 values.append(getattr(self, v.name, v.default)) # 将字段的值添加进去，没有值则添加默认值 # v.name 是字段名 getattr(v.name) 是字段的值---> 映射 args.append('?') # 遍历循环，有多少个值就有多少个？号 # 生成sql语句 # fields与args是列表[x,x,x]，但是我们的sql语句对应的形式是(x,x,x),所以进行，号拼接成目的格式 sql = 'insert into %s(%s) values(%s)' % (self.table_name, ','.join(fields), ','.join(args)) # 拼接好的sql语句中目前剩下？号这个符号，需要再次替换，以便cursor识别；同时防止sql注入问题 sql = sql.replace('?', '%s') # 使用连接对象进行sql语句的提交(插入数据没有返回值) ms.my_execute(sql, values) # 提交sql语句，并将values中的值一一对应到替换后的sql语句中 # 更新数据 def sql_update(self): # 先获取数据库连接对象 ms = Mysql() # sql语句格式本应为 update 表名 set 字段名=字段值 where 字段名=字段值; 我们先用占位符 %s 占位（这里我们默认主键当作条件的字段名） # sql = 'update %s set %s where %s=%s' % (...) # 表名---> cls.table_name # 主键名---> cls.primary_key # 字段名、字段的值以及主键的值不知道 # 1.定义存放字段名、字段值的空列表，并获取主键 fields = [] # 存放字段名 values = [] # 存放字段的值 primary_key = None # 先将主键的值设置为None,获取过后对其进行修改 # 2.获取字段名，字段值，主键；（因为更新数据时候需要用主键定位） for k, v in self.mappings.items(): # mappings在定义元类的时候就已经限制把表中的字段名与之存放其中了 # 获取主键的值 if v.primary_key: # 判断值里面主键这个属性是否为True，是就讲主键的值获取出来 primary_key = getattr(self, v.name, v.default) # 获取主键的值，没有值则添加默认值 # 获取其他字段名与值 else: # 值里面的主键属性为False，表明不是主键，也就是其他的字段 fields.append(v.name + '=?') # 对字段名进行一个拼接，因为我们要设定的值是一个键值对的形式，而我们只知道字段名 values.append(getattr(self, v.name, v.default)) # 将字段的值添加进去，没有值则添加默认值 # 生成sql语句 sql = 'update %s set %s where %s = %s' % (self.table_name, ','.join(fields), self.primary_key, primary_key) # 生成后的sql语句第二个%s对应的格式为 字段名= ？ 因此再对？号进行替换，以便cursor识别，防止sql注入问题 sql = sql.replace('?', '%s') # 使用连接对象进行sql语句的提交（更新数据没有返回值） ms.my_execute(sql, values) # # 提交sql语句，并将values中的值一一对应到替换 # 至此每个实例化产生的对象都具备了以上的方法（包括点属性取值，赋值以及查询、插入、修改数据的方法） # 创建具体的对象，并继承Models，使其具备Models中的各个方法 class User(Models): # 在这里不定义表名就默认表名为类名 # table_name = 'user_info' # 每个表（类）都应具备两种数据类型---> int类型和 varchar类型 两种类型都是只有name没有默认值，所以至少传入一个name参数才能实例化出一个属性对象 id = IntegerField(name='id', primary_key=True) # 一般每个表都有个id字段，且一般将id设置为主键字段 # 注意：字段名=属性名 保持一致 # 此外，还需要一个varchar类型，我们这里以name作为另一个类属性 name = StringField(name='name') # 测试 if __name__ == '__main__': d3 = User(id=1, name='tank') print(d3) # 取值 # print(d3.get('name')) # print(d3.name) # print(d3['name']) # 赋值（修改） d3.name = 'zhao' print(d3.name)
mysql_control：
import pymysql class Mysql: # 设置单例模式 _instance = None def __new__(cls, *args, **kwargs): # 如果没有_instance就调用Mysql的父类Object中__nem__方法实例化对象，并赋值给_instance if not cls._instance: cls._instance = object.__new__(cls, *args, **kwargs) return cls._instance def __init__(self): # 建立连接 self.conn = pymysql.connect( host='127.0.0.1', port=3306, user='user', passwd='123456', db='youku', charset='utf8', autocommit=True ) # 生成游标 self.cursor = self.conn.cursor(pymysql.cursors.DictCursor) # 关闭游标、连接的方法 def close_db(self): self.cursor.close() self.conn.close() # 查看 def my_select(self, sql, args=None): # 提交查看的sql语句 self.cursor.execute(sql, args) # 接收查看结果,并返回 res = self.cursor.fetchall() return res # 返回的是字典类型数据 # 提交---> 包括插入数据，修改数据 def my_execute(self, sql, args): # 不一定能够提交成功，所以使用异常捕获 try: self.cursor.execute(sql, args) except Exception as e: print(e)