Flask 框架 ORM & 增删改查_flask+vue+orm实现增改查删

Python 利用 pymysql 库连接 Mysql（直接连接）

mysql_2 数据库内部表格 xiaoke

Python 文件

import pymysql

# 连接 mysql 数据库
# 端口号默认为 3306 主机号默认为 127.0.0.1 或 localhost 用户名为 root 密码为 root 数据库选择 mysql_2 编码格式选择 utf-8
conn = pymysql.connect(host="127.0.0.1", port=3306, user="root", passwd="root", db="mysql_2", charset="utf8")

# 获取 cursor 游标对象 并把游标对象赋值给变量 cs
cs = conn.cursor()

# 通过游标对象 执行 sql 语句 execute 有返回值 且为受影响记录的行数
r = cs.execute("select * from xiaoke;")
print(r)
# output：6 条

# 获取单条数据
print(cs.fetchone())    # 第 1 条数据
print(cs.fetchone())    # 第 2 条数据
# output：(1, 'liujia', 19, 'woman', 1.67)
# output：(2, 'liuhan', 18, 'man', 1.7)

# 获取多条数据
print(cs.fetchmany())  # 第 3 条数据 以元组的类型返回
print(cs.fetchmany(2))  # 获取 size 条 第 4 , 5 条数据
# output：((3, 'liuzhi', 18, 'man', 1.78),)
# output：((4, 'susu', 19, 'man', 1.8), (5, 'lifan', 20, 'woman', 1.66))

# 获取剩下的全部数据
print(cs.fetchall())     # 6 以元组的类型返回
# output：((6, 'liaojuan', 22, 'woman', 1.56),)

# 全部获取完之后 获取为空值
print(cs.fetchone())     # 返回 None
# output:None


# 关闭游标对象
cs.close()

# 关闭连接对象
conn.close()
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

Python 利用 SQLAlchemy 库连接 Mysql

操作之前，先需要下载二个库，pymysql，SQLAlchemy，且均可以使用 pip install 命令安装

from sqlalchemy import create_engine
# 从 sqlalchemy 库中导入 create_engine 模块(创建引擎)

HOSTNAME = '127.0.0.1'  # 主机地址
DATABASE = 'mysql_2'  # 数据库名字
PORT = 3306  # 数据库端口
USERNAME = 'root'  # 用户名
PASSWORD = 'root'  # 密码

# 创建 url 固定模板
DB_URL = 'mysql+pymysql://{}:{}@{}:{}/{}'.format(USERNAME, PASSWORD, HOSTNAME, PORT, DATABASE)

# 创建引擎
engine = create_engine(DB_URL)  # 以 url 参数创建引擎, 并且赋值给变量 engine

# 创建连接
with engine.connect() as conn:
    res = conn.execute('select * from xiaoke')
    print(res.fetchone())  # 获取一条数据
    # output：(1, 'liujia', 19, 'woman', 1.67)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

具体操作步骤：首先从 sqlalchemy 中导入 create_engine，用这个函数来创建引擎，然后用 engine.connect() 来连接数据库

其中一个比较重要的一点是，通过 create_engine 函数的时候，需要传递一个满足某种格式的字符串，对这个字符串的格式来进行解释

# 具体格式：dialect+driver://username:password@host:port/database?charset=utf8

'mysql+pymysql://{}:{}@{}:{}/{}'.format(USERNAME, PASSWORD, HOSTNAME, PORT, DATABASE)
1
2
3

参数介绍：dialect 是数据库的实现，比如 MySQL、PostgreSQL、SQLite，并且转换成小写，driver 是 Python 对应的驱动，如果不指定，会选择默认的驱动，比如 MySQL 的默认驱动是 MySQLdb，username 是连接数据库的用户名，password 是连接数据库的密码，host 是连接数据库的主机名，port是数据库监听的端口号，database 是连接数据库的名字

SQLAlchemy 执行原生 SQL 语句

先创建一个 content.py 文件，在里面书写配置项 url

HOSTNAME = '127.0.0.1'  # 主机地址
DATABASE = 'mysql_2'  # 数据库名字
PORT = 3306  # 数据库端口
USERNAME = 'root'  # 用户名
PASSWORD = 'root'  # 密码

# 创建 url 固定模板
DB_URL = 'mysql+pymysql://{}:{}@{}:{}/{}'.format(USERNAME, PASSWORD, HOSTNAME, PORT, DATABASE)
1
2
3
4
5
6
7
8

然后在主 python 文件中，导入 content 文件内部的 DB_URL

from sqlalchemy import create_engine
# 从 sqlalchemy 库中导入 create_engine 模块(创建引擎)
from content import DB_URL
# 从 content.py 文件中导入 url 配置项

# 创建引擎
engine = create_engine(DB_URL, echo=True)  # 以 url 参数创建引擎, 并且赋值给变量 engine

