ORM简介

ORM 全称 Object Relational Mapping, 叫对象关系映射。简单的说，ORM 将数据库中的表与面向对象语言中的类建立了一种对应关系。这样，我们要操作数据库，数据库中的表或者表中的一条记录就可以直接通过操作类或者类实例来完成。

对于数据的操作增、删、查、改（主要是查）得到的只是一个字符串没办法显示在前端界面。但用面向对象语言与类建立映射（mapping）后将得到的字符存储在内存中，在声明周期类显示在界面上。

我们知道操作数据库都是用SQL语句执行的：

建数据库

create database  person;

建表

create table man(
   id int primary key,
   name varchar(16) not null,
   age int,
   sex  varchar(2)
);

插入数据

insert into man(id,name,age,sex)
values (1,'张三',22,'男');

更新数据

update man set name='老王';

删除数据

delete from man where id = 1;

查询数据

#查询较复杂
select * from person where name like '%ang';

对于用户来说，并不需要了解数据库，将ORM模型后只需要通过输入参数就能操作数据库，对sql语句进行了封装，那么只需要实例化类并调用类方法就可以操作数据库了。

使用面向对象语言自定义ORM框架

Object-Relational Mapping: 对象-关系映射。把数据转换成python对象
数据库中的表—> python对象
表中的列是列的属性
表中的每一行对应类的实例
字典中的key对应实例，value对应值
对增删查改封装实现面向对象化的操作

实现代码：

简单案例封装sql

sql='update {} set {}=\'{}\' where {}=\'{}\''.format('tt_user','username','zhangyu','username','suyanzeng')
print(sql)

结果：
update tt_user set username='zhangyu' where username='suyanzeng'

案例封装的sql是可以直接在数据库中运行的，我们需要传递有效的参数。
2. 类封装sql语句

class User:
    #初始化为类动态设置属性
    def __init__(self,**kwargs):
        for key,value in kwargs.items():
            self.__setattr__(key,value)
    def makesql(self,**kwargs):
        dict=self.__dict__
        sql = 'insert into table({}) values{}'.format(','.join(list(dict.keys())),tuple(list(dict.values())))   #数据结构的注意这些转换关系
        return sql


user=User(su=1,nm='nihao',ss='bushi')
print(user.makesql())

结果：
insert into table(su,nm,ss) values(1, 'nihao', 'bushi')

可以看到用类封装后实例化类并传入关键参数就构造了sql语句，有了sql语句就可以操作数据库了（表名没生成参数，添加一个参数即可）
3. 类对象实现数据库操作pymsql实现

import pymysql
from pymysql.cursors import DictCursor

# 定义类的方法重复调用次数
import sys
sys.setrecursionlimit(10000000)


# 对连接数据库操作封装

class ConnectMysql:
    def __init__(self):
        conn = pymysql.connect(host='localhost', port=3306, user='用户', password='密码',autocommit=True)
        conn.cursor().execute('use termtask')
        self.cursor = conn.cursor(DictCursor)     #DictCursor以字典获取数据库中的表

    # 封装查询操作
    def select(self, sql:str):
        self.cursor.execute(sql)
        result = self.cursor.fetchall()
        return result

    # 封装修改等更新操作
    def update(self,sql:str):
        if self.cursor.execute(sql):
            return "UPDATE FINISHED"
        else:
            return "UPDATE FAIL"

    # 封装新增(传入的一列封装为字典类型)
    def insert(self,sql:str):
        if self.cursor.execute(sql):
            return "INSERT FINISHED"
        else:
            return "INSERT FAIL"

    # 关闭封装
    def close(self):
        self.cursor.close()
        self.close()
        return 0


# 将数据库的表封装成对象并实现操作
class Users:
    table_name='tt_user'
    #封装查询sql语句
    def quary(self,userid:str):
        sql='select {} from {}'.format("userid",self.table_name)
        print(sql)
        result=ConnectMysql().select(sql)
        return result

    #分装插入sql语句
    def post(self,**kwargs):  #**kwargs为限定参数为字典类型
        for key,value in kwargs.items():
            self.__setattr__(key,value)   #为类动态设置属性，不必输入完全
        sql = 'insert into {}({}) values{}'.format(self.table_name, ','.join(list(self.__dict__.keys())),tuple(list(self.__dict__.values())))
        print(sql)
        '''
        数据传入方式
        user=Users()
        user.post(userid='2',username='chuhailong')
        数据结构，返回self.__dict__
        {'userid': '2', 'username': 'chuhailong'}
        '''
        result=ConnectMysql().insert(sql)
        return result

    #封装更新的sql语句
    def chenge(self,*args):
        pass







# 对于其他表直接继承即可
''' 调用父类方法
self.__class__.__getatrribute__(self,"表名（User类的table_name）")
super调用父类
'''


