flask汇总

flask框架

蓝图

随着flask程序越来越复杂,我们需要对程序进行模块化的处理,之前学习过python的模块化管理,于是针对一个简单的flask程序进行模块化处理

Blueprint概念

  • 简单来说，Blueprint 是一个存储操作方法的容器，
    这些操作在这个Blueprint 被注册到一个应用之后就可以被调用，
    Flask 可以通过Blueprint来组织URL以及处理请求。

在Flask中Blueprint具有的属性

  • Flask使用Blueprint让应用实现模块化
  • 一个应用可以具有多个Blueprint
  • 在一个应用中，一个模块可以注册多次
  • Blueprint可以单独具有自己的模板、静态文件或者其它的通用操作方法
  • 在一个应用初始化时，就应该要注册需要使用的Blueprint
  • 一个Blueprint并不是一个完整的应用，它不能独立于应用运行，而必须要注册到某一个应用中。

使用蓝图的步骤

蓝图/Blueprint对象用起来和一个应用/Flask对象差不多，最大的区别在于一个 蓝图对象没有办法独立运行，必须将它注册到一个应用对象上才能生效

  • 1,创建一个蓝图对象
    admin=Blueprint('admin',name)
    • 蓝图对象中的参数
      • 蓝图的url前缀
        • 当我们在应用对象上注册一个蓝图时，可以指定一个url_prefix关键字参数（这个参数默认是/）
        • 在应用最终的路由表 url_map中，在蓝图上注册的路由URL自动被加上了这个前缀，这个可以保证在多个蓝图中使用相同的URL规则而不会最终引起冲突，只要在注册蓝图时将不同的蓝图挂接到不同的自路径即可
        • url_for

url_for('admin.index') # /admin/
* 注册静态路由
* 和应用对象不同，蓝图对象创建时不会默认注册静态目录的路由。需要我们在 创建时指定 static_folder 参数。
* 下面的示例将蓝图所在目录下的static_admin目录设置为静态目录

admin = Blueprint("admin",name,static_folder='static_admin')
app.register_blueprint(admin,url_prefix='/admin')
* 现在就可以使用/admin/static_admin/ 访问static_admin目录下的静态文件了
* 定制静态目录URL规则 ：可以在创建蓝图对象时使用 static_url_path 来改变静态目录的路由。下面的示例将为 static_admin 文件夹的路由设置为 /lib
* admin = Blueprint("admin",name,static_folder='static_admin',static_url_path='/lib')
app.register_blueprint(admin,url_prefix='/admin')
* 设置模版目录
* 蓝图对象默认的模板目录为系统的模版目录，可以在创建蓝图对象时使用 template_folder 关键字参数设置模板目录

admin = Blueprint('admin',name,template_folder='my_templates')
* 如果在 templates 中存在和 my_templates 同名文件,则系统会优先使用 templates 中的文件

  • 2,在这个蓝图对象上进行操作,注册路由,指定静态文件夹,注册模版过滤器
    @admin.route('/')
    def admin_home():
    return 'admin_home'
  • 3,在应用对象上注册这个蓝图对象
    app.register_blueprint(admin,url_prefix='/admin')
    • 这里的前缀和蓝图对象的前缀一样的作用
  • 当这个应用启动后,通过/admin/可以访问到蓝图中定义的视图函数

虚拟环境的

为甚麽搭建虚拟环境

在实际开发中,多个程序的运行可以能需要调试各种版本的不同环境,比如不同的python解释器,不同的flask版本
问题描述:如果直接进行多个版本安装,会导致后安装的内容覆盖先安装的.
解决办法:使用虚拟环境,不同的程序选择不同的环境,互不影响

搭建步骤

  • 1.先查看当前电脑中是否有虚拟环境命令
    virtualenv --version

  • 2.[可选]安装虚拟环境的命令:
    sudo pip install virtualenv
    sudo pip install virtualenvwrapper

  • 3.查看是否有mkvirtualenv创建虚拟环境指令
    mkvirtualenv --version

  • 4.[可选]安装完虚拟环境后，如果提示找不到mkvirtualenv命令，须配置环境变量

    • 4.1、创建目录用来存放虚拟环境
      mkdir $HOME/.virtualenvs
    • 4.2、打开~/.bashrc文件，并添加如下：
      export WORKON_HOME=$HOME/.virtualenvs
      source /usr/local/bin/virtualenvwrapper.sh
    • 4.3、运行
      source ~/.bashrc

  • 5.创建虚拟环境的命令 :
    mkvirtualenv 虚拟环境名称(默认python2.x)
    例： mkvirtualenv py_flask

    • mkvirtualenv -p python3 虚拟环境名称(指定python3.x)
      例 ：mkvirtualenv -p python3 py3_flask