# 创建连接 with 语句连接数据库, 如果发生异常会被捕获
with engine.connect() as conn:
    # 先删除 users 表
    conn.execute('drop table if exists users')
    # 创建一个 users 表，有自增长的 id 和 name
    conn.execute('create table users(id int primary key auto_increment,name varchar(25))')
    # 插入两条数据到表中
    conn.execute('insert into users(name) values("xiao su")')
    conn.execute('insert into users(name) values("xiao ke")')
    # 执行查询操作
    results = conn.execute('select * from users')
    # 从查找的结果中遍历 以下二种效果相同
    # print(results.fetchall())
    for result in results:
        print(result)
        # output：(1, 'xiao su')
		# output：(2, 'xiao ke')
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

SQLAlchemy（ORM）操作数据库

要使用 ORM 来操作数据库，首先需要创建一个类来与对应的表进行映射，现在以 students 表来做为例子，它有自增长的 id 及 name 、gender 这些字段

from sqlalchemy import create_engine  # 用于创建引擎
from sqlalchemy import Column, Integer, String  # 用于创建表格内数据
from sqlalchemy.ext.declarative import declarative_base  # 用于生成基类
from content import DB_URL  # 用于创建引擎

# 创建引擎
engine = create_engine(DB_URL)

# 所有的类都要继承自 declarative_base 这个函数生成的基类
Base = declarative_base(engine)


# 定义类相当于定义表格
class Students(Base):
    # 给表格取名字, 若缺失此参数, 那么表格的名字将以类的名字代替
    __tablename__ = 'students'
    # 创建字段 id, 数据类型约束 int, 主键, 自增长
    id = Column(Integer, primary_key=True, autoincrement=True)
    # 创建字段 name, 数据类型约束 string, 非空
    name = Column(String(50), nullable=False)
    # 创建字段 gender, 数据约束类型 int, 默认项为 1, 注释项为 '1 为男, 2 为女'
    gender = Column(Integer, default=1, comment='1 为男, 2 为女')


# 模型映射到数据库中
Base.metadata.create_all()
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

代码执行后，就会在 mysql_2 数据库中看见表格 students 被创建

在创建完数据表，并且做完和数据库的映射后，接下来让我们添加数据进去，也就是在实例化对象的时候传递参数进去

student_SD = Students(name='xiao ke', gender=1)
print(student_SD.name)  # 打印 name
print(student_SD.gender)  # 打印 gender
print(student_SD.id)  # 打印 id
# output：xiao ke
# output：1
# output：None
1
2
3
4
5
6
7

可以看到，name 和 gender 都能正常的打印，唯独 id 为 None，这是因为 id 是一个自增长的主键，还未插入到数据库中，id 是不存在的

接下来把创建的数据插入到数据库中，和数据库打交道的，是一个叫做 Session 的对象

from sqlalchemy.orm import sessionmaker

# 绑定事务
Session = sessionmaker(bind=engine)
session = Session()
session.add(student_SD)

# 提交事务
session.commit()
1
2
3
4
5
6
7
8
9

之后就能进行查询操作

print(student_SD.name)  # 打印 name
print(student_SD.gender)  # 打印 gender
print(student_SD.id)  # 打印 id
# output：xiao ke
# output：1
# output：1
1
2
3
4
5
6

完整 Python 代码

from sqlalchemy import create_engine  # 用于创建引擎
from sqlalchemy import Column, Integer, String  # 用于创建表格内数据
from sqlalchemy.ext.declarative import declarative_base  # 用于生成基类
from content import DB_URL  # 用于创建引擎
from sqlalchemy.orm import sessionmaker  # 用于提交事务


# 创建引擎
engine = create_engine(DB_URL)

# 所有的类都要继承自 declarative_base 这个函数生成的基类
Base = declarative_base(engine)


# 定义类相当于定义表格
class Students(Base):
    # 给表格取名字, 若缺失此参数, 那么表格的名字将以类的名字代替
    __tablename__ = 'students'
    # 创建字段 id, 数据类型约束 int, 主键, 自增长
    id = Column(Integer, primary_key=True, autoincrement=True)
    # 创建字段 name, 数据类型约束 string, 非空
    name = Column(String(50), nullable=False)
    # 创建字段 gender, 数据约束类型 int, 默认项为 1, 注释项为 '1 为男, 2 为女'
    gender = Column(Integer, default=1, comment='1 为男, 2 为女')


# 模型映射到数据库中
Base.metadata.create_all()
student_SD = Students(name='xiao ke', gender=1)

# 绑定事务
Session = sessionmaker(bind=engine)
session = Session()
session.add(student_SD)

# 提交事务
session.commit()

