01-Flask 基础

1、Flask 简介

Flask 是一个基于 Python 开发的，依赖 Jinja2 模板和 Werkzeug WSGI 服务的一个微型框架。

Werkzeug 本质是 Socket 服务端，其用于接收 HTTP 请求并对请求进行预处理，然后触发 Flask 框架，开发人员基于 Flask 框架提供的功能对请求进行相应的处理，并返回给用户，如果要返回给用户复杂的内容时，需要借助 Jinja2 模板来实现对模板的处理，即：将模板和数据进行渲染，将渲染后的字符串返回给用户浏览器。

“微”(micro) 并不表示你需要把整个 Web 应用塞进单个 Python 文件（虽然确实可以），也不意味着 Flask 在功能上有所欠缺。微框架中的“微”意味着 Flask 旨在保持核心简单而易于扩展。Flask 不会替你做出太多决策——比如使用何种数据库。而那些 Flask 所选择的——比如使用何种模板引擎——则很容易替换。除此之外的一切都由可由你掌握。如此，Flask 可以与您珠联璧合。

默认情况下，Flask 不包含数据库抽象层、表单验证，或是其它任何已有多种库可以胜任的功能。然而，Flask 支持用扩展来给应用添加这些功能，如同是 Flask 本身实现的一样。众多的扩展提供了数据库集成、表单验证、上传处理、各种各样的开放认证技术等功能。Flask 也许是“微小”的，但它已准备好在需求繁杂的生产环境中投入使用。

11、Flask 安装

1
pip3 install flask

1.2、基本使用

1
2
3
4
5
6
7
8
9
10
from flask import Flask
 
app = Flask(__name__)
 
@app.route('/')
def hello_world():
    return 'Hello World!'
 
if __name__ == '__main__':
    app.run()

2、配置文件

Flask 中的配置文件是一个 flask.config.Config 对象（继承字典），默认配置为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
{
    'DEBUG':                                get_debug_flag(default=False),  # 是否开启 Debug 模式
    'TESTING':                              False,                          # 是否开启 测试  模式
    'PROPAGATE_EXCEPTIONS':                 None,                          
    'PRESERVE_CONTEXT_ON_EXCEPTION':        None,
    'SECRET_KEY':                           None,
    'PERMANENT_SESSION_LIFETIME':           timedelta(days=31),
    'USE_X_SENDFILE':                       False,
    'LOGGER_NAME':                          None,
    'LOGGER_HANDLER_POLICY':               'always',
    'SERVER_NAME':                          None,
    'APPLICATION_ROOT':                     None,
    'SESSION_COOKIE_NAME':                  'session',
    'SESSION_COOKIE_DOMAIN':                None,
    'SESSION_COOKIE_PATH':                  None,
    'SESSION_COOKIE_HTTPONLY':              True,
    'SESSION_COOKIE_SECURE':                False,
    'SESSION_REFRESH_EACH_REQUEST':         True,
    'MAX_CONTENT_LENGTH':                   None,
    'SEND_FILE_MAX_AGE_DEFAULT':            timedelta(hours=12),
    'TRAP_BAD_REQUEST_ERRORS':              False,
    'TRAP_HTTP_EXCEPTIONS':                 False,
    'EXPLAIN_TEMPLATE_LOADING':             False,
    'PREFERRED_URL_SCHEME':                 'http',
    'JSON_AS_ASCII':                        True,
    'JSON_SORT_KEYS':                       True,
    'JSONIFY_PRETTYPRINT_REGULAR':          True,
    'JSONIFY_MIMETYPE':                     'application/json',
    'TEMPLATES_AUTO_RELOAD':                None,
}

修改 Flask 配置有多种方式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
方式一：
    app.config['DEBUG'] = True
    PS： 由于Config对象本质上是字典，所以还可以使用app.config.update(...)
 
 