如何使用虚拟环境

  • 1.查看虚拟环境的命令 :

    workon 两次tab键 或者 workon 回车

  • 2.使用虚拟环境的命令 :

    workon 虚拟环境名称
    例 ：workon py_flask
    例 ：workon py3_flask

  • 3.退出虚拟环境的命令 :

    deactivate

  • 4.删除虚拟环境的命令(需要先退出):

    rmvirtualenv 虚拟环境名称

    例 ：删除虚拟环境py3_flask

    先退出：deactivate

    再删除：rmvirtualenv py3_flask

如何在虚拟环境中安装工具包

  • 1.安装flask-0.10.1的包:
    pip install 包名称
    例 : 安装flask-0.10.1的包
    pip install flask==0.10.1
  • 2.查看虚拟环境中安装的包 :
    pip freeze
  • 工具包安装的位置
    • python2版本下：
      ~/.virtualenvs/py_flask/lib/python2.7/site-packages/
    • python3版本下：
      ~/.virtualenvs/py3_flask/lib/python3.5/site-packages

web应用程序交互流程

flask

核心

  • jinja2
    • 模板
  • 拓展包

    • flask_script

      • 命令行方式启动
        python hello.py runserver -host ip地址

      • from flask import Flask

      • 1.从flask_script中导入Manager类

      • from flask_script import Manager

      • app = Flask(name)

      • 2.使用Manager管理app对象

      • manager = Manager(app)

      • @app.route('/')

      • def hello_world():

      • return "helloworld"

      • if name == 'main':

      • manager.run()

    • flask_wtf

      • 后台CSRF校验机制

      • from flask import Flask,render_template

      • from flask_wtf import CSRFProtect

      • app = Flask(name)

      • 设置SECRET_KEY

      • app.config["SECRET_KEY"] = "fjkdjfkdfjdk"

      • 保护应用程序

      • CSRFProtect(app)

      • @app.route('/')

      • def show_page():

      • return render_template('file01csrf.html')

      • @app.route('/add_data',methods=["POST"])

      • def add_data():

      • return "登陆成功"

      • if name == 'main':

      • app.run(debug=True)

      • 前端隐藏表单

      • {#设置隐藏的csrf_token,使用了CSRFProtect保护app之后,即可使用csrf_token()方法#}

      • <input type="hidden" name="csrf_token" value="{{ csrf_token() }}">

      • <label>用户名:</label> <input type="text" name="username"><br>

      • <label>密码:</label> <input type="text" name="username"><br>

      • <input type="submit" value="登陆">

    • flask_migrate

      • 数据库迁移

    • flask_sqlalchemy

      • flask操作数据库
  • werkzeug
    • 路由模块
      • from werkzeug.route import Converter
        自定义转换器转换器

最简单的flaskweb

  • 新建文件helloworld.py文件

1.导入Flask类

from flask import Flask

2.创建Flask对象接收一个参数__name__，它会指向程序所在的包

app = Flask(name)

3.装饰器的作用是将路由映射到视图函数index

@app.route('/')
def index():
return 'Hello World'

4.Flask应用程序实例的run方法,启动WEB服务器

if name == 'main':
app.run()

加载应用程序的配置方式

  • from_pyfile

    • 从配置文件中添加
      在同级创建配置文件.ini
      配置内容每行一个

    • 从配置文件中加载配置

    • app.config.from_pyfile('config.ini')

  • from_object

    • 从配置对象中添加

    • 配置对象，里面定义需要给 APP 添加的一系列配置

    • class Config(object):

    • DEBUG = True

    • 从配置对象中加载配置

    • app.config.from_object(Config)

  • from_enver

    • 从环境变量中添加

    • 加载指定环境变量名称所对应的相关配置

    • app.config.from_envvar('FLASKCONFIG')

Flask()创建时的参数

  • name

    • 当前程序运行__main__

    • Flask程序所在的包(模块)，传 name 就可以

    • 其可以决定 Flask 在访问静态文件时查找的路径

  • static_folder

    • 静态文件存储的文件夹，默认为static

  • static_url_path

    • 静态文件访问路径，默认为 /static

  • template_folder

    • 模板文件存储的文件夹，默认为 template

app.run()传递的参数

  • host
  • port
  • debug

路由的定义

指定请求方式

  • methods

  • @app.route('/demo2', methods=['GET', 'POST'])

  • def demo2():

  • # 直接从请求中取到请求方式并返回

  • return request.method

  • 配合postman软件开发

  • Postman功能（https://www.getpostman.com/features）

  • 主要用于模拟网络请求包

  • 快速创建请求

  • 回放、管理请求

  • 快速设置网络代理

指定请求参数

路由传递参数,整数

@app.route('/user/int:user_id')
def user_info(user_id):
return 'the num is %d' % user_id

  • 不填转换器名称默认是字符串

    • 默认的就是UnicodeConverter, 所以不填转换器名称, 或者使用default、string都是一样的. - 默认将参数当做普通字符串对待. DEFAULT_CONVERTERS = { 'default': UnicodeConverter, 'string': UnicodeConverter, 'any': AnyConverter, 'path': PathConverter, 'int': IntegerConverter, 'float': FloatConverter, 'uuid': UUIDConverter, }

  • 自定义转换器

  • from flask import Flask

  • 导入基类转换器

  • from werkzeug.routing import BaseConverter

  • app = Flask(name)

  • 1.自定义类,继承自BaseConverter

  • class MyRegexConverter(BaseConverter):

  • # 2.编写初始化方法, init方法, 接收两个参数, url_map, regex, 并初始化父类空间和子类空间

  • def __init__(self,url_map,regex):

  •     super(MyRegexConverter, self).__init__(url_map)

  •     self.regex = regex

  • 3.将自定义转换器类,添加到默认的转换列表中

  • app.url_map.converters['re'] = MyRegexConverter

  • 使用自定义转换器

  • 接收3位整数

  • @app.route('/<re("d{3}"):num>')

  • def hello_world(num):

  • print("num = %s"%num)

  • return "the num is %s"%num

  • 接收一个手机号

  • @app.route('/<re("1[345678]d{9}"):mobile>')

  • def get_phone_number(mobile):

  • return "the mobile is %s"%mobile

  • if name == 'main':

  • app.run()

    • 继承与BaseCoverter

    • 可以直接指定regex值，重写init方法，传递正则规则

    • class BaseConverter(object):

    • """Base class for all converters."""

    • regex = '[^/]+'

    • weight = 100

    • def __init__(self, map):

    •     self.map = map

    • 也可以不直接指定regex值，在使用自定义转换器的时候指定正则规则

    • class MyConverter(BaseConverter):

    • def __init__(self,url_map,regex):

    •     super(MyConverter, self).__init__(url_map)

    •     self.regex = regex

    • app.url_map.converters['re'] = MyConverter

    • @app.route('/<re("d{3}"):num>')

    • def index(num):

    • return num

    • 自定义转换器类中的其他方法

    • class MyConverter(BaseConverter):

    • def __init__(self,url_map,regex):

    •     super(MyConverter, self).__init__(url_map)

    •     self.regex = regex

    • def to_python(self, value):  

    •     return value

    • def to_url(self, value):  

    •     return value

    • app.url_map.converters['re'] = MyConverter

      • to_python
        • 匹配成功后被调用，可以对匹配到的参数进行处理，比如转换匹配到的数据的类型，在正则匹配完成之后，调用视图函数之前，可以对数据进行最后的处理
      • to_url
        • 在正则匹配之前调用执行，并传入参数，调用完成之后才开始真正的路由匹配，不关心是否匹配成功，可以通过此函数修正要传入路由中的参数，方便更好的正则匹配

重定向

重定向

@app.route('/demo5')
def demo5():
# 使用 url_for 生成指定视图函数所对应的 url
return redirect(url_for('user_info', user_id=100))

  • redirect('路径')
    • 通过指定路径重定向到函数
  • url_for('函数名'，key=value)
    • 通过指定函数，返回路径，可以附带附带请求参数

返回json

  • 注意contentType

  • contentType: 告诉服务器，我要发什么类型的数据

  • dataType：告诉服务器，我要想什么类型的数据，如果没有指定，那么会自动推断是返回 XML，还是JSON，还是script，还是String。

  • json和dict转换

    • dict->json
      • json = json.dumps(dict)
      • json = jsonity(key=value)
    • json->dict
      • dict = json.loads(json)

  • jsonify

  • 自定义状态码

    • 手动指定（响应体——状态码+响应头）

    • make_response()

    • @app.route('/')

    • def hello_world():

    • # 1.直接返回, 响应体 + 状态码

    • # return "hello",666

    • # return "hello","666 BIGERROR"

    • # 2.手动创建响应体对象

    • response = make_response("hello")

    • response.status = "888 XIAGAO"

    • return response
      • status
      • headers

上下文

相当于一个容器，保存了 Flask 程序运行过程中的一些信息。

请求上下文

保存了客户端和服务器交互的数据

  • request
  • session

应用上下文

flask 应用程序运行过程中，保存的一些配置信息，比如程序名、数据库连接、应用信息等

  • current_app

  • 应用程序上下文,用于存储应用程序中的变量，可以通过current_app.name打印当前app的名称，也可以在current_app中存储一些变量，例如：

  • 应用的启动脚本是哪个文件，启动时指定了哪些参数

  • 加载了哪些配置文件，导入了哪些配置

  • 连了哪个数据库

  • 有哪些public的工具类、常量

  • 应用跑再哪个机器上，IP多少，内存多大

  • current_app.name

  • current_app.test_value='value'

  • g

  • g 作为 flask 程序全局的一个临时变量,充当者中间媒介的作用,我们可以通过它传递一些数据，g 保存的是当前请求的全局变量，不同的请求会有不同的全局变量，通过不同的thread id区别

  • g.name='abc'

  • 注意：不同的请求，会有不同的全局变量

状态保持

http是一种无状态协议，浏览器请求服务器是无状态的。
无状态：指一次用户请求时，浏览器、服务器不知道之前这个用户做过什么，每次请求都是一次新的请求。
无状态原因：浏览器与服务器是使用 socket 套接字进行通信的，服务器将请求结果返回给浏览器之后，会关闭当前的 socket 连接，而且服务器也会在处理页面完毕之后销毁页面对象。
有时需要保持下来用户浏览的状态，比如用户是否登录过，浏览过哪些商品等
实现状态保持主要有两种方式：
在客户端存储信息使用Cookie
在服务器端存储信息使用Session
二.生活状态举例：

Cookie是存储在浏览器中的一段纯文本信息，建议不要存储敏感信息如密码，因为电脑上的浏览器可能被其它人使用
Cookie基于域名安全，不同域名的Cookie是不能互相访问的
应用场景：广告推送；商城结账提取商品信息

  • 获取与设置cookie

  • from flask import Flask, make_response, request

  • app = Flask(name)

  • 设置cookie值

  • @app.route('/set_cookie')

  • def set_cookie():

  • response = make_response("set cookie")

  • response.set_cookie("name","zhangsan")

  • response.set_cookie("age","13",10) #10秒有效期

  • return response

  • 获取cookie

  • @app.route('/get_cookie')

  • def get_cookie():

  • #获取cookie,可以根据cookie的内容来推荐商品信息

  • # name = request.cookies['haha']

  • name = request.cookies.get('name')

  • age = request.cookies.get('age')

  • return "获取cookie,name is %s, age is %s"%(name,age)

  • if name == 'main':

  • app.run(debug=True)

Session

对于敏感、重要的信息，建议要存储在服务器端，不能存储在浏览器中，如用户名、余额、等级、验证码等信息,所以可以使用session进行保存
在服务器端进行状态保持的方案就是Session

  • 依赖cookie

  • 获取和设置session

  • from flask import Flask,session

  • app = Flask(name)

  • 设置SECRET_KEY

  • app.config["SECRET_KEY"] = "fhdk^fk#djefkj&&&"

  • 设置session

  • @app.route('/set_session/path:name')

  • def set_session(name):

  • session["name"] = name

  • session["age"] = "13"

  • return "set session"

  • 获取session内容

  • @app.route('/get_session')

  • def get_session():

  • name = session.get('name')

  • age = session.get('age')

  • return "name is %s, age is %s"%(name,age)

  • if name == 'main':

  • app.run(debug=True)

  • SECRET_KEY

请求钩子

在客户端和服务器交互的过程中，有些准备工作或扫尾工作需要处理，比如：

在请求开始时，建立数据库连接；
在请求开始时，根据需求进行权限校验；
在请求结束时，指定数据的交互格式；
为了让每个视图函数避免编写重复功能的代码，Flask提供了通用设施的功能，即请求钩子。

before_first_request

在第一次请求之前调用，可以在此方法内部做一些初始化操作
如：数据库的连接

before_request

在每次请求之前调用，这时候已经有请求了，可能在这个方法里面做请求的校验

如果请求的校验不成功，可以直接在此方法中进行响应，直接return之后那么就不会执行视图函数

@app.before_request
def before_request():
print("before_request")
# if 请求不符合条件:
# return "laowang"

after_request

在执行完视图函数之后会调用，并且会把视图函数所生成的响应传入,可以在此方法中对响应做最后一步统一的处理

@app.after_request
def after_request(response):
print("after_request")
response.headers["Content-Type"] = "application/json"
return response

teardown_request

请每一次请求之后都会调用，会接受一个参数，参数是服务器出现的错误信息

@app.teardown_request
def teardown_request(e):
print("teardown_request")

当前Request对象

request 就是flask中代表当前请求的 request 对象，其中一个请求上下文变量(理解成全局变量，在视图函数中直接使用可以取到当前本次请求)

args

  • 地址栏数据，问号后面
    www.baidu.com?key=value&key=value

data

  • json/xml,post提交的请求

form

  • 表单
  • 记录请求中的cookie信息

files

  • 文件内容

headers

  • 记录请求中的报文头

method

  • 记录请求中使用的HTTP方法

url

  • 记录请求的url地址

路由和视图函数在定义和匹配过程中关键类

BaseConverter

  • 记录匹配规则

Rule

  • 记录视图函数与路由映射关系

Map

  • 路由与视图函数关系列表

MapAdapter

  • 做具体匹配工作

Flask_script

属于flask的扩展包,通过使用Flask-Script扩展，我们可以在Flask服务器启动的时候，通过命令行的方式传入参数。而不仅仅通过app.run()方法中传参,比如我们可以通过：

继承脚本扩展，动态运行程序，指定IP，PORT

python hello.py runserver -host ip地址

Manager（app）

from flask import Flask

1.从flask_script中导入Manager类

from flask_script import Manager

app = Flask(name)

2.使用Manager管理app对象

manager = Manager(app)

@app.route('/')
def hello_world():
return "helloworld"

if name == 'main':
manager.run()

数据库

  • ORM

  • ORM 全拼Object-Relation Mapping. 称为对象-关系映射

  • 主要实现模型对象到关系数据库数据的映射.

    • 优点
      • 对数据库的操作都转化成对类,属性和方法的操作.
        不用编写各种数据库的sql语句.
        不在关注,使用的是mysql、oracle...等数据库
    • 缺点
      • 相比较直接使用SQL语句操作数据库,有性能损失.

  • Flask-SQLAlchemy

  • SQLALchemy 实际上是对数据库的抽象，让开发者不用直接和 SQL 语句打交道，而是通过 Python 对象来操作数据库，在舍弃一些性能开销的同时，换来的是开发效率的较大提升

  • SQLAlchemy是一个关系型数据库框架，它提供了高层的 ORM 和底层的原生数据库的操作。flask-sqlalchemy 是一个简化了 SQLAlchemy 操作的flask扩展。

    • 安装
      • pip install flask-sqlalchemy
      • 如果连接的是 mysql 数据库，需要安装 mysqldb
        pip install flask-mysqldb
      • 提示:如果flask-mysqldb安装不上,安装, pip install pymysql
    • 数据库连接设置
      • 数据库链接地址
        app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://root:mysql@127.0.0.1:3306/test'
        • 格式:mysql://<用户名>:<密码>@:<端口>/数据库名称
      • 动态追踪修改设置，如未设置只会提示警告
        app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
      • 有时候需要查看映射的sql语句
        • app.config['SQLALCHEMY_ECHO'] = True
      • 配置完成需要去 MySQL 中创建项目所使用的数据库
        $ mysql -uroot -pmysql
        $ create database test charset utf8;
      • 配置信息汇总
        • SQLALCHEMY_BINDS 一个映射 binds 到连接 URI 的字典。更多 binds 的信息见用 Binds 操作多个数据库。
        • SQLALCHEMY_ECHO 如果设置为Ture， SQLAlchemy 会记录所有 发给 stderr 的语句，这对调试有用。(打印sql语句)
        • SQLALCHEMY_RECORD_QUERIES 可以用于显式地禁用或启用查询记录。查询记录 在调试或测试模式自动启用。更多信息见get_debug_queries()。
        • SQLALCHEMY_NATIVE_UNICODE 可以用于显式禁用原生 unicode 支持。当使用 不合适的指定无编码的数据库默认值时，这对于 一些数据库适配器是必须的（比如 Ubuntu 上 某些版本的 PostgreSQL ）。
        • SQLALCHEMY_POOL_SIZE 数据库连接池的大小。默认是引擎默认值（通常 是 5 ）
        • SQLALCHEMY_POOL_TIMEOUT 设定连接池的连接超时时间。默认是 10 。
        • SQLALCHEMY_POOL_RECYCLE 多少秒后自动回收连接。这对 MySQL 是必要的， 它默认移除闲置多于 8 小时的连接。注意如果 使用了 MySQL ， Flask-SQLALchemy 自动设定 这个值为 2 小时。
      • 连接其他数据库
        • Postgres:
          postgresql://scott:tiger@localhost/mydatabase
        • MySQL:
          mysql://scott:tiger@localhost/mydatabase
        • Oracle:
  • oracle://scott:tiger@127.0.0.1:1521/sidname
    * SQLite （注意开头的四个斜线）:
    sqlite:////absolute/path/to/foo.db
    • 创建sqlalchemy对象

      • 创建SQLAlchemy对象

db = SQLAlchemy(app)

* 使用模型类创建数据表
    * 一对多关系
        * 一方
            * 创建模型类（继承自db.Model）
             * > class Student(db.Model):
             * >     __tablename__ = "students"
             * >     id = db.Column(db.Integer,primary_key=True)
             * >     name = db.Column(db.String(64),unique=True,nullable=False)
             * > 
             * >     #关系属性
             * >     courses = db.relationship("Course",backref="students",secondary=tb_student_course)

                * 默认表名为模型类的名字

__tablename__指定表名
* class Student(db.Model):
tablename = "students"
* 类属性名表示的字段名
* > 定义列对象
* > 变量作为字段名
* > 括号内是字段类型和字段约束

                    *  id = db.Column(db.Integer,primary_key=True)
name = db.Column(db.String(64),unique=True,nullable=False)
                * 关系属性
                 * > 关系属性方便查询使用
                 * > 通过 table_name.courses可以访问到‘Course’模型类定义的数据表
                 * > ‘Course’模型类定义的数据表，通过Course.students可以访问到本数据表

                    *  courses = db.relationship("Course",backref="students")
                    * lazy='dynamic'
                     * > 第三个参数lazy决定了什么时候SQLALchemy从数据库中加载数据
                     * > 如果设置为子查询方式(subquery)，则会在加载完Role对象后，就立即加载与其关联的对象，这样会让总查询数量减少，但如果返回的条目数量很多，就会比较慢
                     * > 设置为 subquery 的话，role.users 返回所有数据列表
                     * > 另外,也可以设置为动态方式(dynamic)，这样关联对象会在被使用的时候再进行加载，并且在返回前进行过滤，如果返回的对象数很多，或者未来会变得很多，那最好采用这种方式

                    * 关系属性在任何一方设置都行
        * 多方
            * 设置外键
                * role_id = db.Column(db.Integer,db.ForeignKey(Role.id))
    * 多对多关系
        * 创建一张关联表

关联表数据分别和两张表设置外键
* 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'))
)
* 关系属性设置在任何一方都行
* courses = db.relationship('Course', secondary=tb_student_course,
backref='student',
lazy='dynamic')
* 向数据表中添加数据
* 在
if name == main:
之后
* 一对多
* 创建模型类对象
* stu1 = Student(name='张三')
* cou1 = Course(name='物理')
* 将模型类对象添加进会话
* db.session.add(obj) 添加对象
db.session.add_all([obj1,obj2,..]) 添加多个对象
* db.session.delete(obj) 删除对象
* 提交会话
* db.session.commit() 提交会话
* db.session.rollback() 回滚
* db.session.remove() 移除会话
* 多对多
* 创建模型类对象
* 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(obj) 添加对象
db.session.add_all([obj1,obj2,..]) 添加多个对象
* db.session.delete(obj) 删除对象
* 提交会话
* db.session.commit() 提交会话
* db.session.rollback() 回滚
* db.session.remove() 移除会话
* app.run()

  • 数据库的迁移

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

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

    • 虚拟环境中安装Flask-Migrate
      • pip install flask-migrate
    • 导入相应的包
      • from flask_sqlalchemy import SQLAlchemy
        from flask_migrate import Migrate,MigrateCommand
        from flask_script import Shell,Manager
    • 创建Flask对象
      • app = Flask(name)
    • 使用flask-script的manager接管app对象
      • manager = Manager(app)
    • 设置app连接数据库的配置信息
    • 创建SQLAlchemy对象，读取app中的配置信息
      • db = SQLAlchemy(app)
    • 使用数据库迁移框架
      • migrate = Migrate(app,db)
        第一个参数是Flask实例，第二个参数是sqlalchemy数据库实例
    • 使用Flask_script中的manager动态运行程序

      • manager是Flask-Script的实例，这条语句在flask-Script中添加一个db命令

