本文的主要内容：flask视图&路由、虚拟环境安装、路由各种定义、状态保持、cookie、session、模板基本使用、过滤器&自定义过滤器、模板代码复用：宏、继承/包含、模板中特有变量和函数、Flask-WTF 表单、CSRF、数据库操作、ORM、Flask-SQLAlchemy、增删改查操作、案例、蓝图、单元测试

全套笔记和代码自取地址： 请移步这里

感兴趣的小伙伴可以自取哦，欢迎大家点赞转发~

共 4 章，42 子模块

数据库

• Flask-SQLAlchemy 安装及连接

• 使用数据库

• 综合案例演练

• 数据库迁移

学习目标

• 能够理解 ORM 工作原理以及其优缺点

• 能够写出在 Flask 中连接 MySQL 的配置项格式（IP，端口，数据库）

• 能够使用 SQLAlchemy 定义出关系为一对多模型类

• 能够使用 SQLAlchemy 的相关函数创建表及删除表

• 能够写出的指定模型数据对数据库的增删改代码

• 能够写出模型数据按照条件查询的功能逻辑

• 能够写出模型数据按照指定数量分页的功能逻辑

• 能够写出模型数据按照指定条件排序的功能逻辑

• 能够按照课件步骤实现综合图书管理的相关案例

• 能够使用 Flask-Migrate 扩展对数据库进行迁移

多对多演练

在项目开发过程中，会遇到很多数据之间多对多关系的情况，比如：

• 学生网上选课(学生和本文)

• 老师与其授课的班级(老师和班级)

• 用户与其收藏的新闻(用户和新闻)

• 等等...

所以在开发过程中需要使用 ORM 模型将表与表的多对多关联关系使用代码描述出来。多对多关系描述有一个唯一的点就是：需要添加一张单独的表去记录两张表之间的对应关系

场景示例

需求分析

• 学生可以网上选课，学生有多个，本文也有多个

• 学生有：张三、李四、王五

• 本文有：物理、化学、生物

• 选修关系有：

  • 张三选修了化学和生物

  • 李四选修了化学

  • 王五选修了物理、化学和生物

• 需求：

  1. 查询某个学生选修了哪些本文

  2. 查询某个本文都有哪些学生选择

思路分析

• 可以通过分析得出

  • 用一张表来保存所有的学生数据

  • 用一张表来保存所有的本文数据

• 具体表及测试数据可以如下：

学生表(Student)

选修课表(Course)

数据关联关系表(Student_Course)

结果

• 查询某个学生选修了哪些本文，例如：查询王五选修了哪些本文

  • 取出王五的 id 去 Student_Course 表中查询 student.id 值为 3 的所有数据

  • 查询出来有3条数据，然后将这3条数据里面的 course.id 取值并查询 Course 表即可获得结果

• 查询某个本文都有哪些学生选择，例如：查询生物本文都有哪些学生选修

  • 取出生物本文的 id 去 Student_Course 表中查询 course.id 值为 3 的所有数据

  • 查询出来有2条数据，然后将这2条数据里面的 student.id 取值并查询 Student 表即可获得结果

代码演练

• 定义模型及表

tb_student_course = db.Table('tb_student_course',
                             db.Column('student_id', db.Integer, db.ForeignKey('students.id')),
                             db.Column('course_id', db.Integer, db.ForeignKey('courses.id'))
                             )
​
​
class Student(db.Model):
    __tablename__ = "students"
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(64), unique=True)
​
    courses = db.relationship('Course', secondary=tb_student_course,
                              backref='student',
                              lazy='dynamic')
​
​
class Course(db.Model):
    __tablename__ = "courses"
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(64), unique=True)

• 添加测试数据

if __name__ == '__main__':
    db.drop_all()
    db.create_all()
​
    # 添加测试数据
​
    stu1 = Student(name='张三')
    stu2 = Student(name='李四')
    stu3 = Student(name='王五')