方式二：
    1、app.config.from_pyfile("python文件名称")
    如：
        settings.py
            DEBUG = True
        app.config.from_pyfile("settings.py")
 
    2、app.config.from_envvar("环境变量名称")
        环境变量的值为python文件名称名称，内部调用from_pyfile方法
 
    3、app.config.from_json("json文件名称")
        JSON文件名称，必须是json格式，因为内部会执行json.loads
 
    4、app.config.from_mapping({'DEBUG':True})
        字典格式
 
    5、app.config.from_object("python类或类的路径")  # 从sys.path中已经存在路径开始写
    举例：
        app.config.from_object('pro_flask.settings.TestingConfig')
        settings.py
            class Config(object):
                DEBUG = False
                TESTING = False
                DATABASE_URI = 'sqlite://:memory:'
 
            class ProductionConfig(Config):
                DATABASE_URI = 'mysql://user@localhost/foo'
 
            class DevelopmentConfig(Config):
                DEBUG = True
 
            class TestingConfig(Config):
                TESTING = True
 
    PS: settings.py文件默认路径要放在程序root_path目录，如果instance_relative_config为True，则就是instance_path目录

3、路由系统

  • @app.route('/user/<username>') # 只有名字
  • @app.route('/post/<int:post\_id>') # int 类型
  • @app.route('/post/<float:post\_id>') # float类型
  • @app.route('/post/<path:path>')
  • @app.route('/login', methods=['GET', 'POST'])

常用路由系统有以上五种，所有的路由系统都是基于以下对应关系来处理：

1
2
3
4
5
6
7
8
9
DEFAULT_CONVERTERS = {
    'default':          UnicodeConverter,
    'string':           UnicodeConverter,
    'any':              AnyConverter,
    'path':             PathConverter,
    'int':              IntegerConverter,
    'float':            FloatConverter,
    'uuid':             UUIDConverter,
}

注册路由方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
from flask import Flask
 
app = Flask(__name__)


#################### 第一种 ####################
def auth(func):
    def inner(*args, **kwargs):
        print('before')
        result = func(*args, **kwargs)
        print('after')
        return result
    return inner
 
 
@app.route('/index.html',methods=['GET','POST'],endpoint='index_1') # endpoint 不写默认为函数名 
@auth
def index_1():
    return 'Index'
 
 
#################### 第二种 ####################    
def index():
    return "Index"
app.add_url_rule(rule='/index.html', endpoint="index", view_func=index, methods=["GET","POST"])
# or
app.add_url_rule(rule='/index.html', endpoint="index", view_func=index, methods=["GET","POST"])
app.view_functions['index'] = index
 
 
#################### 第三种，CBV ####################
def auth(func):
    def inner(*args, **kwargs):
        print('before')
        result = func(*args, **kwargs)
        print('after')
        return result
    return inner
 
class IndexView(views.View):
    methods = ['GET']       # 允许的method
    decorators = [auth, ]   # 装饰器
    def dispatch_request(self):
        print('Index')
        return 'Index!'
app.add_url_rule('/index', view_func=IndexView.as_view(name='index'))  # name=endpoint
 
 
#################### 第四种 ####################
class IndexView(views.MethodView):
    methods = ['GET']
    decorators = [auth, ]
    def get(self):
        return 'Index.GET'
    def post(self):
        return 'Index.POST'
 
app.add_url_rule('/index', view_func=IndexView.as_view(name='index'))  # name=endpoint

@app.route 和 app.add_url_rule 参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
@app.route和app.add_url_rule参数:
    rule,                       # URL规则
    view_func,                  # 视图函数名称
    defaults=None,              # 默认值,当URL中无参数，函数需要参数时，使用defaults={'k':'v'}为函数提供参数
    endpoint=None,              # 名称，用于反向生成URL，即： url_for('名称')
    methods=None,               # 允许的请求方式，如：["GET","POST"]       
    strict_slashes=None,        # 对URL最后的 / 符号是否严格要求，如：
        @app.route('/index',strict_slashes=False)  # 访问 www.xx.com/index/ 或 www.xx.com/index均可
        @app.route('/index',strict_slashes=True)   # 仅访问 http://www.xx.com/index 
     
    redirect_to=None,           # 重定向到指定地址，如：
        @app.route('/index/<int:nid>', redirect_to='/home/<nid>')  # 可以是地址
 
        def func(adapter, nid):
            return "/home/888"
        @app.route('/index/<int:nid>', redirect_to=func)   # 也可以是函数
 
    subdomain=None,             # 子域名访问
        from flask import Flask, views, url_for
        app = Flask(import_name=__name__)
        app.config['SERVER_NAME'] = 'flepeng.com:5000'
 
        @app.route("/", subdomain="admin")  # 访问的是admin.flepeng.com:5000
        def static_index():
            """Flask supports static subdomains
            This is available at static.your-domain.tld"""
            return "static.your-domain.tld"
 
        @app.route("/dynamic", subdomain="<username>") # 访问的是xxx.flepeng.com:5000
        def username_index(username):
            """Dynamic subdomains are also supported
            Try going to user1.your-domain.tld/dynamic"""
            return username + ".your-domain.tld"
 
        if __name__ == '__main__':
            app.run()