manager.add_command('db',MigrateCommand)

数据库迁移

  • 配合flask_migrate
    pip install flask-migrate

  • 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()

    • app = Flask(name)

    • manager = Manager(app)

    • db = SQLAlchemy(app)

    • migrate = Migrate(app,db)

    • manager.add_command('db',MigrateCommand)

    • 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

输出格式： -> 版本号 (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) 版本号

模板

Jinja2模板

1.获取各种变量的值

整数: {{ my_num + 20}}

字符串: {{ my_str + " python" }}

元组: {{ my_tuple }}, 分开获取:{{ my_tuple[0] }}, {{ my_tuple[1] }}

列表: {{ my_list }}, 分开获取:{{ my_list[0] }}, {{ my_list[1] }}

字典: {{ my_dict }},分开获取:{{ my_dict.name }}, {{ my_dict[age] }}

2.遍历元祖中所有的元素

{% for item in my_tuple %}
  • {{ item }}
    • {% endfor %} 
    <h2>3.取出列表中所有偶数</h2>
{% for item in my_list %}
    {% if item %2 == 0 %}
        {{ item }}
    {% endif %}
{% endfor %}

<h2>4.遍历字典内容</h2>
{% for key in my_dict %}
    {# 如果直接是mydict.key ,那么这个key是一个字符串, 如果是 mydict[key], 那么key当成变量 #}
    <li>{{ key }} = {{ my_dict[key] }}</li>
{% endfor %}

    • Jinja2模板概述

    • 用来展示数据的html页面,这个过程也通常称为渲染,属于Jinja2的功能 使用模板的好处：

    • 视图函数只负责业务逻辑和数据处理(业务逻辑方面)

    • 而模板则取到视图函数的数据结果进行展示(视图展示方面)

    • 代码结构清晰，耦合度低

    • Jinja2特点

    • Jinja2：是 Python 下一个被广泛应用的模板引擎，是由Python实现的模板语言，他的设计思想来源于 Django 的模板引擎，并扩展了其语法和一系列强大的功能，其是Flask内置的模板语言。

    • 模板语言：是一种被设计来自动生成文档的简单文本格式，在模板语言中，一般都会把一些变量传给模板，替换模板的特定位置上预先定义好的占位变量名。

    • 使用render_template函数封装模板引擎

      • python代码实现
      • 仿照django实现模板语言
      • 过滤器支持链式调用{{
        str|lower|reverse }}
      • 直接在模板中支持运算

    • Jinja2模板语法

      • 获取变量值

        • 整数:{ {number} }

      元祖:{ {tuple[0]} }

      列表:{ { list[0] } }

      字典:{ { dict['key'] } }

      * 分支语句 * { % if 条件 % } 语句1

    { % else % }
    语句2
    { % endif % }
    * for循环
    * {% for 变量 in 容器 %}
    语句
    {% endfor%}
    * for循环中可以访问i的特殊变量
    * loop.index 当前循环迭代的次数（从 1 开始）
    * loop.index0 当前循环迭代的次数（从 0 开始）
    * loop.revindex 到循环结束需要迭代的次数（从 1 开始）
    * loop.revindex0 到循环结束需要迭代的次数（从 0 开始）
    * loop.first 如果是第一次迭代，为 True 。
    * loop.last 如果是最后一次迭代，为 True 。
    * loop.length 序列中的项目数。
    * loop.cycle 在一串序列间期取值的辅助函数。见下面示例程序。
    * 注释
    * {# 注释内容 #}

    • Jinja2模板过滤器

      • Jinja2模板自带的两种过滤器

      • 过滤器的本质就是函数。有时候我们不仅仅只是需要输出变量的值，我们还需要修改变量的显示，甚至格式化、运算等等，而在模板中是不能直接调用 Python 中的某些方法，那么这就用到了过滤器。

        • 字符串过滤器
    • 使用格式:{{ 字符串 | 字符串过滤器 }}
      * safe：禁用转义

    {{ 'hello' | safe }}

    * capitalize：把变量值的首字母转成大写，其余字母转小写

    {{ 'hello' | capitalize }}

    * lower：把值转成小写

    {{ 'HELLO' | lower }}

    * upper：把值转成大写

    {{ 'hello' | upper }}

    * title：把值中的每个单词的首字母都转成大写

    {{ 'hello' | title }}

    * reverse：字符串反转

    {{ 'olleh' | reverse }}

    * format：格式化输出

    {{ '%s is %d' | format('name',17) }}

    * striptags：渲染之前把值中所有的HTML标签都删掉

    {{ 'hello' | striptags }}

    * 列表过滤器 * 使用格式:{{ 列表 | 列表过滤器 }} * first：取第一个元素

    {{ [1,2,3,4,5,6] | first }}

    * last：取最后一个元素

    {{ [1,2,3,4,5,6] | last }}

    * length：获取列表长度

    {{ [1,2,3,4,5,6] | length }}

    * sum：列表求和

    {{ [1,2,3,4,5,6] | sum }}

    * sort：列表排序

    {{ [6,2,3,1,5,4] | sort }}

    * 使用过滤器的其他操作语句 * 语句块操作 {% filter upper %} #一大堆文字# {% endfilter %} * 链式调用 {{ "hello world" | reverse | upper }} * Jinja2自定义过滤器的两种方式 * 先定义函数（一个形参接受原值） * 添加到过滤器列表，app.add_template_filter('函数名'，‘过滤器名称’) * > def do_listreverse(li): * > # 通过原列表创建一个新列表 * > temp_li = list(li) * > # 将新列表进行返转 * > temp_li.reverse() * > return temp_li * > * > app.add_template_filter(do_listreverse,'lireverse') 
        * 定义函数，直接使用过滤器列表装饰@app.teemplate_filter('过滤器名称')
     * > @app.template_filter('lireverse')
     * > def do_listreverse(li):
     * >   # 通过原列表创建一个新列表
     * >   temp_li = list(li)
     * >   # 将新列表进行返转
     * >   temp_li.reverse()
     * >   return temp_li

    • 模板代码的复用

    • 在模板中，可能会遇到以下情况：

    • 多个模板具有完全相同的顶部和底部内容

    • 多个模板中具有相同的模板代码内容，但是内容中部分值不一样

    • 多个模板中具有完全相同的 html 代码块内容

    • 像遇到这种情况，可以使用 JinJa2 模板中的 宏、继承、包含来进行实现

      • 宏

      • 宏是Jinja2中的函数,调用后,直接返回一个模板,或者字符串

      • 当模板中出现大量重复功能代码的时候,可以使用宏来进行封装

        • 定义宏
          可以在当前文件，也可以在其他文件

        • {% macro input(name,value='',type='text') %}

        • <input type="{{type}}" name="{{name}}" value="{{value}}">

        • {% endmacro %}

          • 使用当前文件的宏

          • {{ input('name' value='zs')}}

          • 使用其他文件的宏

          • {%import 'filename.html' as 别名%}

          • {%别名.函数名(参数)%}

      • 继承

      • 将公共的内容抽取到父类模板,共子类使用的形式称为继承.

      • 一般Web开发中，继承主要使用在网站的顶部菜单、底部。这些内容可以定义在父模板中，子模板直接继承，而不需要重复书写。

        • 父模板

        • 父模板中使用多个block组成

          • {% block top %}
            顶部菜单
            {% endblock top %}

    {% block content %}
    正文内容
    {% endblock content %}

    {% block bottom %}
    底部
    {% endblock bottom %}
    * 子模版
    * 继承后,子类完全拥有父类内容,并且子类可以进行重写,如果写保留父类内容使用: super()

            * {% extends 'base.html' %}

    {% block content %}
    需要填充的内容
    {% endblock content %}
    * 模板继承的注意点
    * 不支持多继承
    为了便于阅读，在子模板中使用extends时，尽量写在模板的第一行。
    不能在一个模板文件中定义多个相同名字的block标签。
    定义block模板的时候,一定要加上endblock结束标记
    * 包含
    * > Jinja2模板中，除了宏和继承，还支持一种代码重用的功能，叫包含(Include)。它的功能是将另一个模板整个加载到当前模板中，并直接渲染。

        * 格式:

    {% include 'hello.html' %}
    或者
    {% include 'hello.html' ignore missing %}
    提示: ignore missing 加上后如果文件不存在,不会报错
    * 总结
    * 宏(Macro)、继承(Block)、包含(include)均能实现代码的复用。
    继承(Block)的本质是代码替换，一般用来实现多个页面中重复不变的区域。
    宏(Macro)的功能类似函数，可以传入参数，需要定义、调用。
    包含(include)是直接将目标模板文件整个渲染出来。

    • 模板特有的变量和函数

    • 你可以在自己的模板中访问一些 Flask 默认内置的函数和对象

      • config
        • 你可以从模板中直接访问Flask当前的config对象:

    {{config.DEBUG}}
    输出:True
    * request
    * 就是flask中代表当前请求的request对象：

    {{request.url}}
    输出:http://127.0.0.1
    * g变量
    * 在视图函数中设置g变量的 name 属性的值，然后在模板中直接可以取出

    {{ g.name }}
    * url_for()
    * url_for会根据传入的路由器函数名,返回该路由对应的URL,在模板中始终使用url_for()就可以安全的修改路由绑定的URL,则不比担心模板中渲染出错的链接:

    {{url_for('home')}}
    * 如果我们定义的路由URL是带有参数的,则可以把它们作为关键字参数传入url_for(),Flask会把他们填充进最终生成的URL中:

    {{ url_for('post', post_id=1)}}
    /post/1
    * get_flashed_messages()
    * 这个函数会返回之前在flask中通过flask()传入的消息的列表，flash函数的作用很简单,可以把由Python字符串表示的消息加入一个消息队列中，再使用get_flashed_message()函数取出它们并消费掉：

    {%for message in get_flashed_messages()%}
    {{message}}
    {%endfor%}

    • Flask_WTF表单
      • 使用代码定义表单
      • 在模板中进行表单渲染
      • 提供一系列的验证器，对表单提交的数据进行验证
      • 流程
        • 定义类继承子FlaskForm
        • 在类中编写字段内容，验证函数
        • 创建，渲染到页面
    • csrf
      • flask_wtf模块提供了csrf攻击的保护
      • 使用流程:

    from flask_wtf.csrf import CSRFProtect
    CSRFProtect(app)
    * CSRFProtect(app)保护原理:
    * > 对应用程序app中的post,put,dispatch,delete, 4种类型的请求做保护,因为这些类型的请求是用于更改服务器的资源
    * > 当以上面4种类型的请求,操作服务器资源的时候,会校验cookie中的csrf_token, 表单中的csrf_token信息
    * > 只有上面二者的值相等的时候,那么校验则通过,可以操作服务器资源

    * csrf_token值的生成需要加密, 所以设置SECRET_KEY
* 前后端代码
    * 后端代码
     * > from flask_wtf import CSRFProtect
     * > app.config["SECRET_KEY"] = "fjkdjfkdfjdk"
     * > CSRFProtect(app)

    * 前端代码
     * > {#设置隐藏的csrf_token,使用了CSRFProtect保护app之后,即可使用csrf_token()方法#}
     * >     <input type="hidden" name="csrf_token" value="{{ csrf_token() }}">

    render_template()函数

    from flask import Flask,render_template
    app = Flask(name) #默认省略了三个参数,static_url_path, static_folder, template_folders

    @app.route('/')
    def hello_world():
    #定义数据,整数,字符串,元祖,列表,字典
    num = 10
    str = "hello"
    tuple = (1,2,3,4)
    list = [5,6,7,8]
    dict = {
    "name":"张三",
    "age":13
    }

    return render_template('file01.html',my_num=num,my_str=str,my_tuple=tuple,my_list=list,my_dict=dict)

    if name == 'main':
    app.run(debug=True)

    • 将数据传递给模板
      return render_template('模板文件名',key=value)

    XMind: ZEN - Trial Version

    【推广】 免费学中医，健康全家人
    原文地址：https://www.cnblogs.com/serpent/p/9614628.html