​
    cou1 = Course(name='物理')
    cou2 = Course(name='化学')
    cou3 = Course(name='生物')
​
    stu1.courses = [cou2, cou3]
    stu2.courses = [cou2]
    stu3.courses = [cou1, cou2, cou3]
​
    db.session.add_all([stu1, stu2, stu2])
    db.session.add_all([cou1, cou2, cou3])
​
    db.session.commit()
​
    app.run(debug=True)

数据库迁移

• 在开发过程中，需要修改数据库模型，而且还要在修改之后更新数据库。最直接的方式就是删除旧表，但这样会丢失数据。

• 更好的解决办法是使用数据库迁移框架，它可以追踪数据库模式的变化，然后把变动应用到数据库中。

• 在Flask中可以使用Flask-Migrate扩展，来实现数据迁移。并且集成到Flask-Script中，所有操作通过命令就能完成。

• 为了导出数据库迁移命令，Flask-Migrate提供了一个MigrateCommand类，可以附加到flask-script的manager对象上。

首先要在虚拟环境中安装Flask-Migrate。

pip install flask-migrate

• 代码文件内容：

  
  
#coding=utf-8
  
  
from flask import Flask
​
from flask_sqlalchemy import SQLAlchemy
from flask_migrate import Migrate,MigrateCommand
from flask_script import Shell,Manager
​
app = Flask(__name__)
manager = Manager(app)
​
app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://root:mysql@127.0.0.1:3306/Flask_test'
app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN'] = True
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
db = SQLAlchemy(app)
​
  
  
#第一个参数是Flask的实例，第二个参数是Sqlalchemy数据库实例
  
  
migrate = Migrate(app,db) 
​
  
  
#manager是Flask-Script的实例，这条语句在flask-Script中添加一个db命令
  
  
manager.add_command('db',MigrateCommand)
​
  
  
#定义模型Role
  
  
class Role(db.Model):
    # 定义表名
    __tablename__ = 'roles'
    # 定义列对象
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(64), unique=True)
    user = db.relationship('User', backref='role')
​
    #repr()方法显示一个可读字符串，
    def __repr__(self):
        return 'Role:'.format(self.name)
​
  
  
#定义用户
  
  
class User(db.Model):
    __talbe__ = 'users'
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(64), unique=True, index=True)
    #设置外键
    role_id = db.Column(db.Integer, db.ForeignKey('roles.id'))
​
    def __repr__(self):
        return 'User:'.format(self.username)
​
​
if __name__ == '__main__':
    manager.run()

创建迁移仓库

  
  
#这个命令会创建migrations文件夹，所有迁移文件都放在里面。
  
  
python database.py db init

创建迁移脚本

• 自动创建迁移脚本有两个函数

  • upgrade()：函数把迁移中的改动应用到数据库中。

  • downgrade()：函数则将改动删除。

• 自动创建的迁移脚本会根据模型定义和数据库当前状态的差异，生成upgrade()和downgrade()函数的内容。

• 对比不一定完全正确，有可能会遗漏一些细节，需要进行检查

python database.py db migrate -m 'initial migration'

更新数据库

python database.py db upgrade

返回以前的版本

可以根据history命令找到版本号,然后传给downgrade命令:

python app.py db history
​
输出格式：<base> ->  版本号 (head), initial migration

• 回滚到指定版本

python app.py db downgrade 版本号

实际操作顺序:

• 1.python 文件 db init

• 2.python 文件 db migrate -m"版本名(注释)"

• 3.python 文件 db upgrade 然后观察表结构

• 4.根据需求修改模型

• 5.python 文件 db migrate -m"新版本名(注释)"

• 6.python 文件 db upgrade 然后观察表结构

• 7.若返回版本,则利用 python 文件 db history查看版本号

• 8.python 文件 db downgrade(upgrade) 版本号

常见关系模板代码