自定制路由匹配规则

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
from flask import Flask, views, url_for
from werkzeug.routing import BaseConverter
 
app = Flask(import_name=__name__)
 
class RegexConverter(BaseConverter):
    """
    自定义URL匹配正则表达式
    """
    def __init__(self, map, regex):
        super(RegexConverter, self).__init__(map)
        self.regex = regex
 
    def to_python(self, value):
        """
        路由匹配时，匹配成功后传递给视图函数中参数的值
        """
        return int(value)
 
    def to_url(self, value):
        """
        使用url_for反向生成URL时，传递的参数经过该方法处理，返回的值用于生成URL中的参数
        """
        val = super(RegexConverter, self).to_url(value)
        return val
 
 
# 添加到flask中
app.url_map.converters['regex'] = RegexConverter
 
@app.route('/index/<regex("\d+"):nid>')
def index(nid):
    print(url_for('index', nid='888'))
    return 'Index'
 
if __name__ == '__main__':
    app.run()

4、模板

4.1、模板的使用

Flask 使用的是 Jinja2 模板，所以其语法和 Django 无差别，但是 Flask 的模板支持的语法更贴近 Python，支持函数等

4.2、自定义模板方法

Flask 中自定义模板方法的方式和 Bottle 相似，创建一个函数并通过参数的形式传入 render_template，如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
############### html文件 #####################
<!DOCTYPE html>
<html>
<head lang="en">
    <meta charset="UTF-8">
    <title></title>
</head>
<body>
    <h1>自定义函数</h1>
    {{ww()|safe}}
</body>
</html>
 
 
############### run.py #####################
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from flask import Flask,render_template
app = Flask(__name__)
 
def index():
    return '<h1>index</h1>'
 
@app.route('/login', methods=['GET', 'POST'])
def login():
    return render_template('login.html', ww=index)
 
app.run()
 
 
############### 其他 html文件 #####################
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    {% macro input(name, type='text', value='') %}
        <input type="{{ type }}" name="{{ name }}" value="{{ value }}">
    {% endmacro %}
 
    {{ input('n1') }}
    {% include 'tp.html' %}
    <h1>asdf{{ v.k1}}</h1>
</body>
</html>

注意：Markup 等价 Django 的 mark_safe

5、请求和响应

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
from flask import Flask
from flask import request
from flask import render_template
from flask import redirect
from flask import make_response
 
app = Flask(__name__)
 
@app.route('/login.html', methods=['GET', "POST"])
def login():
    # 请求相关信息 
    # request.url          http://127.0.0.1/console/editor
    # request.base_url     http://127.0.0.1/console/editor
    # request.url_root     http://127.0.0.1
    # request.host_url     http://127.0.0.1
    # request.host         127.0.0.1
    # request.files
    # f = request.files.get['file_name']   file_name为form表单的name值
    # f.save('/var/www/uploads/' + secure_filename(f.filename))  secure_filename：检测中文是否合法,f.save会直接保存
    
    # 响应相关信息
    # return "字符串"
    # return render_template('html模板路径',**{})
    # return redirect('/index.html')
 
    # 自定义响应头
    # response = make_response(render_template('index.html'))  # response是flask.wrappers.Response类型
    # response.delete_cookie('key')                    # 删
    # response.set_cookie('key', 'value')              # 设置cookie
    # response.headers['X-Something'] = 'A value'      # 设置响应头
    # return response
 
    return "内容"
