python学习（四）：犹如鸿雁一般的Flask,小小框架有着无限可能

1.Flask安装

1.创建项目


pip install Flask                                     安装Flask模块python -m  flask run （--host=0.0.0.0）                运行项目（默认5000端口）

2.项目结构

FlaskAdmin
│  app.py                            主入口文件
├─static                              静态资源文件
│  └─css
│          index.css
└─templates                          模板文件└─homeindex.html

(1.默认结构

from flask import Flask,request,redirect,url_for,render_templateapp = Flask(__name__)@app.route('/')
def hello_world():return 'hello world'# 以脚本的形式运行，以命令行的形式运行，默认情况下，都没有实现热重载功能
if __name__ == '__main__':app.run(debug=True)

（2.热重载结构


使用pycharm 右上角的脚本运行方式有热重载功能，而命令行启动方式无效注意：1.这种方式只监听保存的代码。2.如果遇到异常，会立即退出。  3.一般增加功能会执行热重载。

2.Flask全栈学习

1.@app.route路由注解

1.route路由功能

1.methods请求注解


@app.route("/")
def hello_world():# html=""# lxml_demo.parse_page_lxml(html)return render_template('intro.html')### 注解中声明请求方法
@app.route('/login', methods=['GET', 'POST'])
def login():if request.method == 'POST':return "这是post方法"+request.form['username']else:return "这是get方法"

2.route多重路由注解(可变)


@app.route ('/hello/')
@app.route ('/hello/<name>')
def hello(name=None):return render_template ('home/index.html', name=name)

3.path路径参数路由


### 路径参数: string类型
## /user/xiaoming
@app.route('/user/<username>/')
def shwo_user_profile(username):return f'User {username}'### 路径参数: int类型
## /post/1
@app.route('/post/<int:post_id>')
def shwo_post(post_id):return f'Post {post_id}'

4.query参数路由


# ### query参数： request.args.get('xxx')获取
# @app.route ('/profile/')
# def profile():
#     if request.args.get ('name'):
#         return '个人中心页面'
#     else:
#         return redirect (url_for ('register'))
#

5.404错误页


@app.errorhandler(404)
def page_not_found(error):return render_template ('404error.html')

2.views视图函数

1.url_for路由别名

路由别名指向视图函数，而不受注解影响

### 视图函数的别名
## url_for('my_list',page=1,count=2)
## 构建出来的url：/post/list/1/?count=2
@app.route('/post/list/<page>/')
def my_list(page):return 'my list'模板中使用
<a href="{{ url_for('salut') }}">链接</a>
# 好处是路由可以随便改,不影响代码. 这里的参数是相应函数名(不带括号的)

2.render_template返回模板


## 模板文件
## flask采用Jinjia2作为模板，模板文件默认放置在templates文件夹(Django也是templates， 模板语法和Django类似)
def hello(name=None):return render_template ('home/index.html', name=name)

3.redirect路由重定向(url_for)


### query参数： request.args.get('xxx')获取
@app.route ('/profile/')
def profile():if request.args.get ('name'):return '个人中心页面'else:return redirect (url_for ('register'))    // 跳转指定的视图函数return redirect ('/register')             // 跳转指定的路由

3.Markup解析标签

Markup帮助咱们在HTML的标签上做了一层封装,让Jinja2模板语言知道这是一个安全的HTML标签。前端只需要在模板语法中加上一个safe就额可以了

后端 :
from flask import Markup  tag = "<input type='text' name='user' value='DragonFire'>" markup_tag = Markup(tag)前端 :
{{ tag|safe }}

4.template_global全局注解

@app.template_global()  # 定义全局模板函数
def a_b_sum(a, b):return a + b#定义一个全局函数,这样就不需要进行传递,可以在全局使用

2.templates模板语法

1.static静态资源


#Web程序中常常需要处理静态文件，在Flask中需要使用url_for函数并指定static端点名和文件名。 ### 1.模板文件中使用静态资源
(1.方法一：使用url_for模板语法
<link rel="stylesheet" href="{{url_for('static',filename='css/index.css')}}">(2.方法二：在setting添加对应的配置文件 <img src="/static/img/bg-main.png" alt="">  (添加上根路径下的文件就可以)### 2.在视图函数中使用模板文件 myhome/views.py
def func(request):return render_template(request,'a/ind.html')### 3.直接访问静态资源
// static 类似于其它框架的public目录，但Django框架需要携带这个目录
http://localhost:5000/static/assets/upload/image/bgmain-1.png

2.if…else,for…in语法

if…else,for…in和extend,include，Flask和Django相同

注意点：比如include加载有延迟，因此使用Django的方式开发flask, 效果并不理想。特别是对加载Script脚本时，影响最大

{% if name %}<h1>Hello {{ name }}!</h1>
{% else %}<h1>Hello, World!</h1>
{% endif %}{% for foo in g %}
.....
{% endfor %}

3.{{ }}过滤器

(1.模板过滤器

{{name | upper}}             名称大写（capitalize 首字母大写，trim 去空格， lower 转小写， upper 转大写）

(2.模板函数

# 1.视图函数
#定义一个函数,把它传递给前端
def a_b_sum(a,b):return a+b@app.route("/")
def index():## 传递模板函数return render_template("index.html", tag=a_b_sum) ## 传递列表数据return render_template ('charts.html',lxml_listl=self.lxml_list) # 2.模板页面
{{ tag(99,1) }}注意：如果没有使用{% comment %} 注释，则会出现异常

(3.枚举遍历

Jinjia2模板页面中不认识enumerate关键字1.在视图函数中先进行枚举
if keyword =='charts':return render_template ('charts.html',lxml_list=enumerate(self.lxml_list))2.再采用模板语法 {% for i,item in lxml_list  %}<tr><td>{{i+1}}</td><td>{{item["authors"]}}</td><td>{{item["tags"]}}</td><td>{{item["quotes"]}}</td></tr>{% endfor %}

3.models数据库模型

1.配置数据库

sqlalchemy：是一个独立的ORM框架，可以独立于Flask存在，也可以在其他项目中使用，比如Django中。
flask-sqlalchemy：对sqlalchemy的一个封装，能够更适合在flask中使用。

一、安装模块
1、安装连接数据库的库：
pip install pymysql2、安装封装后sqlalchemy：
pip install flask-sqlalchemy二、配置文件
from flask_restful import Api, Resource
from flask_sqlalchemy import SQLAlchemy#创建一个对象，设置名为db
db = SQLAlchemy(app)
# "mysql://账号:密码@数据库ip地址:端口号/数据库名"
app.config['SQLALCHEMY_DATABASE_URI'] = "mysql+pymysql://root:mysql@192.168.44.128:3306/test39"
# 关闭数据库修改跟踪操作[提高性能]，可以设置为True，这样可以跟踪操作：
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
# 开启输出底层执行的sql语句
app.config['SQLALCHEMY_ECHO'] = True
# 开启数据库的自动提交功能[一般不使用]
app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN'] = True
# 未知的配置功能
# app.config['SQLALCHEMY_BINDS'] = {}三、处理python3和python2的兼容性
python2中数据库客户端： MySqldb
python3中数据库客户端：pymysql
解决方案一：让python2和python3的包进行转换。
import pymysql
pymysql.install_as_MySQLdb()
方案二：表示只使用python3的包，不使用python2的包
app.config['SQLALCHEMY_DATABASE_URI'] = "mysql+pymysql://xxxxx"四、安装模块的注意事项
（1.如果在terminal中安装成功后，flask-sqlalchemy导入失败，则可以在pycharm的pip设置选项中添加这个模块
（2.如果出现PyMysql 找不到的情况下，在app.py中添加以下代码
import pymysql
pymysql.install_as_MySQLdb()

2.sqlalchemy模型使用

数据操作——增删改查
1：给模型对象设置数据可以通过初始化参数或者赋值属性两种方式
2：session.add(模型对象) 添加单条数据到会话中, session.add_all(列表) 添加多条数据到会话中
3：sqlalchemy 会自动创建事务, 并将数据操作包含在事务中, 提交会话时就会提交事务，事务提交失败会自动回滚。

**（1.**基本的使用

## （1.创建一个对象，设置名为db
##（注意需要在配置app.config数据库前，创建实例）
from flask_sqlalchemy import SQLAlchemy
db = SQLAlchemy(app)
## 配置数据库
app.config = {**app.config, **config}## （3.如果需要重建表，可以考虑以下内容（？）
# 删除表
db.drop_all()
# 创建表
db.create_all() ## （2.验证是否连接成功
engine = db.get_engine()
conn = engine.connect()
conn.close()
# 也可以执行sql语句
# with engine.connect() as conn:
#   result = conn.execute('select 1')
#   print (result.fetchone())

**(2.**模型的关联

教程链接：https://blog.csdn.net/qq_42385761/article/details/122792767


## （1.外键
#1.外键的数据类型一定要注意所引用的字段类型。db.Foreignkey("表名. 字段名")
#3.外键是属于数据库层面的，不推荐直接在ORM直接使用
author_id = db.Column(db.Integer,db.Foreignkey("user.id"))## （2.关联
#1.第一个参数是模型的名字，必须要和模型的名字一致(被连接的)。backref（bsck reference）。
#2.代表反向引用，代表对方访问我的时候的字段名称
author = db.relationship("user",backref="articles")## （3.一对一：
# db.backref
#1. 在反向引用的时候，如果需要传递一些其他的参数，那么就需要用到这个函数，否则不需要使用。
#2.只要在relationship的backref参数上，设置反向引用的名称就可以了。uselist=Flase ：代表反向引用的名称就可以了
user = db.relationship("User",backref=db.backref("extension",uselist=Flase))## （4.新建数据库表，创建orm模型
class Books(db.Model):__tablename__ = 'Books'  # 设置表名id = db.Column(db.Integer,primary_key=True,autoincrement=True) # 主键字段title = db.Column(db.String(200),nullable=False)  # 标题content = db.Column(db.Text,nullable=False)  # 内容class User(db.Model):id = db.Column(db.Integer,primary_key=True)username = db.Column(db.String(20))addresses = db.relationship('Address',backref='user')class Address(db.Model):id = db.Column(db.Integer,primary_key=True)email_address = db.Column(db.String(50))user_id = db.Column(db.Integer,db.ForeignKey('user.id'))

3.sqlacodegen反向映射*

flask-sqlacodegen，他的作用就是将数据库转换成模型
sqlacodegen的包是否删除(用flask-sqlacodegen就不能有sqlacodegen包，会有重复包名，会导致调用失败)

1.安装模块（下载失败可以在pycharm里面安装）
pip3 install flask-sqlacodegen==1.1.6 2.执行命令(需要停止运行程序)
python -m flask-sqlacodegen mysql+mysqldb://root:123456@127.0.0.1:3306/flask-test > models.py --flask注意：映射的模型文件，会清空原有的数据。

4.migrate模型映射

在实际的开发环境中，经常会发生数据库修改的行为。一般我们修改数据库不会直接手动的去修改，而是**去修改ORM对应的模型，然后再把模型映射到数据库**中。这时候如果有一个工具能专门做这种事情，就显得非常有用了，而flask-migrate就是做这个事情的。
flask-migrate是基于Alembic进行的一个封装，并集成到Flask中，而所有的迁移操作其实都是Alembic做的，他能跟踪模型的变化，并将变化映射到数据库中。

注意：如果已经有映射文件(migrations)和映射表(alembic_version)，则需要先删除再重新初始化。

1.安装模块
pip install flask-migrate2.使用方法(在定义模型的位置前后都可以)
from flask_migrate import Migrate
（1.模型注册到当前应用
db.init_app (app)
（2.绑定app和数据库
migrate = Migrate(app,db)3.使用命令执行映射ORM
python -m flask db init                        初始化一个迁移文件夹
python -m flask db migrate                     把当前的模型添加到迁移文件中
python -m flask db upgrade                     把迁移文件中对应的数据库操作，真正的映射到数据库中：（1. 数据库会生成一个alembic_version，是映射对应的id， 如果需要重新映射，也需要把这个表给手动删除。
（2. 把原有的migrations文件夹给删除

5.常用模型字段

1.常用数据类型

Integer：整形，映射到数据库中是int类型。
Float：浮点类型，映射到数据库中是flfloat类型。他占据的32位。
Double：双精度浮点类型，映射到数据库中是double类型，占据64位 (SQLALCHEMY中没有)。
String：可变字符类型，映射到数据库中是varchar类型.
Boolean：布尔类型，映射到数据库中的是tinyint类型。
DECIMAL：定点类型。是专门为了解决浮点类型精度丢失的问题的。在存储钱相关的字段的时候建议大家都使用这个数据类型。并且这个类型使用的时候需要传递两个参数，第一个参数是用来标记这个字段总能能存储多少个数字，第二个参数表示小数点后有多少位。
Enum：枚举类型。指定某个字段只能是枚举中指定的几个值，不能为其他值。在ORM模型中，使用Enum来作为枚举。
Date：存储时间，只能存储年月日。映射到数据库中是date类型。在Python代码中，可以使用datetime.date 来指定。
DateTime：存储时间，可以存储年月日时分秒毫秒等。映射到数据库中也是datetime类型。在Python代码中，可以使用 datetime.datetime 来指定。
Time：存储时间，可以存储时分秒。映射到数据库中也是time类型。在Python代码中，可以使用datetime.time 来创建值。
Text：存储长字符串。一般可以存储6W多个字符。如果超出了这个范围，可以使用LONGTEXT类型。映射到数据库中就是text类型。
LONGTEXT：长文本类型，映射到数据库中是longtext类型。

2.Column常用参数

primary_key：True设置某个字段为主键。
autoincrement：True设置这个字段为自动增长的。
default：设置某个字段的默认值。在发表时间这些字段上面经常用。
nullable：指定某个字段是否为空。默认值是True，就是可以为空。
unique：指定某个字段的值是否唯一。默认是False。
onupdate：在数据更新的时候会调用这个参数指定的值或者函数。在第一次插入这条数据的时候，不会用 onupdate的值，只会使用default的值。常用于是 update_time 字段（每次更新数据的时候都要更新该字段值）。
name：指定ORM模型中某个属性映射到表中的字段名。如果不指定，那么会使用这个属性的名字来作为字段名。如果指定了，就会使用指定的这个值作为表字段名。这个参数也可以当作位置参数，在第1个参数来指定。

4.data数据获取

1.获取MySQL数据

1.普通的CRUD

# 1. 添加数据
article = User(title = "标题", content = "内容")
db.session.add (article)
db.session.commit ()# 2.查询数据
# filter_by() 返回一个类列表的对象
obj_list = User.query.filter_by (id=1).all()
# first() 返回第一个对象
obj = User.query.filter_by (id=1).first()  # 3.修改数据
# 更新单个数据
obj = db.session.query(UserMsg).filter_by(id=obj.id)[0]
obj.token = token
db.session.commit ()
# 更新多个数据
obj_list = db.session.query(UserMsg).filter_by(email=obj.email).all()
for item in obj_list:item.token = token
db.session.commit ()# 4.删除数据
obj = User.query.filter_by (id=1)
obj.delete ()
db.session.commit ()

2.高级查询

# 1.模糊查询
# or_() 或查询数据
artice = User.query.filter_by (or_(id=1)).all()
# ilike是不区分大小写，like是区分大小写
user_list = UserMsg.query.filter(UserMsg.username.like(f'%{username}%')).all ()# 2.偏移查询
# offset() 跳过n条数据查询
artice = User.query.offset(2).filter_by (or_(id=1)).first()
# limit() 获取n条数据
artice = User.query.offset(2).filter_by (or_(id=1)).limit(10).first()
# [start:stop], slice(start,stop) 切片获取数据
artice = User.query.offset(2).filter_by (or_(id=1)).slice(0,10).first() # 3.排序
# order_by() 排序 （asc(), desc()）
artice = User.query.filter_by (id=1).order_by(User.id.desc()).all() # 4.分组查询
# group_by() 根据某些字段分组
# 如想要根据年龄进行分组，来统计每个分组分别有多少人
user_result = db.session.query(User.id,func.count(User.id)).group_by(User.sex).all()

2.获取Request数据

from flask import requestdef login():curmethod = request.method                请求方法(request包含请求的各种变量 )name = request.args.get("xxx")            获取get方法的query参数name = request.values.get("xxxx")         获取get方法的query参数(建议使用) data = request.form                       获取post请求的参数 headers = request.headers                 获取headers请求头数据fileName =　request.values.get("file")　　 获取上传的文件data = request.get_data()                 获取请求的所有数据

3.获取Response数据


# 普通返回字典数据
from flask import jsonify
def dowonload(): return jsonify({ 'msg':'下载成功！','code':200 })# 序列化数据集对象（模板传递数据不需要序列化）
from collections import Iterable
def serialize_models(modelsObj):try:# 可迭代对象是转换成列表，否则转换成字典if isinstance(modelsObj, Iterable):# 序列化成列表格式# 清洗列表数据(列表推导式)t_modelsObj = []for item in modelsObj:t_modelsObj.append({key: value for key, value in item.__dict__.items ()  if key != '_sa_instance_state' })modelsObj = list.copy(t_modelsObj)else:modelsObj = {key: value for key, value in modelsObj.__dict__.items () if key != '_sa_instance_state' }return modelsObjexcept Exception as e:print("序列化数据集对象异常",e)return None

5.Filter 拦截器

1.session身份认证

1.普通使用

如果有redis等缓存需求，可以安装Flask-Session

教程链接：https://blog.csdn.net/lluozh2015/article/details/123174344

from flask import session# 配置session
app.config['SECRET_KEY'] = os.urandom(24)
app.config['PERMANENT_SESSION_LIFETIME'] = timedelta(days=7)  # 设置session
session['username'] = 'liefyuan'# 获取session
# 如果内容不存在，将会报异常
result = session['key']
# 如果内容不存在，将返回None(推荐)
result = session.get('key')# 删除session
session.pop('username',None) # 清空session
session.clear## 页面中使用 session
{{ session.user.username}}

2.封装成拦截器


# 路由拦截器  @app.before_requestdef before():url = request.path  # 当前请求的URLpassUrl = ["/login", "/register","/auth/doLogin", "/auth/doRegister"]if url not in passUrl and not url.startswith("/static"):user = session.get ("user", None)if not user or not user.get("id"):return redirect("/login")else:# 验证帐号是否有效user_id = user.get("id")obj = UserMsg.query.filter_by (id=user_id,is_delete=0).first()if not obj:return redirect("/login")else:passelse:pass## 保存信息
# 保存到session里面obj = obj_list[0]session['user'] = {"id":obj.id,"username":obj.username,"email":obj.name,}

6.分离项目拦截器

1.flask_cors跨域

1.安装模块
pip install flask_cors2.使用方法
from flask_cors import CORS
# r'/*' 是通配符，让本服务器所有的 URL 都允许跨域请求
CORS(app, resources=r'/*')

2.PyJWT身份认证

(1.定义JWT方法

1.安装模块（这个模块与Django的相同）
pip install PyJWT2.使用方法
--/utils/JWT.py  实现jwt操作import jwtimport datetime# 加密密钥secret_key = 'xxxx'# 一、生成token密钥# 传入的数据为 use_id 最好不要添加其它参数，否则会超过最大值240， 目前是 176长度# 可修改参数：  valid_days  有效期天数可以修改，  secret_key   服务器密钥也可以修改## data为字典数据# 1.有效载核，存放有效信息   2.密钥字串， 服务端被重置时的合法性      3.sinature签名算法# 返回token字符串值 和 token数据def make_jwt(user_id):try:global secret_keynow_time = datetime.datetime.now ()str_now_time = datetime.datetime.strftime (now_time, '%Y-%m-%d %H:%M:%S')token_input_data = {'user_id': user_id,  # 用户ID,或者其它参数'now_time': str_now_time,  ## 当前的用户登录信息, 日期字符串'valid_days': 15  # 天数 days}encoded_jwt = jwt.encode (token_input_data, secret_key, algorithm='HS256')if type (encoded_jwt) != str:  ## 转换成普通的string字符串encoded_jwt = str (encoded_jwt, encoding="utf-8")return encoded_jwtexcept Exception as e:print ("错误是", e)return None# 二、解析token密钥## str_token 为token字符串## 返回验证结果 user_data /  Nonedef parse_jwt(str_token):try:global secret_keyif type (str_token) != bytes:str_token = bytes (str_token, encoding='utf8')# 解密tokentoken_output_data = jwt.decode (str_token, secret_key, algorithms=['HS256'])# 检测token的有效性str_pass_time = token_output_data.get ('now_time', None)str_valid_days = token_output_data.get ('valid_days', None)if len (str_pass_time) == 0 or str (str_valid_days) == 0:raise Exception ('error')obj_pass_time = datetime.datetime.strptime (str_pass_time, '%Y-%m-%d %H:%M:%S')obj_valid_time = obj_pass_time + datetime.timedelta (days=str_valid_days)now_time = datetime.datetime.now ()if obj_valid_time < now_time:raise Exception ('error')else:return token_output_dataexcept Exception as e:print ("错误是", e)return None# 三、jwt直接获取 user_id 参数值# 获取 token,   META 获取数据  ”HTTP_ + header字段名称大写“# 使用.get获取与是否在请求中使用get方法无关def get_parse_token(request):try:global secret_keystr_token = request.headers.get("token",None)  # 获取 tokenif type (str_token) != bytes:str_token = bytes (str_token, encoding='utf8')token_output_data = jwt.decode (str_token, secret_key, algorithms=['HS256'])return token_output_data['user_id']else:return Noneexcept Exception as e:print ("错误是", e)return None-- views/UserViews.py视图函数 from ..utils import JWT          # 自定义jwt生成token模块token = JWT.make_jwt(user_id)             # 生成tokenuser_obj = JWT.parse_jwt(token)           # 解析tokenuser_id = JWT.get_parse_token(request)    # 获取token数据

（2.jwt拦截器

# 路由拦截器@app.before_requestdef before():url = request.path  # 当前请求的URLpassUrl = ["/","/login", "/register"]if url not in passUrl and not url.startswith("/static"):token = request.headers.get("token")# 验证是否有tokenif not token:return jsonify({ 'msg':'无权限访问！请输入token！','code':403 })else:# 验证token是否有效user_id = jwt.get_parse_token(request)if not user_id:return jsonify({ 'msg':'无权限访问！token无效！','code':403 })else:# 验证帐号是否有效obj = UserMsg.query.filter_by (id=user_id,is_delete=0).first()if not obj:return jsonify({ 'msg':'无权限访问！当前帐号已被注销！','code':403 })else:passelse:pass

7.flask功能模块

1.passlib密码加密

1.安装模块
pip install passlib2.使用方法
from passlib.hash import pbkdf2_sha256# 密码加密
encryptPass = pbkdf2_sha256.hash("123456")
print("加密数据",encryptPass)# 验证密码
res = pbkdf2_sha256.verify("123456",encryptPass)
print("验证数据",res)

2.服务端文件下载

// 返回静态页面

# import urllib.request
# url = "http://127.0.0.1:5000/"
# res = urllib.request.urlopen(url)
# data = res.read().decode()
# print(data)import flask
app = flask.Flask(__name__)
# 路由就是将URL绑定到一个函数上面，这样浏览器客户端向web服务器发送一个URL请求后，服务器中的路由收到这个URL后，能立马找到对应的函数进行处理。
@app.route("/")
# 这是一段路由控制语句，每个路由地址用“@app.route(...)来指明，来访问的相对地址是“/”
def index():try:res = open('2.hello.html',"rb")data = res.read()res.close()return dataexcept Exception:print('error')if __name__=="__main__":app.run()

// 下载文件"图像.jpg"


import　flask
import　os
app=flask.Flask(__name__)
@app.route("/")
def　index():if　"fileName"　not　in　flask.request.values:return　"图像.jpg"else:data　=　b""try:fileName = flask.request.values.get("fileName")if　fileName　!=　""　and　os.path.exists(fileName):fobj　=　open(fileName,　"rb")data = fobj.read()fobj.close()## 返回二进制流except　Exception　as　err:data　=　str(err).encode()return　data
if　__name__=="__main__":app.run()

3.file上传文件

//获取文件名称fileName，然后获取文件数据保存

import　flask
app=flask.Flask(__name__)
@app.route("/upload",methods=["POST"])
def　uploadFile():msg=""try:if　"fileName"　in　flask.request.values:fileName　=　flask.request.values.get("fileName")　　　　　　data=flask.request.get_data()fobj=open("upload　"+fileName,"wb")fobj.write(data)fobj.close()msg="OK"## 存入本地else:msg="没有按要求上传文件"except　Exception　as　err:print(err)msg=str(err)return　msg
if　__name__=="__main__":app.run()