if __name__ == '__main__':
    #查询实例对象
    '''
    user=Users()
    result=user.select('userid')
    print(result)
    
    '''
    user=Users()
    result=user.post(username='suyanzeng',password='123456',role='user')
    print(result)

控制栏显示执行成功。

数据中成功插入数据。

上面用户名和密码写正确，连接数据库要用pymsyql用pip指令安装：pip install pymysql 下面的sqlalchemy一样。

SQLAlchemy框架实现ORM模型

# SQLAlchemy框架是python语言开发的ORM框架，使-----
# ---用该框架不需要自己封装sql语句，用其内置函数实现数据库操作
# sqlalchemy 作为python 主流的ORM 框架,
# ORM 全称 Object Relational Mapping, 叫对象关系映射。简单的说，ORM 将数据库中的表与面向对象语言中的类建立了一种对应关系。这样，我们要操作数据库，数据库中的表或者表中的一条记录就可以直接通过操作类或者类实例来完成

# 使用sqlalchemy操作数据库
from sqlalchemy import create_engine, MetaData, Table
from sqlalchemy.engine import row
from sqlalchemy.orm import declarative_base, sessionmaker, session, scoped_session

# 建立数据库连接
engine = create_engine('mysql+pymysql://root:baby5429@localhost/termtask')  # termtask数据库名称 ，通过create_engine建立连接返回实例
# 定义映射数据库表和python类的基类
Base = declarative_base()  # Declarative类实现数据库表映射到pyhton内置对象，实例化创建基类
# 创建数据库对话
Session = sessionmaker(bind=engine)
# 自定义的工厂类可以拿来我们构造新的Session
FactorySession = scoped_session(Session)

md = MetaData(bind=engine)

# 定义模型类即数据表转换的python类的过程(要继承基类才能实现隐射)也就是建立mapping过程
'''
class User(Base):
    __tablename__="tt_user"    #数据库中的表名
                                #也可以在这里定义表结构用metadata类创建数据库（但没必要）

'''


class User(Base):
    __table__ = Table('tt_user', md, autoload=True)  # MetaData类实现表到类的映射


if __name__ == '__main__':
    result = FactorySession.query(User.userid,User.username).filter(User.userid == 3).all()
    print(result)

对应数据库表中的id=3

SQLAlchemy实现增删查改

# SQLAlchemy框架是python语言开发的ORM框架，使-----
# ---用该框架不需要自己封装sql语句，用其内置函数实现数据库操作
# sqlalchemy 作为python 主流的ORM 框架,
# ORM 全称 Object Relational Mapping, 叫对象关系映射。简单的说，ORM 将数据库中的表与面向对象语言中的类建立了一种对应关系。这样，我们要操作数据库，数据库中的表或者表中的一条记录就可以直接通过操作类或者类实例来完成

# 使用sqlalchemy操作数据库
from sqlalchemy import create_engine, MetaData, Table
from sqlalchemy.engine import row
from sqlalchemy.orm import declarative_base, sessionmaker, session, scoped_session

# 建立数据库连接
engine = create_engine('mysql+pymysql://root:baby5429@localhost/termtask')  # termtask数据库名称 ，通过create_engine建立连接返回实例
# 定义映射数据库表和python类的基类
Base = declarative_base()  # Declarative类实现数据库表映射到pyhton内置对象，实例化创建基类
# 创建数据库对话
Session = sessionmaker(bind=engine)
# 自定义的工厂类可以拿来我们构造新的Session
FactorySession = scoped_session(Session)

md = MetaData(bind=engine)

# 定义模型类即数据表转换的python类的过程(要继承基类才能实现隐射)也就是建立mapping过程
'''
class User(Base):
    __tablename__="tt_user"    #数据库中的表名
                                #也可以在这里定义表结构用metadata类创建数据库（但没必要）

'''


class User(Base):
    __table__ = Table('tt_user', md, autoload=True)  # MetaData类实现表到类的映射


if __name__ == '__main__':

    #查询
    result = FactorySession.query(User.userid,User.username).filter(User.userid == 3).all()
    print(result)
    # 查询结果   [(3, 'zhangyu')] 列表中间是字典

    #新增 实例化映射类
    user1=User(username='jingchengxin',password='123456',role='user')
    FactorySession.add(user1)
    FactorySession.commit()   # 修改操作要提交
    print("INSERT FINESHED")    


    #修改需要先查询出来
    result2 = FactorySession.query(User).filter_by(username='jingchengxin').first()
    result2.username='unkown'
    FactorySession.commit()
    print("UPDATE FINESHED")

    '''
    #删除需要先查询出来
    result1=FactorySession.query(User).filter_by(username='unkown').delete()
    FactorySession.commit()
    print('DELETED')
    '''

初始数据库

执行代码后结果：

数据库（没有执行删除操作）：