if __name__ == '__main__':
    app.run()

request 属性 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
form        一个从POST和PUT请求解析的 MultiDict（一键多值字典）。
args        MultiDict，要操作 URL （如 ?key=value ）中提交的参数可以使用 args 属性:
                searchword = request.args.get('key', '')
values      CombinedMultiDict，内容是form和args。 可以使用values替代form和args。
cookies     请求的cookies，类型是dict。
stream      在可知的mimetype下，如果进来的表单数据无法解码，会没有任何改动的保存到这个 stream 以供使用。很多时候，当请求的数据转换为string时，使用data是最好的方式。这个stream只返回数据一次。
headers     请求头，字典类型。
data        包含了请求的数据，并转换为字符串，除非是一个Flask无法处理的mimetype。
files       MultiDict，带有通过POST或PUT请求上传的文件。
environ     WSGI隐含的环境配置。
method      请求方法，比如POST、GET。
path        获取请求文件路径：/myapplication/page.html
full_path   获取请求文件路径,包括args数据：/myapplication/page.html?k=v
script_root 
base_url    获取域名与请求文件路径：http://www.baidu.com/myapplication/page.html
url         获取全部url：http://www.baidu.com/myapplication/page.html?id=1&edit=edit
url_root    获取域名：http://www.baidu.com/
is_xhr      如果请求是一个来自JavaScript XMLHttpRequest的触发，则返回True，这个只工作在支持X-Requested-With头的库并且设置了XMLHttpRequest。
blueprint   蓝图名字。
endpoint    endpoint匹配请求，这个与view_args相结合，可是用于重构相同或修改URL。当匹配的时候发生异常，会返回None。
json        如果mimetype是application/json，这个参数将会解析JSON数据，如果不是则返回None。 
可以使用这个替代get_json()方法。
max_content_length          只读，返回MAX_CONTENT_LENGTH的配置键。
module                      如果请求是发送到一个实际的模块，则该参数返回当前模块的名称。这是弃用的功能，使用blueprints替代。
routing_exception = None    如果匹配URL失败，这个异常将会/已经抛出作为请求处理的一部分。这通常用于NotFound异常或类似的情况。
url_rule = None             内部规则匹配请求的URL。这可用于在URL之前/之后检查方法是否允许(request.url_rule.methods) 等等。 
                            默认情况下，在处理请求函数中写下 print('request.url_rule.methods', request.url_rule.methods) 
                            会打印：request.url_rule.methods {‘GET’, ‘OPTIONS’, ‘HEAD’}
view_args = None            一个匹配请求的view参数的字典，当匹配的时候发生异常，会返回None。
其他方法
get_json(force=False, silent=False, cache=True)
on_json_loading_failed(e)

6、Session

除请求对象之外，还有一个 session 对象。它允许你在不同请求间存储特定用户的信息。它是在 Cookies 的基础上实现的，并且对 Cookies 进行密钥签名要使用会话，你需要设置一个密钥。app.secret_key = 'A0Zr98j/3yX R~XHH!jmN\]LWX/,?RT'

  • 设置：session['username'] ＝ 'xxx'
  • 删除：session.pop('username', None)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
from flask import Flask, session, redirect, url_for, escape, request
 
app = Flask(__name__)
 
@app.route('/')
def index():
    if 'username' in session:
        return 'Logged in as %s' % escape(session['username'])
    return 'You are not logged in'
 
@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        session['username'] = request.form['username']
        return redirect(url_for('index'))
    return '''
        <form action="" method="post">
            <p><input type=text name=username>
            <p><input type=submit value=Login>
        </form>
    '''
 
@app.route('/logout')
def logout():
    # remove the username from the session if it's there
    session.pop('username', None)
    return redirect(url_for('index'))
 
# set the secret key.  keep this really secret:
app.secret_key = 'A0Zr98j/3yX R~XHH!jmN]LWX/,?RT'

可以通过重写 open-session 和 save-session 方法，让 session 存储在内存中或者 Redis 中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
############################# run.py #########################################
from flask import Flask
from flask import session
from pro_flask.utils.session import MySessionInterface
app = Flask(__name__)
 
