Flask学习记录#

flask run启动#

新版flask在linux中的运行方式#

先在环境变量中指定要运行哪个文件，比如要运行的是helloworld_server.py文件

1
export FLASK_APP=helloworld_server

对于win环境，则使用

1
$env:FLASK_APP = "helloworld_server"

然后如果要运行在开发模式则需要输入：（前面是linux环境命令，后面是win环境命令）

1
export FLASK_ENV=development
2
$env:FLASK_ENV="development"

然后执行(后面的可以指定ip和端口)

1
flask run
2

3
flask run -h 0.0.0.0 -p 50001

export FLASK_ENV=production运行在生产模式，未指明则默认为此方式 export FLASK_ENV=development运行在开发模式

flask routes查询路由#

注意，需要先在环境变量中指定要运行的是哪个文件，才能使用flask routes查询这个文件中的路由

定义路由的请求方式#

有三种：

GET

OPTIONS（自带）

HEAD（自带）

methods参数指定请求方式#

method指定的是一个列表，里面可以有多种支持的请求方式

1
@app.route("/itcast1", methods=["POST"])
2
def view_func_1():
3
    return "hello world 1"
4

5
@app.route("/itcast1", methods=["GET", "POST"])
6
def view_func_2():
7
    return "hello world 2"

蓝图的使用#

单一文件定义蓝图#

1
# 8创建蓝图对象
2
user_bp = Blueprint('user', __name__)
3
# 9编写蓝图视图
4
@user_bp.route('/profile')
5
def get_profile():
6
    return 'get_profile'
7
# 10注册蓝图
8
# app.register_blueprint(user_bp)
9
# 11指定蓝图的url前缀
10
app.register_blueprint(user_bp, url_prefix='/user')

目录定义蓝图#

1、先有目录，然后有__init__.py文件和views.py文件

views.py里是蓝图对应的视图代码

在__init__.py文件中编写代码：

1
# 0导包
2
from flask import Blueprint
3

4
# 1创建蓝图对象
5
goods_bp = Blueprint('goods', __name__, url_prefix='/goods')
6

7
# 2导入views.py，不导入的话不会执行views.py中的代码，就不能访问视图函数
8
from . import views

在views.py文件编写代码：

1
# 0导入蓝图对象
2
from . import goods_bp
3

4
# 1编写蓝图视图
5
@goods_bp.route('/getgoods')
6
def get_goods():
7
    return 'goods'

2、在创建flask应用的文件里把蓝图注册到app

1
# 12 注册goods包中的蓝图，注意这里导包是从goods路径导入__init__.py文件中的gods_bp，如果写成from goods.__init__会访问不了蓝图
2
from goods import goods_bp
3
app.register_blueprint(goods_bp)

蓝图必须显示指明静态文件目录#

不像默认的static文件夹一样，蓝图里的静态文件不会被默认寻找，只有显示指定静态文件目录才会去找

1
admin = Blueprint("admin",__name__,static_folder'static_admin')
2
app.register_blueprint(admin,url_prefix='/admin')

也可通过 static_url_path 改变访问路径

1
admin = Blueprint("admin",__name__,static_folder='static_admin',static_url_path='/lib')
2
app.register_blueprint(admin,url_prefix='/admin')

从url路径获取参数#

直接获取

1
# 13从url路径中获取参数
2
@user_bp.route('/profile/<user_id>')
3
def get_profile_by_id(user_id):
4
    return 'get_profile_by_id：{}'.format(user_id)

转换器配合正则表达式使用#

1
# 14使用转换器配合正则表达式
2
@user_bp.route('/profile/<int:user_id>')
3
def get_profile_by_id(user_id):
4
    return 'get_profile_by_id：{}'.format(user_id)

转换器内置的类型：

default
string
any
path
int
float
uuid

自定义转换器类型#

1
# 15自定义转换器
2
# 16导包并编写类
3
from werkzeug.routing import BaseConverter
4
class MobileConverter(BaseConverter):
5
    """自定义转换器"""
6
    regex = r'1[3-9]\d{9}'
7
# 17将自定义的转换器告知flask应用
8
app.url_map.converters['mobile'] = MobileConverter
9
# 18使用自定义转换器
10
@app.route('/sms_codes/<mobile:mob_num>')
11
def send_sms_code(mob_num):
12
    return 'send_sms_code：{}'.format(mob_num)