以下罗列了使用关系型数据库中常见关系定义模板代码

一对多

• 示例场景：

  • 用户与其发布的帖子(用户表与帖子表)

  • 角色与所属于该角色的用户(角色表与多用户表)

• 示例代码

class Role(db.Model):
    """角色表"""
    __tablename__ = 'roles'
​
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(64), unique=True)
    users = db.relationship('User', backref='role', lazy='dynamic')
​
class User(db.Model):
    """用户表"""
    __tablename__ = 'users'
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(64), unique=True, index=True)

多对多

• 示例场景

  • 讲师与其上课的班级(讲师表与班级表)

  • 用户与其收藏的新闻(用户表与新闻表)

  • 学生与其选修的本文(学生表与选修本文表)

• 示例代码

tb_student_course = db.Table('tb_student_course',
                             db.Column('student_id', db.Integer, db.ForeignKey('students.id')),
                             db.Column('course_id', db.Integer, db.ForeignKey('courses.id'))
                             )
​
class Student(db.Model):
    __tablename__ = "students"
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(64), unique=True)
​
    courses = db.relationship('Course', secondary=tb_student_course,
                              backref=db.backref('students', lazy='dynamic'),
                              lazy='dynamic')
​
class Course(db.Model):
    __tablename__ = "courses"
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(64), unique=True)

自关联一对多(了解)

• 示例场景

  • 评论与该评论的子评论(评论表)

  • 参考网易新闻

• 示例代码

class Comment(db.Model):
    """评论"""
    __tablename__ = "comments"
​
    id = db.Column(db.Integer, primary_key=True)
    # 评论内容
    content = db.Column(db.Text, nullable=False)
    # 父评论id
    parent_id = db.Column(db.Integer, db.ForeignKey("comments.id"))
    # 父评论(也是评论模型)
    parent = db.relationship("Comment", remote_side=[id],
                             backref=db.backref('childs', lazy='dynamic'))
​
  
  
# 测试代码
  
  
if __name__ == '__main__':
    db.drop_all()
    db.create_all()
​
    com1 = Comment(content='我是主评论1')
    com2 = Comment(content='我是主评论2')
    com11 = Comment(content='我是回复主评论1的子评论1')
    com11.parent = com1
    com12 = Comment(content='我是回复主评论1的子评论2')
    com12.parent = com1
​
    db.session.add_all([com1, com2, com11, com12])
    db.session.commit()
    app.run(debug=True)

自关联多对多(了解)

• 示例场景

  • 用户关注其他用户(用户表，中间表)

• 示例代码

tb_user_follows = db.Table(
    "tb_user_follows",
    db.Column('follower_id', db.Integer, db.ForeignKey('info_user.id'), primary_key=True),  # 粉丝id
    db.Column('followed_id', db.Integer, db.ForeignKey('info_user.id'), primary_key=True)  # 被关注人的id
)
​
class User(db.Model):
    """用户表"""
    __tablename__ = "info_user"
​
    id = db.Column(db.Integer, primary_key=True)  
    name = db.Column(db.String(32), unique=True, nullable=False)
​
    # 用户所有的粉丝，添加了反向引用followed，代表用户都关注了哪些人
    followers = db.relationship('User',
                                secondary=tb_user_follows,
                                primaryjoin=id == tb_user_follows.c.followed_id,
                                secondaryjoin=id == tb_user_follows.c.follower_id,
                                backref=db.backref('followed', lazy='dynamic'),
                                lazy='dynamic')

蓝图&单元测试

• 蓝图

• 单元测试

学习目标

• 能够使用代码实现蓝图对项目进行模块化

• 能够说出断言的作用

• 能够说出实现单元测试步骤

• 能够说出单元测试所执行方法的定义规则

未完待续， 同学们请等待下一期

全套笔记和代码自取地址： 请移步这里

感兴趣的小伙伴可以自取哦，欢迎大家点赞转发~