app.secret_key = 'A0Zr98j/3yX R~XHH!jmN]LWX/,?RT'
app.session_interface = MySessionInterface()
@app.route('/login.html', methods=['GET', "POST"])
def login():
    print(session)
    session['user1'] = 'alex'
    session['user2'] = 'alex'
    del session['user2']
 
    return "内容"
 
if __name__ == '__main__':
    app.run()
 
 
############################ session.py ######################
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import uuid
import json
from flask.sessions import SessionInterface
from flask.sessions import SessionMixin
from itsdangerous import Signer, BadSignature, want_bytes
 
class MySession(dict, SessionMixin):
    def __init__(self, initial=None, sid=None):
        self.sid = sid
        self.initial = initial
        super(MySession, self).__init__(initial or ())
 
    def __setitem__(self, key, value):
        super(MySession, self).__setitem__(key, value)
 
    def __getitem__(self, item):
        return super(MySession, self).__getitem__(item)
 
    def __delitem__(self, key):
        super(MySession, self).__delitem__(key)
 
 
class MySessionInterface(SessionInterface):
    session_class = MySession
    container = {}
 
    def __init__(self):
        import redis
        self.redis = redis.Redis()
 
    def _generate_sid(self):
        return str(uuid.uuid4())
 
    def _get_signer(self, app):
        if not app.secret_key:
            return None
        return Signer(app.secret_key, salt='flask-session',key_derivation='hmac')
 
    def open_session(self, app, request):
        """程序刚启动时执行，需要返回一个session对象"""
        sid = request.cookies.get(app.session_cookie_name)   # 在cookie中通过配置的name获取session
        if not sid:
            sid = self._generate_sid()
            return self.session_class(sid=sid)
 
        signer = self._get_signer(app)
        try:
            sid_as_bytes = signer.unsign(sid)                # 解密，反序列化
            sid = sid_as_bytes.decode()
        except BadSignature:
            sid = self._generate_sid()
            return self.session_class(sid=sid)
 
        # val = self.redis.get(sid)    # session保存在redis中
        val = self.container.get(sid)  # session保存在内存中
 
        if val is not None:
            try:
                data = json.loads(val)
                return self.session_class(data, sid=sid)
            except:
                return self.session_class(sid=sid)
        return self.session_class(sid=sid)
 
    def save_session(self, app, session, response):
        """程序结束前执行，可以保存session中所有的值；如： 保存到resit，写入到用户cookie"""
        domain = self.get_cookie_domain(app)
        path = self.get_cookie_path(app)
        httponly = self.get_cookie_httponly(app)
        secure = self.get_cookie_secure(app)
        expires = self.get_expiration_time(app, session)
 
        val = json.dumps(dict(session))
 
        # self.redis.setex(name=session.sid, value=val, 
                           time=app.permanent_session_lifetime)  # session保存在redis中
        self.container.setdefault(session.sid, val)              # session保存在内存中
 
        session_id = self._get_signer(app).sign(want_bytes(session.sid))
 
        response.set_cookie(app.session_cookie_name, session_id,expires=expires, httponly=httponly,
                            domain=domain, path=path, secure=secure)

也可以使用第三方 session，让 session 存储在 Redis 中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#!/usr/bin/env python
# -*- coding:utf-8 -*-
"""
pip3 install redis
pip3 install flask-session
"""
 
 
from flask import Flask, session, redirect
from flask.ext.session import Session
 
 
app = Flask(__name__)
app.debug = True
app.secret_key = 'asdfasdfasd'
 
 
app.config['SESSION_TYPE'] = 'redis'
from redis import Redis
app.config['SESSION_REDIS'] = Redis(host='192.168.0.94',port='6379')
Session(app)
 
 
@app.route('/login')
def login():
    session['username'] = 'alex'
    return redirect('/index')
 
 
@app.route('/index')
def index():
    name = session['username']
    return name
 
 
if __name__ == '__main__':
    app.run()

七、蓝图

蓝图用于为应用提供目录划分：

小型应用程序：示例

大型应用程序：示例