request对象的使用#

request对象中封装了以下内容：

data	记录请求的数据，并转为字符串（请求体）	*
form	记录请求中的表单数据	MultiDict
args	请求中的参数	MultiDict
cookies	请求中的cookie信息	Dict
headers	请求头	EnvironHeaders
method	请求方法	GET/POST
url	请求的URL地址	string
files	请求上传的文件	*

从请求中获取参数#

1
# 19request对象的使用，要先导入request包
2
# /articles?channel_id=123
3
@app.route('/articles')
4
def get_articles():
5
    channel_id = request.args.get('channel_id')
6
    return 'get_articles：{}'.format(channel_id)

从请求中获取文件#

1
# 20提取request中的文件
2
@app.route('/upload', methods=['POST'])
3
def upload_file():
4
    file = request.files['pic']
5
    # 手动打开文件
6
    with open('./demo.jpg', 'wb') as new_file:
7
        new_file.write(file.read())
8
    # flask提供的保存文件方法
9
    file.save('./demo.jpg')
10
    return 'ok'

处理响应render_template#

使用模板文件夹中的文件去处理响应

1
# 0导包
2
from flask import Flask, request, Blueprint
3

4
app = Flask(__name__)
5

6
# 1导入模板响应需要的包
7
from flask import render_template
8
# 2使用render_template函数去渲染模板，传参直接传递参数
9
# 在模板中通过{{my_str}}和{{my_int}}去获取参数
10
@app.route('/')
11
def index():
12
    # 普通变量直接传
13
    #my_str = 'hello world'
14
    #my_int = 100
15
    #return render_template('index.html', my_str=my_str, my_int=my_int)
16
    # 字典要保证字典中的key和模板中的变量名一致
17
    data = dict(
18
        my_str='hello world',
19
        my_int=1233
20
    )
21
    return render_template('index.html', **data)
22
    # 这行传字典，等价于下面这行，所以要保证字典中的key和模板中index.html的变量名一致
23
    # return render_template('index.html', my_str='hello world', my_int=1233)

重定向#

1
# 3重定向，先导包
2
from flask import redirect
3
@app.route('/demo')
4
def demo():
5
    return redirect('http://www.itheima.com')

返回json#

1
# 4返回json数据
2
# 先导包
3
from flask import jsonify
4
@app.route('/json')
5
def json():
6
    json_dict = {
7
        "user_id": 1001,
8
        "user_name": "itcast",
9
        "age": 18
10
    }
11
    return jsonify(json_dict)

响应的返回#

1
# 5响应有两种返回方式
2
# 元祖返回响应
3
@app.route('/demo4')
4
def demo4():
5
    # 注意格式是(response,status,headers)，如果不足3个，则从右边开始缺省
6
    # 例如写了status，那必须要有response
7
    return '状态码为 666', 666, {'Itcast': 'python'}
8
# make_response返回响应
9
from flask import make_response
10
@app.route('/demo5')
11
def demo5():
12
    response = make_response('状态码为 666')
13
    response.headers['Itcast'] = 'python'
14
    response.status_code = 666
15
    return response

设置cookie只能通过make_response#

1
# 6设置cookie
2
from flask import make_response
3
@app.route('/cookie')
4
def set_cookie():
5
    response = make_response('设置cookie成功')
6
    # 第一个参数是cookie的名称，第二个参数是cookie的值，第三个参数是cookie的过期时间，可以没有第三个参数
7
    response.set_cookie('username', 'itcast', max_age=3600)
8
    return response

读取cookie的值#

1
# 7读取cookie的值
2
@app.route('/get_cookie')
3
def get_cookie():
4
    username = request.cookies.get('username')
5
    return username

删除cookie的值#

1
# 8删除cookie
2
@app.route('/delete_cookie')
3
def delete_cookie():
4
    response = make_response('删除cookie成功')
5
    response.delete_cookie('username')
6
    return response

session对象#

设置session#

1
# 9设置session，注意在使用session之前，必须先设置secret_key
2
# 先导包
3
from flask import session
4
@app.route('/set_session')
5
def set_session():
6
    session['username'] = 'itcast'