# 查询操作
print(student_SD.name)  # 打印 name
print(student_SD.gender)  # 打印 gender
print(student_SD.id)  # 打印 id
# output：xiao ke
# output：1
# output：1
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

如果想让查询到的数据格式好看一点，那么有一个魔法方法 ，在 print(实例化对象) 的时候自动被调用

def __repr__(self):
        return "<User(id='%s', name='%s',gender='%s')>" % (self.id,self.name,self.gender)
1
2

完整 Python 代码

from sqlalchemy import create_engine  # 用于创建引擎
from sqlalchemy import Column, Integer, String  # 用于创建表格内数据
from sqlalchemy.ext.declarative import declarative_base  # 用于生成基类
from content import DB_URL  # 用于创建引擎
from sqlalchemy.orm import sessionmaker  # 用于提交事务


# 创建引擎
engine = create_engine(DB_URL)

# 所有的类都要继承自 declarative_base 这个函数生成的基类
Base = declarative_base(engine)


# 定义类相当于定义表格
class Students(Base):
    # 给表格取名字, 若缺失此参数, 那么表格的名字将以类的名字代替
    __tablename__ = 'students'
    # 创建字段 id, 数据类型约束 int, 主键, 自增长
    id = Column(Integer, primary_key=True, autoincrement=True)
    # 创建字段 name, 数据类型约束 string, 非空
    name = Column(String(50), nullable=False)
    # 创建字段 gender, 数据约束类型 int, 默认项为 1, 注释项为 '1 为男, 2 为女'
    gender = Column(Integer, default=1, comment='1 为男, 2 为女')

    def __repr__(self):
        return "<User(id='%s', name='%s',gender='%s')>" % (self.id,self.name,self.gender)


# 模型映射到数据库中
Base.metadata.create_all()
student_SD = Students(name='xiao ke', gender=1)

# 绑定事务
Session = sessionmaker(bind=engine)
session = Session()

# 上传更改到事务中
session.add(student_SD)

# 提交事务
session.commit()

# 魔法方法打印数据
print(student_SD)
# output：<User(id='1', name='xiao ke',gender='1')>
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

实现数据库的增删改查

from sqlalchemy import create_engine  # 用于创建引擎
from sqlalchemy import Column, Integer, String  # 用于创建表格内数据
from sqlalchemy.ext.declarative import declarative_base  # 用于生成基类
from content import DB_URL  # 用于创建引擎
from sqlalchemy.orm import sessionmaker  # 用于提交事务


# 创建引擎
engine = create_engine(DB_URL)

# 所有的类都要继承自 declarative_base 这个函数生成的基类
Base = declarative_base(engine)


class Article(Base):
    # 给表格取名字, 若缺失此参数, 那么表格的名字将以类的名字代替
    __tablename__ = 'art'
    # 创建字段 id, 数据类型约束 int, 主键, 自增长
    id = Column(Integer, primary_key=True, autoincrement=True)
    # 创建字段 name, 数据类型约束 string, 非空
    name = Column(String(50), nullable=False)
    # 创建字段 content, 数据约束类型 string
    content = Column(String(50))
    # 创建字段 author, 数据约束类型 string
    author = Column(String(50))

    def __str__(self):
        return 'Article(name:{}, content:{}, author:{})'.format(self.name, self.content, self.author)


# 绑定事务
Session = sessionmaker(bind=engine)
session = Session()


# 添加数据 以及创建表格 art
def add_data():
    # 模型映射到数据库中
    Base.metadata.create_all()
    article = Article(name='python', content='人生苦短, 我用 python', author='龟叔')
    # 上传更改到事务中
    session.add(article)
    # 提交事务
    session.commit()


# 查询数据
def search_data():
    # 查询第一条数据
    # data = session.query(Article).first()

    # 查询所有数据
    data = session.query(Article).all()

    # filter 按照条件去查询
    # data = session.query(Article).filter(Article.name == 'python').all()

    # 通过字段名查询
    # data = session.query(Article).filter_by(name='python').all()

    # 指定查询第几条数据
    # get(参数)不传递参数会直接报错, 传递的参数不存在则直接返回 None
    # data = session.query(Article).get(2)

    # 魔法方法查询数据
    print(data[1])
    # print(data[2])
    # print(data[3])


# 更改数据
def update_data():
    data = session.query(Article).first()
    data.name = 'php'
    # 具体来说是修改第一条数据的 name
    session.commit()


# 删除数据
def delete_data():
    data = session.query(Article).first()
    session.delete(data)
    # 回滚一定得在提交之前回滚, 否则回滚失败
    # 回滚就是不让 commit(), 那么删除之前数据库是怎么样还是怎么样, 也就是删除失败
    # session.rollback()
    session.commit()


if __name__ == '__main__':
    # 增添数据：add_data() 
    # 查询数据：search_data()
    # 更改数据：update_data()
    delete_data()  # 删除数据
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