其他：

  • 蓝图URL前缀：xxx = Blueprint('account', __name__,url_prefix='/xxx')
  • 蓝图子域名：xxx = Blueprint('account', __name__,subdomain='admin')
    • 前提需要给配置 SERVER_NAME：app.config['SERVER_NAME'] = 'flepeng.com:5000'
    • 访问时：admin.flepeng.com:5000/login.html
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
######################### count.py #################
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from flask import Blueprint
from flask import render_template
from flask import request
 
account = Blueprint('account', __name__)
 
 
@account.route('/login.html', methods=['GET', "POST"])
def login():
    return render_template('login.html')
######################### run.py #################
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from flask import Flask
 
app = Flask(__name__,template_folder='templates',static_folder='statics',static_url_path='/static')
 
from .views.account import account
from .views.blog import blog
from .views.user import user
 
app.register_blueprint(account)   # 注册
app.register_blueprint(blog)
app.register_blueprint(user)
 
if __name__ == '__main__':
    app.run

8、message（了解）

message 是一个基于 Session 实现的用于保存数据的集合，其特点是：使用一次就删除。又称闪现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
from flask import Flask, flash, redirect, render_template, request, get_flashed_messages
 
app = Flask(__name__)
app.secret_key = 'some_secret'
 
 
@app.route('/')
def index1():
    messages = get_flashed_messages()
    print(messages)
    return "Index1"
 
 
@app.route('/set')
def index2():
    v = request.args.get('p')
    flash(v)
    return 'ok'
 
 
if __name__ == "__main__":
    app.run()

9、中间件（了解）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
from flask import Flask, flash, redirect, render_template, request
 
app = Flask(__name__)
app.secret_key = 'some_secret'
 
@app.route('/')
def index1():
    return render_template('index.html')
 
@app.route('/set')
def index2():
    v = request.args.get('p')
    flash(v)
    return 'ok'
 
class MiddleWare:
    def __init__(self,wsgi_app):
        self.wsgi_app = wsgi_app
 
    def __call__(self, *args, **kwargs):
        return self.wsgi_app(*args, **kwargs)
 
if __name__ == "__main__":
    app.wsgi_app = MiddleWare(app.wsgi_app)
    app.run(port=9999)

10、请求扩展

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from flask import Flask, Request, render_template
 
app = Flask(__name__, template_folder='templates')
app.debug = True
 
 
@app.before_first_request     # 只有第一次请求时，会调用，按注册顺序依次执行
def before_first_request1():
    print('before_first_request1')
 
 
@app.before_first_request     # 只有第一次请求时，会调用
def before_first_request2():
    print('before_first_request2')
 
 
@app.before_request           # 请求之前的处理，按照注册的顺序依次执行，若果有return，则直接返回，返回时经过所有after_request
def before_request1():
    Request.nnn = 123
    print('before_request1')
 
 
@app.before_request
def before_request2():
    print('before_request2')
 
 
@app.after_request            # 请求完成之后的处理，按照注册的逆序依次执行
def after_request1(response):
    print('before_request1', response)
    return response
 
 
@app.after_request
def after_request2(response):
    print('before_request2', response)
    return response
 
 
@app.errorhandler(404)         # 当发生错误时执行，比如404错误
def page_not_found(error):
    return 'This page does not exist', 404
 
 
@app.context_processor         # 为所有的模板传递的函数，调用方式：{{ val_1 }} 仿佛是 Jinja2 内置的变量一样
def template_var():
    return {'val_1':'10'}
 
 
@app.template_global()         # 为所有的模板传递的函数，调用方式：{{ my_fun(1,2) }} 
def my_fun(a1, a2):
    return a1 + a2
 
 
@app.template_filter()         # 为所有的模板传递的函数，调用方式{{ 1|db(2,3)}}
def db(a1, a2, a3):
    return a1 + a2 + a3
 
 
@app.route('/')
def hello_world():
    return render_template('hello.html')
 
 
if __name__ == '__main__':
    app.run()

11、Flask插件

  • WTForms
  • SQLAchemy
  • Flask-session
  • 等…
Python > Flask
#Python #Flask
01-Flask 基础
https://flepeng.github.io/021-Python-32-框架-Flask-01-Flask-基础/
作者
Lepeng
发布于
2021年3月31日
许可协议