7
    return '设置session成功'

读取session#

1
#10读取session
2
@app.route('/get_session')
3
def get_session():
4
    username = session.get('username')
5
    return '获取到session数据：{}'.format(username)

异常处理#

http异常主动抛出用abort()#

1
# 11使用abort函数，直接返回错误响应，要先导包
2
from flask import abort
3
@app.route('/article')
4
def get_article():
5
    channel_id = request.args.get('channel_id')
6
    if channel_id is None:
7
        abort(404)
8
    else:
9
        return '获取文章成功,channel_id:{}'.format(channel_id)

装饰器捕获异常#

1
# 12捕获异常，用装饰器
2
@app.errorhandler(500)
3
def internal_server_error(e):
4
    return '服务器搬家了', 500
5
# 13也可以捕获特定的异常
6
@app.errorhandler(ZeroDivisionError)
7
def zero_division_error(e):
8
    return '除数不能为0'
9
@app.route('/zero')
10
def zero():
11
    a = 1/0
12
    return 'zero 函数'

请求钩子hook#

就是中间件的作用

请求的处理过程：pre_process -> view -> after_prosess

middleware1.pre_process() -> m2.pre_process() -> m3.pre_process()->view0 -> m3.after_process() -> m2.after_process() ->m1.after_process() -> client

中间件处理不区分具体是哪个视图，对所有视图通通生效

有四中处理的方法：

before_first_request：只在第一次接收到请求时处理，在视图前

before_request：每次请求前执行，在视图前

after_request：如果没有抛出异常，在每次请求后执行

teardown_request：在每次请求后执行

上下文#

分为：请求上下文和应用上下文

请求上下文#

有两个，request和session

应用上下文#

current_app：当前应用

使用场景：在另一个文件中要使用到其他文件中创建的app对象，直接import有循环引用的风险

1
from flask import Blueprint, current_app
2
bp = Blueprint('passprot', __name__)
3

4
@bp.route('/bp')
5
def viewfunction():
6
    # 这行相当于 app.config.get('Itcast')
7
    current_app.config.get('Itcast')
8
    pass

g对象：省去传递参数的声明，只在一次请求的期间传递，下一次请求存下一次请求的数据

1
# 18g对象可以存取当前请求的数据，免于传参
2
# 先导包
3
from flask import g
4
# 普通传参方式
5
def db_query_1(user_id, user_name):
6
    return 'db_query_1:{}, {}'.format(user_id, user_name)
7
# g对象方式
8
def db_query_2():
9
    user_id = g.user_id
10
    user_name = g.user_name
11
    return 'db_query_2:{}, {}'.format(user_id, user_name)
12
@app.route('/g')
13
def get_user_profile():
14
    # user_id = 123
15
    # user_name = "itcast"
16
    # ret = db_query_1(user_id, user_name)
17
    g.user_id = 456
18
    g.user_name = "itcast"
19
    ret = db_query_2() # 不用考虑传参
20
    return ret

正式开始写项目#

通过endpoint给路由起别名#

1
# 起别名是给这个HelloWorldResource, '/'这一组起别名
2
api.add_resource(HelloWorldResource, '/', endpoint='HelloWorld')

flask_result的路由#

1
# -*- conding:utf-8 -*-
2
# 0导包
3
from flask import Flask
4
from flask_restful import Resource, Api
5

6
# 1创建app
7
app = Flask(__name__)
8
api = Api(app)
9

10
# 2创建类视图
11
class HelloWorldResource(Resource):
12
    def get(self):
13
        return {'hello': 'world'}
14

15
    def post(self):
16
        return {'msg': 'post hello world'}
17

18
# 3注册路由，参数是类视图对应的类，和访问路径
19
api.add_resource(HelloWorldResource, '/')

flask_result的蓝图#

1
# 4给蓝图导包
2
from flask import Blueprint
3
# 5创建蓝图对象
4
user_bp = Blueprint('user', __name__)
5
# 6使用蓝图，api对象不再和全局的app对象绑定，而是和蓝图绑定，得到蓝图里的api对象
6
user_api = Api(user_bp)
7
# 7蓝图的类视图
8
class UserProfileResource(Resource):
9
    def get(self):
10
        return {'msg': 'get user profile'}
