flask通用模板
from flask import Flask, render_template, request
from flask_sqlalchemy import SQLAlchemy
from flask_migrate import Migrate, MigrateCommand
from flask_script import Manager
app = Flask(__name__)
# 为app指定数据库的链接信息
app.config['SQLALCHEMY_DATABASE_URI'] = \
'mysql+pymysql://root:123456@localhost:3306/flask'
# 取消sqlalchemy的信号追踪
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
# 设置程序的启动模式
app.config['DEBUG'] = True
# 非查询自动提交回数据库
app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN']= True
# 创建SQLAlchemy的实例db,以后在程序中通过db来操作数据库
db = SQLAlchemy(app)
# 创建Manager对象，指定管理哪个对象（app）
manager = Manager(app)
# 创建Migrate对象，指定关联的app和db
migrate = Migrate(app, db)
# 为manager增加命令，允许做数据库的迁移操作
# 为manager绑定一个叫db的命令，该子命令执行操作由MigrateCommand提供
manager.add_command('db', MigrateCommand)
# 创建实体类
class A(db.Model):
__tablename__ = 'a'
id = db.Column(
db.Integer
)
# 默认http://localhost:5000
@app.route('/01', methods=['POST', 'GET'])
def views():
if request.method == "GET":
return render_template('1.html')
else:#请求方式为post
pass
if __name__ == "__main__":
manager.run()
# 配置完成后运行,此操作每个项目只需要运行一次即可
# python3 xx.py db init
# 作用：将编辑好的实体类生成中间文件并保存在migrations文件夹
# 特点：只要检测到实体类有更改就会生成中间文件
# python3 xx.py db migrate
# 将中间文件映射回数据库
# python3 xx.py db upgrade
# 完整运行命令
# python3 xx.py runserver --host 0.0.0.0 --port 5555
flask基础介绍
1.静态网页 和 动态网页
1.静态网页：无法与服务器做交互的网页
2.动态网页：允许与服务器做交互的网页
2.web 与服务器之间的关系
1. web : 网页（html, css, js）
2. 服务器：server
1.什么是服务器？
能够给用户提供服务的机器就是服务器
2.硬件和软件
1.硬件
一台主机
2.软件
一个能够接受用户请求并能够给出响应的程序
常用服务器端软件：
1. APACHE
2. TOMCAT
3. IIS
4.Nginx
3.作用：
1.存储web上的信息
2.能够处理用户的请求（request）并给出响应（response）
3.执行处理程序
4.具备一定的安全功能
3.框架
1. 什么是框架？
为了解决开放性问题而存在的程序结构
2. python web 框架
1. Flask - 轻量级
2. Webpy - 轻量级
3. Tornado - 异步框架
4. Django - 重量级的
3. 框架的模式
1.框架模式
指的是框架中各组件的交互方式
2.常用的模式
1.MTV
M : Models 模型层，根据数据库进行建模
T : Templates, 模板层， 处理与用户显示相关的内容
V : Views， 视图层， 处理与用户打交道的内容（请求和响应）
2.MVC
M : Models 模型层，根据数据库建模
V : views 视图层，处理用户显示相关的内容
C : Controller 控制器， 处理请求和响应
4.Flask框架：
1.什么是Flask？
一个基于python并且依赖于jinjja2模引擎和Werkzeug WSGI服务的一个微型框架
WSGI：web server gateway interface(web 服务网关接口 )
2.安装Flask
1.查看已安装的版本
进入python 的交互模式： import flask
>>> flask.__version__ 查看版本
2.在线安装
sudo pip3 install flask
5.flask - 路由（route）
1.什么是路由
路由就是为了匹配用户的请求地址以及对应的视图函数
2.路由的体现
在flask中,路由是由@app.route装饰器来表示
http://localhost:5000
@app.route(’/’)
def index():
return ‘xxxx’
3.带参数的路由
路由中可以携带参数来表示要传递到视图中的数据
http://localhost:5000/show/wangwc
http://localhost:5000/show/lixiaod
http://localhost:5000/show/liergou
1.基本带参数路由
@app.route(’/show/’)
def show(name):
#name 表示的就是通过地址栏所传递过来的数据
return
２．带多个参数的路由
@app.route(’/show//’)
def show(name, age):
return
＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊
端口占用：
１． netstat -lptu 查看占用5000端口的pid号是多少
２． kill －９ 端口号
以上步骤重复两遍
＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊
３．指定参数类型的路由
＠app.route(’/show//int:age’)
def show(name, age):
pass
int 类型转换器
Flask中的类型转换器
类型转换器 作用
缺省 字符串，不能有斜杠/
int： 整数
float： 浮点数
path: 字符串允许有/
4.多路由匹配，允许让多个url地址匹配到同一个视图处理函数
示例：
localhost:5000/index
localhost:5000/default
localhost:5000/
匹配到同一个视图
@app.route(’/index’)
@app.route(’/default’)
@app.route(’/’)
def index():
return ‘xxx’
4.url的反向解析
正向解析：程序自动解析，根据@app.route(’’)中的访问路径来匹配
处理函数
地址 >>> 视图函数（正向）
视图 >>> 访问地址（反向）
反向解析：通过视图处理函数的名称以及参数生成对应的访问url
语法：
from flask import url_for
url = url_for(func, args)
参数：func表示视图处理函数的名称
args 表示处理函数中需要的参数
url 表示视图处理函数对应的访问地址
6.模板 － Templates
1.什么是模板？
能够呈献给用户去看的网页
在模板中允许包含‘变量’来表示动态的数据
在模板中，允许嵌套服务端的代码
Flask是依赖于jinja2的模板引擎
２．Flask模板的设置
默认情况下Flask会在项目工程中的一个templates文件夹中
去搜索模板
3.模板的渲染
１．作用：
在视图中，将模板文件(xx.html)先渲染为字符串，再响应
给客户端浏览器。
２．函数：
from flask import render_template
render_template('模板名称,html')
模板的基本设置
１．基本设置
在项目工程的根目录创建一个templates文件夹
２．模板的渲染
渲染成字符串，
再将模板字符串响应
return render_template(‘模板名称.html’)
＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊
模板中的语法规范：（重难点）
１．变量
模板中的变量是一种占位符，告诉模板该位置的值是从渲染时哪个
数据中获取
语法：
１．在视图处理函数中
渲染模板，并带一些数据到模板中
return render_template(‘xx.html’, 变量1=值1, …)
2.在模板中
获取对应的变量的值放到指定的位置即可
语法：{{变量名}}
示例：
在xxx.html中
姓名：{{name}}
姓名：{{age}}
2.过滤器
１．什么是过滤器
允许在变量输出前改变变量的值
２．语法
{{变量|过滤器}}
３．jinja2常见过滤器
capitalize 首字母大写，其余小写
lower 所有字母变小写
upper 所有字符变大写
title 所以单词首字母大写
trim 取消字符串两端的空格
default 如果变量为空，则使用default的值显示
truncate 如果字符串超出指定长度则截取字符串
后面显示…
3.标签
１．什么是标签
每个标签表示的就是不同的服务端功能
２．语法
{% 标签内容 %}
3.常用标签
１．if 标签
１．基本的if标签
{% if 条件%}
满足条件要运行的内容
{%endif%}
２．if .. else ..
{% if 条件%}
满足条件要运行的内容
{% else %}
不满足条件要运行的
{%endif%}
3. if .. elif .. else ．．
{% if 条件%}
满足条件要运行的内容
{% elif 条件２%}
满足条件２要运行的内容
{% endif %}
2.for 标签
１．语法
{% for 变量 in 可迭代对象 %}
变量是属于服务器端的，使用时需要用{{}}
判断时用{%%}
{%endfor%}
2.内置变量 loop
作用:
在for 循环中无需声明，可以直接使用
表示本次循环的一些相关信息
２．常用属性
１．loop.index
表示当前循环的次数从１开始
2.loop.index0
当前循环的下标从0开始记录
3.loop.first
当前是否为第一次循环
４.loop.last
判断是否为最后一次循环
３.macro标签 宏
1.作用
相当于在网页中声明函数
２.语法
使用{%macro%}...{%endmacro%}声明
{%marco 名称(参数列表)%}
．．．
{%endmacro%}
调用:
{{名称(参数列表)}}
３.在独立的文件中声明
在实战开发中推荐将宏们放在统一的文件中
进行管理
１.创建macro.html 模板文件
声明所有宏文件
２.导入模板文件
{% import 'macro.html' as ma %}
4.静态文件
１.什么是静态文件
不与服务器做动态交互的文件一律是静态文件
2.静态文件的处理
１.在项目工程的目录中创建一个static文件夹
作用：为了存放所有的静态资源
２.所有的静态文件必须通过/static／路径访问
／static后的子路径将到static文件夹中继续搜索
模板：
１.静态地址的反向解析
url_for(‘static’, filename=’<file_path>’)
示例
<img
src=‘url_for(‘static’, filename=‘img/a.jpg’)’
>
2.模板的继承
１.什么是模板的继承
类似于类的继承
如果一个模板中的内容大部分与另一个模板一样
可以使用继承的方式简化模板的开发。
2.语法：
１．父模板文件
需要定义哪些内容在子模板中是可以被重写的
{% block 块名 %}
定义在父模板中要正常显示的内容
{% endblock %}
block :
１.在父模板中是可以正常显示的，没有任何影响
２.在子模板中是可以被重写的
２．子模板文件
１.需要指定继承自那个模板
{% extends ‘父模板名称’%}
２.重写父模板中指定的内容
{% block 快名 %}
此处编写的内容会覆盖掉父模板的同名block的
内容
{% endblock %}
修改配置
１.构建Flask应用时指定配置信息
app = Flask(
__name__,
template_folder = "templates", #指定存放模板的文件夹名称
static_url_path = "/static", #指定访问静态文件的路径
static_folder = "static", #指定保存静态资源的文件夹名称
)
２.启动程序时运行配置
app.run(
debug=1,
port = 5555,
host = '0.0.0.0',
)
指定访问到本项目的地址，
0.0.0.0表示局域网内都可以访问到本项目
其他机器访问本机项目时需要使用ip地址
请求和响应
1.HTTP 协议
1.作用
规范了数据是如何打包以及传递的
２．两大核心内容
１．请求消息
由客户端带给服务端的消息
由三部分组成：
１．请求起始行
GET / HTTP/1.1
1请求 －get
2请求资源路径 ／
3HTTP协议及版本 HTTP/1.1
２．请求消息头
所有以key:value格式存在的内容都是消息头
每个消息头都是要传递给服务器的信息
３．请求主体
只有post put请求方式才有请求主体
２．响应消息
由服务端带给客户端的消息
１.响应起始行
HTTP/1.1 200 OK
1.协议以及版本号 HTTP/1.1
2.响应状态码-200
3.原因短句 OK
２.响应消息头
以key:value格式存在的内容都是消息头
服务器要传递给浏览器的信息
3.响应主体
服务器端响应回来的数据
2.请求对象 request
1.什么是请求
请求对象中会封装所有与请求相关的信息
如：请求数据，消息头，路径
２．语法
from flask import request
通过request来表示请求
3.request中的常用成员
1.scheme 获取请求协议
2.method 获取本次请求的方式
3.args 获取使用get请求方式所提交的方式
4.form 获取使用post请求方式所提交的数据
5.cookies 获取cookies相关数据
6.files 获取上传的文件们
7.path 获取请求的资源路径（不包含请求参数）
8.full_path 获取请求资源的完整路径
9.url 获取完整的请求地址从协议处开始
10.headers 获取请求消息头的信息
3.获取请求提交的数据
1.get请求方式
1.get方式的场合
1.表单中使用get请求方式
＜form method='get'>
....
</form>
2.通过地址栏访问的全部都是get请求
1.<a href='/01?参数名＝参数值＆...'>
</a>
2.window.location.href='/01?名=值&...'
get请求要通过request.args 获取请求参数值
（允许按照字典的方式-
操作request.args）
2.post请求方式
1.场合
＜form method='post'></form>
2.获取post请求数据
通过request.form 获取post方式提交的数据
（按照字典的方式操作）
3.注意
文件上传（表单的文件的上传设置form的enctype属性）
1.准备工作
文件一定要放在表单中上传
1.表单的提交方式必须为post
****2.表单的enctype属性值为multipart/form-data
2.服务器端
文件上传首先会传到＇缓存区＇,我们需要将文件从缓存区中去出来
保存到指定的位置
1.通过request属性files 获取上传的文件
f = request.files[‘文件框的name值’]
2.通过f.save(保存路径)将文件保存到指定目录处
通过f.filename得到文件名
f.save(‘static/’ + f.filename)
注意：
保存的目录必须已经存在
模型－ Models
1.什么是模型
模型：根据数据库中的表结构创建出来的class
数据库中每一张表对应到编程语言中就是一个class
表中的每一列对应就是class中的一个属性
2.模型的框架 －ORM框架
1.什么是ORM
Object relational Mapping
中文名： 对象关系映射
2.orm的三大特征
1.数据表table到编程类class的映射
2.数据类型的映射
数据库中表的字段以及数据类型对应到编程语言中就是
类的属性及其数据类型
3.关系映射
将数据库中表和表的关系对应到编程语言中类与类的关系
1.一对一的关系
A表中的一条数据只能与B表中的一条数据关联
B表中的一条数据只能与A表中的一条数据关联
2.一对多的关系
A表中的一条数据可以与B表中的多条数据关联
B表中的一条数据只能与A表中的一条数据关联
3.多对多
A表中的一条数据可以与B表中的多条数据关联
B表中的一条数据可以与A表中的多条数据关联
3.优点
1.封装了数据库所有的操作，提升效率
2.可以省略庞大的数据访问层，即使不用sql编码也能
完成对数据库的CRUD操作
3.Flask中的ORM框架
1.SQLAlchemy 框架
1.安装SQLAlchemy
pip3 install sqlalchemy
2.Flask 中需要安装flask-sqlalchemy
pip3 install flask-sqlalchemy
2.Flask中配置数据库
from flask import Flask
from flask_SQLAlchemy import SQLAlchemy
app = Flask(__name__)
#为app指定数据库的链接信息
app.config['SQLALCHEMY_DATABASE_URI'] =
'mysql://root:123456@localhost:3306/flask'
创建SQLAlchemy的实例db,以后在程序中通过db来操作数据库
db = SQLAlchemy(app)
数据库工具
1.Navicat for MySQL
数据库第三方可视化工具
2.Power Designer
数据库建模工具
模型层
模型－ Models
1.什么是模型
模型：根据数据库中的表结构创建出来的class
数据库中每一张表对应到编程语言中就是一个class
表中的每一列对应就是class中的一个属性
2.模型的框架 －ORM框架
1.什么是ORM
Object relational Mapping
中文名： 对象关系映射
2.orm的三大特征
1.数据表table到编程类class的映射
2.数据类型的映射
数据库中表的字段以及数据类型对应到编程语言中就是
类的属性及其数据类型
3.关系映射
将数据库中表和表的关系对应到编程语言中类与类的关系
1.一对一的关系
A表中的一条数据只能与B表中的一条数据关联
B表中的一条数据只能与A表中的一条数据关联
2.一对多的关系
A表中的一条数据可以与B表中的多条数据关联
B表中的一条数据只能与A表中的一条数据关联
3.多对多
A表中的一条数据可以与B表中的多条数据关联
B表中的一条数据可以与A表中的多条数据关联
3.优点
1.封装了数据库所有的操作，提升效率
2.可以省略庞大的数据访问层，即使不用sql编码也能
完成对数据库的CRUD操作
3.Flask中的ORM框架
1.SQLAlchemy 框架
1.安装SQLAlchemy
pip3 install sqlalchemy
2.Flask 中需要安装flask-sqlalchemy
pip3 install flask-sqlalchemy
2.Flask中配置数据库
from flask import Flask
from flask_SQLAlchemy import SQLAlchemy
app = Flask(__name__)
#为app指定数据库的链接信息
app.config['SQLALCHEMY_DATABASE_URI'] =
'mysql://root:123456@localhost:3306/flask'
创建SQLAlchemy的实例db,以后在程序中通过db来操作数据库
db = SQLAlchemy(app)
模型：
1.定义模型**
模型：根据数据库中的表结构创建出来的class（模型类）（实体类）
实体完整性：确保数据库一张表中的数据不能重复，靠主键实施
1.语法：
calss MODELNAME(db.Model):
tablename = 'TABLEWARE＇
COLUMN_NAME = db.Column(db.TYPE, OPTIONS)
1.MODELNAME :定义的模型类的名称，根据表名设定
表名为USERS 可设为Users
2.TABLENAME 映射到数据库的表名
表名为USERS 可设置为
class Users(db.Model):
tablename = ‘USERS’
3.COLUMN_NAME 属性名，映射到数据库就是列名d
4.TYPE 映射到列的数据类型
5.OPTIONS 列选项
db.TYPE 列类型如下
类型名 python类型 说名
Integer int 普通整数，32位
SmallInteger int 小范围，16位
BigInteger int/long 不限精度
Float Float 浮点数
Numeric decimal.decimal 定点数
String str 字符串
Text str 字符串
Boolean bool 布尔
Date datetime.Date 日期
Time datetime.time 时间类型
DateTime datetime.datetime 日期时间类型
OPTIONS 列选项
选项名 说明
autoincrenent 如果设置为True为子增长
如果列是整数， 并且是主键则默认自曾长
primary_pri 为True为主键
unique 为Ture表示该列值唯一
index 为Ture该列加索引
nullable 为Ture该列可为空
default 指定该列默认值
如果一个列中要包含多个列选项，使用＇,＇隔开
列选项与列类型之间使用＇，＇隔开
2.db.creat_all()
将所有的实体类创建到数据库上
注意：
只有类对应的表不存在时才会创建，否则没反应
3.db.drop_all()
将所有的数据表全部删除
安装：flask-script
安装：flask-migrate
2数据库的迁移
将实体类的改动映射回数据库
依赖第三方库
1.flask-script
类Manager
作用：对项目进行管理，如启动，添加命令
2.flask-migrate
类：
1.Migrate
作用：用于管理app 和 db 之间的协调关系
2.MigrateCommand
作用：允许在终端中提供实体类的迁移命令
3.实现数据库的迁移
1.python3 xxx.py db init
作用：做一些项目和数据库的初始化操作
特点：一个项目中，只执行一次即可
2.python3 xxx.py db migrate
作用：将编辑好的实体类生成中间文件并保存在migrations文件夹
特点：只要检测到实体类有更改就会生成中间文件
3.python3 xxx.py db upgrade
作用：将中间文件映射回数据库
3.基于ORM的CROD
1.增加 C(Create)
1.创建实体类的对象， 并为对象的属性赋值
实例：
user = User()
user.username = 'xsw'
user.age = 37
... ...
2.将实体对象保存回数据库
db.session.add(user)
#非查询操作必须手动将操作提交回数据库
db.session.commit()
3.配置自动提交
app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN']= 1
当视图函数执行完毕后，自动提交所有操作到数据库
2.查询：R
1.基于db.session进行查询
db.session.query()
参数：
要查询的列, 如果查询多个列的话，使用，隔开
如果查询所有列的话，则参数为实体类
实例
1.查询Users实体类中的id, username, age
db.session.query(Users.id, Users.username, ..)
2.查询所有实体类
db.session.query(Users)
3.查询Users 实体类和Wife类中的所有列
db.session.query(Users, Wife)
返回值：
该函数会返回一个Query对象， 类型为BaseQuery
查询执行函数
目的：在db.session.query()上得到最终结果
语法：db.session.query(...).查询执行函数()
函数 说明
all() 以列表的方式返回所有数据
first() 以实体对象的方式返回查询结果
若没有，返回None
first_or_404 效果同上，如果没有响应404
count() 返回查询结果的数量
查询过滤器函数
1.作用
在db.session.query()追加筛选条件
２.语法:
dn.session.query().查询过滤器函数().过滤器函数()
过滤器函数 作用
filter() 按指定查询条件
filter_by() 等值查询条件中使用
limit() 获取前几行的数据
offset() 指定结果偏移量
order_by() 排序
group_by() 分组
过滤器函数详解：
１.filter()
等值判断用 ==
构建各种各样的条件
注意点：
条件必须由 实体类．属性 构成
db.session.query(Users).filter(Users.age == 17).all()
返回值：BaseQuery对象
filter函数可以连用，相当于and条件
也可在一个filter函数中，用,号隔开两个条件
查询或 用＿or()
from SQLAlchemy import or_
xxx.filter(or_(条件１， 条件２))
模糊查询：
查询所有email中包含wang的用户信息
select * from users where email like '%wang%'
like()方法模糊查询
db.session.query(Users).filter(Users.name.like('%wang%'))
in_(['', ''])方法模糊查询
db.session.query(Users).filter(Users.age.in_([17,30,35])).all()
between and 查询
db.session.query(Users).filter(Users.age.between(30, 45)).all()
2.filter_by()
作用：只能做单表的等值条件过滤筛选
语法：
db.session.query(xx).filter_by(属性＝值).all()
特点：
１.不用实体类.属性， 直接用属性名即可
２.等值判断用=， 而不是 ==
练习：查询Users实体中isActive为True的信息
３.limit() & offset()
1.limit(n)
作用：获取前n条数据
语法：
db.session.query(xx).limit(n).all()
2.limit(m)).offset(n)
作用：跳过n条，获取m条数据
语法：
db.session.query(xx).limit(m).offset(n)
4.order_by()
作用：排序
示例：
１. 将数据降序
db.session.query(Users).order_by('age desc').all()
2.Users实体中大于１８岁的人按照年龄排序，如果年龄相同按照id 升序排列
db.session.query(Users).filter(Users.age > 18) \
.order_by('age desc, id').all()
聚合查询：
１．基本的聚合查询
from sqlalchemy import func
#func对象中提供了所有的聚合函数
sum() 求和 func.sum()
count()
...
语法：
db.session.query(func.聚合函数(实体类.属性)).all()
示例:查询Users所有人的平均年龄
db.session.query(func.avg(Users.age)).all()
2.分组聚合查询
语法：
db.session.query(聚合).group_by('属性名＇).all()
#Users实体中，按isActive 分组求每组人数
db.session.query(
func.count(Users.age)
).group_by('isActive').all()
3.带条件的分组聚合
语法：
db.session.query(查询列, 聚合列).filter(条件)
．group_by('分组')
.having(条件)
基于实体类的查询
实体类.query.查询过滤器函数().查询执行函数()
ex:
1.查询Users实体中的所有数据
Users.query.all()
2.查询Users实体中isActive为Ture的数据
Users.query.filter_by(isActive = Ture ).all()
` 3.修改－u
1.查
查询出要修改的实体对象
２．改
通过实体对象.属性 ＝ 值
３．保存
db.session.add(实体对象)
示例：
修改Users实体中id 为1的年龄为３７
user = db.session.query(Users).filter_by(id = 1).first()
user.age = 37
db.session.add(user))
4.删除 －D
１.查询
查询出实体对象
２．删除
db.session.delete(对象)
重定向：
什么是重定向
由服务器通过浏览器向一个新的地址发送请求
语法：
from flask import redirect
redirect(‘新地址’)
特点：产生两次响应
关系映射：
1.一对多
数据库中的体现靠主外键的关系实现
多表中增加主键，表示对一表主键的引用
＊＊＊在flask-SQLALchemy上的实现
在多的实体类中增加对一的实体类的引用，
在一的实体类中增加 关联属性 和 反向引用关系属性
１．在多的实体类中
增加一个列要引用一表类的主键列
外键列名 ＝ db.Column(db.Integer, db.ForeignKey('主键表.主键列'))
示例：模拟Course 和 Teacher之间的关系
在Teacher 中增加一个列外键引用自Course的主键
course_id = db.Column(
db.Integer,
db.ForeignKey('course.id'),
nullable=1
)
２．在一实体类中
增加关联属性和反向引用关系属性
目的： 在编程语言中创建类与类之间的关系
１．关联属性
在一实体中，要通过哪个<<属性>>来获取到对应的'多'的实体对象们
２．反向引用关系属性
在'多'的实体中，要通过哪个<<属性>>来获取到对应的一的对象的实体
语法：
在‘一’的实体类中增加
属性名 ＝ db.relationship(
'多的实体类名',
backref='自定义一个反向引用关系属性名称'，
lazy='dynamic'
)
lazy ：指如何加载course中对应的Teacher们的信息
１．select
首次访问时加载关联数据
２．immediate
源对象加载后立马加载关联数据（使用连接）
３．subquery
效果同上
４．noload
永不加载
５．dynamic
不加载记录，但是提供加载记录的查询
示例：
class Course(db.Model):
....
#关联属性和反向引用关系
teachers = db.relationship(
'Teacher',
backref = 'course',
lazy='dynamic'
)
３．获取数据
１．通过一的对象找多的关联对象们
通过 关联属相查找
course = Course.query.filter_by(id=1).first()
teachers = course.teachers.all()
2.通过多的查一
tea = Teacher.query.filter_by(id= 1).first()
course = tea.course
2.一对一
１．关联的两张表中任意增加外键，引用另一表的主键
２．并且要实施唯一约束
在orm中的实现
１．在任意一张表中增加外键和唯一约束
u_id = db.Column(
db.Integer,
db.ForeignKey('主表.属性')，
unique = 1,
nullable = 1
)
2.另外一张表中增加关联属性和反向引用关系属性
属性名 ＝ db.relationship(
'关联实体类名'，
backref='反向引用关系属性'，
uselist = 0
)
uselist 设置为False 表示关联属性的一个标量而非一个列表
3.多对多
在数据库中实现
依靠第三张关联表
在ORM中
１．创建第三张表
２．关联属性和反向引用关系
在关联的两个类中任意一个类中增加
属性名 = db.relationship(
'关联的类名'，
secondary='第三张关联表名'，
lazy = 'dynamic',
backref = db.backref(
'反向引用关系名称',
lazy = 'dynamic'
)
)
cookies
Cookies:
1.什么是Cookies／Cookie
cookie是一种数据存储的手段
将一段文本保存在客户端浏览器的一种手段，并可以长时间保存数据
２.cookies使用场合
１．记住密码
３．在flask中使用cookies
1.使用响应对象，将数据保存进cookies
１．响应对象的构建
１．重定向就是响应对象
resp = redirect() #就是响应对象
２．通过make_response()构建响应对象
from flask import make_response
resp = make_response('' 或 render_template)
2.保存cookies的语法：
响应对象.set_cookie(key, value, max_age)
key 保存cookie的名称
value 保存的cookie的值
max_age 最大存活时长，取值为数字,以秒为单位
２．获取cookie的值
每次向服务器发送请求时，都会将cookie的数据封装在request中带到服务器
通过request.cookies 获取所有的cookies的值（字典），在通过cookie的具体名称，
得到具体的值
３．删除cookies的值
响应对象.delete_cookie('key')
来源：CSDN
作者：zz_never_giveup
链接：https://blog.csdn.net/u013259361/article/details/103462302