11
# 8用蓝图里的api对象收集路径信息，api绑定的哪个对象，收集到的路径信息就传给哪个对象
12
user_api.add_resource(UserProfileResource, '/user/profile')
13
# 9蓝图对象注册到全局app
14
app.register_blueprint(user_bp)

给类视图加装饰器#

1
# 10给不同的请求方法加不同的装饰器，写在后面的装饰器会先被调用
2
# 首先创建装饰器
3
def decorator1(func):
4
    def wrapper(*args, **kwargs):
5
        print('call decorator1')
6
        return func(*args, **kwargs)
7
    return wrapper
8

9
def decorator2(func):
10
    def wrapper(*args, **kwargs):
11
        print('call decorator2')
12
        return func(*args, **kwargs)
13
    return wrapper
14
# 11创建装饰器类
15
class DemoResource(Resource):
16
    method_decorators = {
17
        'get': [decorator1, decorator2],
18
        'post': [decorator1]
19
    }
20
    # 使用了[decorator1, decorator2]两个装饰器
21
    def get(self):
22
        return {'msg': 'get view'}
23
    # 使用了[decorator1]装饰器
24
    def post(self):
25
        return {'msg': 'post view'}
26
    # 未使用装饰器
27
    def put(self):
28
        return {'msg': 'put view'}
29
# 12把类视图注册到路由
30
api.add_resource(DemoResource, '/DemoResource')

关于请求处理参数#

1
# 13使用RequestParser进行校验
2
# 导包
3
from flask_restful.reqparse import RequestParser
4
# 创建视图类
5
class RequestParserDemo(Resource):
6
    def get(self):
7
        # 创建RequestParser类对象
8
        request_parser = RequestParser()
9
        # 声明参数
10
        request_parser.add_argument('a')
11
        request_parser.add_argument('b')
12
        # 执行校验
13
        request = request_parser.parse_args()
14
        # 可以把request当做字典，也可以当做对象
15
        # a = request['a']
16
        a = request.a
17
        return {'a': a}
18
# 14把类视图注册到路由
19
api.add_resource(RequestParserDemo, '/RequestParserDemo')

有四个字段

例如：

1
request_parser.add_argument('b', type=int, required=True, help='missing b', action='append')

1 required#

请求是否一定要携带参数，默认为false

2 help#

参数检验错误时返回到错误描述信息

3 action#

对于请求参数中出现多个同名参数时的处理方式

action=‘store’保留出现的第一个，默认

action=‘append’以列表追加保存所有同名参数的值

4 type#

描述参数应该匹配的类型

有三种可以匹配的类型

1、Python标准类型

2、Flask-RESTful提供的类型（检验类型方法在flask_restful.inputs模块中）

regex（指定正则表达式）

1
from flask_restful import inputs
2
request_parser.add_argument('a', type=inputs.regex(r'^\d{2}&'))

natural：自然数0、1、2、3..
positive：正整数1、2、3..

int_range(low, high)：整数范围

1
from flask_restful import inputs
2
request_parser.add_argument('a', type=input.int_range(1, 10))

boolean

3、自定义

5 location#

描述参数应该在请求数据中出现的位置

也可指明多个位置

1
request_parser.add_argument('text', location=['headers', 'json'])

关于响应#

1
# 15处理响应
2
# 导包
3
from flask_restful import fields, marshal_with, marshal
4
# 编写用户类
5
class User(object):
6
    def __inti__(self, user_id, name, age):
7
        self.user_id = user_id
8
        self.name = name
9
        self.age = age
10
# 声明需要序列化处理的字段
11
resource_fields = {
12
    'user_id': fields.Integer,
13
    'name': fields.String
14
}
15
# 编写视图类
16
class Demo1marshal(Resource):
17
    @marshal_with(resource_fields, envelope='data1')
18
    def get(self):
19
        user = User(1, 'itcast', 12)
20
        return user
21
class Demo2marshal(Resource):
22
    def get(self):
23
        user = User(1, 'itcast', 12)
24
        return marshal(user, resource_fields, envelope='data2')
25
# 把视图类注册到路由的api
26
api.add_resource(Demo1marshal, '/demo1marshal')
27
api.add_resource(Demo2marshal, '/demo2marshal')