从0到1，Flask全网最全教学！全文1w字，蓝图、会话、日志、部署等使用Flask搭建中小型企业级项目

原创

小羽网安

发布于 2024-06-27 13:01:13

4490

发布于 2024-06-27 13:01:13

文章被收录于专栏：编程

从0到1，Flask全网最全教学！全文1w字，蓝图、会话、日志、部署等使用Flask搭建中小型企业级项目

什么是flask？

Flask是一个使用Python编写的轻量级Web应用框架，它简洁而灵活，适用于开发小型至中型的Web应用。本文将介绍Flask框架的基本概念、特点以及如何使用Flask来快速搭建Web应用，争取在两周内，介绍一篇企业级响应速度的轻量级python Web框架sanic和异步数据库SQLAlchemy。

2024年6月27日找工作日记，21岁，简历--》https://xiaoyus.cc/index.php/sample-page/

优点

轻量级：框架本身轻量，但支持使用扩展构建复杂的应用。
灵活性：提供更大的灵活性，开发者可以根据项目需求选择使用的组件。
RESTful可请求调度、Jinja2模板、支持安全cookie（客户端会话）、符合WSGI 1.0

缺点

缺少一些内置功能：相对于Django，一些功能需要通过扩展实现。
适用于中小型项目：对于大型企业级应用，可能需要更多的手动配置。
在异步请求响应速度方面，没有sanic好

安装 Flask

在已激活的虚拟环境中可以使用如下命令安装 Flask：

pip install Flask

1、创建第一个视图函数

# 导入flask类
from flask import Flask
# 初始化
app = Flask(__name__)
# 使用route()装饰器来告诉Flask触发函数的URL。
@app.route('/')
def index():
    return 'Hello World!'

Tips：你创建的第一个flask-py文件不能为flask.py，这会与flask本身发生冲突。

启动

可以使用flask命令或者python -m flask来运行这个应用。你需要使用--app选项告诉flask 你的应用名称是什么

flask --app main run

Tips：如果文件名为 app.py 或者 wsgi.py ，那么就不需要使用 --app

出现了这个错误警告，跳过就好，不影响falsk运行，错误原因是因为在开发环境中，Flask应用程序是使用内置的服务器（如SimpleServer或Lighttpd）运行的，而不是使用WSGI服务器。

好啦，打开我们的蓝色链接，我们第一个flask程序就写好了

外部服务器（--host）

运行服务的时候，只能本地访问，而网络中的其他电脑却访问不了。缺省（默认）设置就是这样的，我们可以加上--host=0.0.0.0

flask --app main run --host=0.0.0.0

这时候多了一条外网地址，我们使用虚拟机访问一下，访问成功！

调试模式（ --debug）

flask --app main run --host=0.0.0.0 --debug

HTML 转义

当返回 HTML （ Flask 中的默认响应类型）时，为了防止注入攻击，所有用户提供的值在输出渲染前必须被转义。使用Jinja（这个稍后会介绍）渲染的 HTML 模板会自动执行此操作。

from markupsafe import escape

@app.route("/<name>")# 路由中的 <name> 从 URL 中捕获值并将其传递给视图函数。
def hello(name):
    return f"Hello, {escape(name)}!" #  escape() 可以手动转义.

那么如果一个用户想要提交其名称为 <script>alert("bad")</script> ，escape就会转义为文本，预防XSS攻击。

XSS攻击详见https://mp.weixin.qq.com/s/RJcOZuscU07BEPgK89LSrQ

路由

现代 web 应用都使用有意义的 URL ，这样有助于用户记忆，网页会更得到用户的青睐，提高回头率。

使用 route() 装饰器来把函数绑定到 URL:

@app.route('/')
def index():
    return '登录页面'

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

# 可以为一个函数指定多个规则
@app.route('/page1')
@app.route('/page2')
@app.route('/page3')
def page_handler():
    return 'This is a sample page.'

变量规则

通过把URL的一部分标记为<variable_name>就可以在URL中添加变量。标记的部分会作为关键字参数传递给函数。使用<converter:variable_name>，可以选择性的加上一个转换器，为变量指定规则

@app.route('/user/<username>')
def show_user_profile(username):
    return f'用户名： {escape(username)}'

@app.route('/get/<int:get_id>')
def show_post(get_id):
    return f'Get请求id： {get_id}'

@app.route('/path/<path:subpath>')
def show_subpath(subpath):
    return f'path {escape(subpath)}'

转换器类型	介绍
string	（缺省\|\|默认值）接受任何不包含斜杠的文本
int	接受正整数
float	接受正浮点数
path	类似 string ，但可以包含斜杠
uuid	接受 UUID 字符串

唯一的URL/重定向行为

@app.route('/projects/') # 这里有斜杠
def projects():
    return 'The project page'

@app.route('/about') # 这里没有斜杠
def about():
    return 'The about page'

projects 的 URL 是中规中矩的，尾部有一个斜杠，看起来就如同一个文件夹。访问一个没有斜杠结尾的 URL （ /projects ）时 Flask 会自动进行重定向，帮您在尾部加上一个斜杠（ /projects/ ），比如访问这个urlhttp://127.0.0.1:5000/projects会自动重定向到http://127.0.0.1:5000/projects/，俩者只有一个斜杠之分

但是，如果访问http://127.0.0.1:5000/about/about这个路由后面添加了一个斜杠，就会导致404

URL构建

url_for函数用于构建指定函数的URL。它把函数名称作为第一个参数。可以接受任意个关键字参数，每个关键参数对应url中的变量。未知变量将添加到URL中作为查询参数。

@app.route('/index/')
def index333():
    print(url_for('index333')) # /index/
    # 获取index333视图函数的路由，必须传值sid=xxx，则返回值 /index2/22/
    return url_for('index222',sid=22)

@app.route('/index2/<int:sid>/')
def index222(sid):
    # 获取index333视图函数的路由，并传值sid=sid，假设sid=234 则返回值 /index/?sid=234
    # 这里可以传任意值
    return url_for('index333',sid=sid)

@app.route('/')
def index():
    print(url_for('index')) # /
    print(url_for('login')) # /login
    
    return 'index' 

@app.route('/login')
def login():
    print(url_for('login')) # /login
    print(url_for('index')) # /
    print(url_for('profile', username='zhang san'))# /user/zhang%20san
    return 'login' 

@app.route('/user/<username>')
def profile(username):
    print(url_for('login', next='/')) # /login?next=/
    print(url_for('index')) # /
    print(url_for('profile', username='zhang san'))# /user/zhang%20san
    return f'{username}\'s profile'

为什么不在把 URL 写死在模板中，而要使用反转函数 url_for() 动态构建？

集中管理URL：通过反转URL，可以在单一位置修改URL，无需在代码库中四处搜寻，实现高效维护。 自动转义特殊字符：URL创建机制自动处理特殊字符的转义，确保URL的准确性，直观性和安全性。 生成绝对路径：使用URL生成器生成的路径始终是绝对路径，有效避免因相对路径引起的潜在问题。 适应子路径部署：当您的应用部署在URL的子路径下（例如部署在/myapplication而非根路径/），url_for()函数能够智能处理，确保URL的正确性。

HTTP方法

Web应用程序使用不同的HTTP方法处理URL。缺省情况下，一个路由只回应GET请求。可以使用route()装饰器的methods参数来处理不同的HTTP方法。

from flask import request
# 将所有函数都封装到同一个函数中，当每个方法都使用一些共同的数据时，这样是有用的
@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        return do_the_login()
    else:
        return show_the_login_form()
    
# 你也可以把不同方法对应的视图分别放在独立的函数中。
@app.get('/login')
def login_get():
    return show_the_login_form()

@app.post('/login')
def login_post():
    return do_the_login()

。。。@app.[其他方法]

静态文件

url_for('static', filename='style.css') # /static/style.css

渲染模板

直接在Python中编写HTML不仅麻烦，还容易忽视安全问题。Flask通过集成Jinja2，简化了HTML的生成，自动进行转义，让开发更安全、更高效。

多用途文本生成：模板技术不仅适用于创建HTML网页，同样能够用来生成包括Markdown、纯文本等在内的多种文本文件格式。
网页内容生成：在web应用开发中，模板引擎是生成HTML页面的关键工具，但它们的应用远不止于此。
扩展性：模板系统的设计使其能够轻松扩展到其他文本格式，如电子邮件所需的纯文本格式，提供灵活性。
多样化应用：模板的通用性使其成为处理不同文本输出需求的理想选择，无论是在线内容还是电子邮件通信。

Tips：flask会在templates文件夹内寻找模板。

情况一：一个模块 /application.py /templates /hello.html 情况二：一个包 /application /__init__.py /templates /hello.html

构造你的视图函数

@app.route('/')
def index():
    txt_h1='hellow'
    return render_template('index.html',txt_h1=txt_h1)

flask模板语法和django中的模板语法类似，使用模板语法

<!doctype html>
<html lang="en">
<head>
    <title>这是你的第一个模板html</title>
</head>
<body>
    <h1>{{ txt_h1 }}</h1>
    {% if txt_h1=='hellow' %}
    <h1>h1标题存在hellow</h1>
    {% else %}
    <h1>h1标题不存在hellow</h1>
    {% endif %}
</body>
</html>

在模板内部可以像使用 url_for() 和 get_flashed_messages() 函数一样访问 config 、 request 、 session 和 g对象，自动转义缺省开启，确保安全性，如果 name 包含 HTML ，那么会被自动转义。如果您可以信任某个变量，且知道它是安全的 HTML （例如变量来自一个把 wiki 标记转换为 HTML 的模块），那么可以使用 Markup 类把它标记为安全的，或者在模板中使用 |safe 过滤器，例如

@app.route('/')
def index():
    txt_h1='<a href="https://xiaoyus.cc">我的主页</a>'
    return render_template('index.html',txt_h1=txt_h1)

使用Markup

from markupsafe import Markup

@app.route('/')
def index():
    txt_h1='<a href="https://xiaoyus.cc">我的主页</a>'
    txt_h1=Markup(txt_h1) # 使用 Markup 类把它标记为安全的
    return render_template('index.html',txt_h1=txt_h1)

使用 | safe

<body>
    <h1>{{ txt_h1 | safe }}</h1><!--将txt_h1变量标记为安全-->
    {% if txt_h1=='hellow' %}
    <h1>h1标题存在hellow</h1>
    {% else %}
    <h1>h1标题不存在hellow</h1>
    {% endif %}
</body>

操作请求数据

在Flask中，全局对象request确实提供了客户端的请求信息，但可能让人疑惑的是，它如何保证在多线程环境下的线程安全。Flask通过使用本地环境（Local Environment）来解决这个问题。每个线程都拥有自己的本地环境，这意味着每个线程的request对象是独立的，不会与其他线程的request对象冲突。这样，即使在多线程环境下，每个请求也能安全地处理，而不会相互干扰。

本地环境

Flask中有些对象看似全局，实则不然。它们是本地对象的代理，意味着每个线程有自己的版本，从而保证了线程安全。这在单元测试时特别有用，因为测试时可能没有真正的请求对象。

要解决这个问题，你可以手动创建一个请求对象。Flask提供了test_request_context()，一个方便的环境管理器，让你可以在测试代码中模拟请求。使用它，你可以这样写：

from flask import Flask, request

app = Flask(__name__)

with app.test_request_context('/hello', method='POST'):
    # 在这个区块内，你可以像处理真实请求一样使用request对象
    assert request.path == '/hello'
    assert request.method == 'POST'

如果需要模拟更完整的环境，比如整个WSGI环境，可以使用request_context()，传入环境变量即可：

with app.request_context(environ):
    # 这里可以进行更复杂的测试
    assert request.method == 'POST'

简而言之，Flask让你即使在没有真实请求的情况下，也能轻松测试依赖于请求对象的代码。

请求对象

导入flask的request包

from flask import request

通过使用method方法，处理当前请求方式

@app.route('/',methods=['GET','POST'])
def index():
    if request.method == 'GET':
        txt_h1='这是GET请求'
    elif request.method =="POST" :
        txt_h1='这是post请求'
    else:
        txt_h1='这是不支持的请求'

通过使用form方法，处理获取的请求方式数据

@app.route('/',methods=['GET','POST'])
def index():
    if request.method == 'POST':
        username= request.form['username'] # 获取post表单的username数据
        password= request.form['password'] # 获取post表单的password
        return (f'<script>alert("账号：{username}，'
                f'密码：{password}")</script>')
    # txt_h1=Markup(txt_h1)
    return render_template('index.html')

这是你的html表单

<form action="/" method="post">
    <input name="username" ><br>
    <input name="password" ><br>
    <button>登录</button>
</form>

操作URL获取参数比如https://127.0.0.1/index/?page=1 如何取得这个page参数

searchword = request.args.get('page', '') # 后面的''表示默认为空，这样渲染模板的时候就不会有NULL字样显示了

其他方法参考官方文档或者直接查看源代码

文件上传

使用Flask上传文件时，确保HTML表单包含enctype="multipart/form-data"，否则文件无法上传，一个简单案例

@app.route('/upload', methods=['GET', 'POST'])
def upload_file():
    if request.method == 'POST':
        f = request.files['file']
        f.save('upload/uploaded_file.jpg')
    return render_template('index.html')

html

<form action="/upload" method="post" enctype="multipart/form-data">
    <input name="file" type="file" >
    <button>上传文件</button>
</form>

如果想要把客户端的文件名作为服务器上的文件名，可以通过 Werkzeug 提供的 secure_filename() 函数:

@app.route('/upload', methods=['GET', 'POST'])
def upload_file():
    if request.method == 'POST':
        f = request.files['file']
        f.save(f'upload/{secure_filename}')
    return render_template('index.html')

Cookies

访问 cookies ，可以使用 request的cookies 属性。


from flask import request

@app.route('/')
def index():
    # 读取 cookies
    username = request.cookies.get('username')
    # 储存 cookies
    resp = make_response(render_template(...))
    resp.set_cookie('username', 'the username')
    return resp

打开浏览器f12，找到网络中的包即可查看

重定向和错误

使用redirect()可以重定向。使用abort()可以更早退出请求，并且返回错误代码：

from flask import abort, redirect, url_for

@app.route('/')
def index():
    return redirect(url_for('login'))  # 使用redirect()重定向
    
@app.route('/login')
def login():
    abort(401)  # 后面的代码将不会运行，直接返回401状态码
    return 'test'

让一个用户从索引页重定向到一个无法访问的页面（401 表示禁止访问）。上例可以说明重定向和出错跳出是如何工作的。

自定义请求状态页面

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

关于响应

在Flask中，视图函数的返回值会直接生成响应对象。若返回字符串，Flask将其转换为响应体，附带200 OK状态码和text/html内容类型。若返回字典或列表，Flask自动调用jsonify()，生成JSON格式的响应。这是Flask处理响应的基本规则。

直接响应：若视图函数返回的是一个Response对象，Flask将直接使用该对象作为HTTP响应返回给客户端。
字符串转换：若返回值是字符串，Flask会将其作为响应体内容，并结合默认参数创建一个响应对象返回。 @app.route('/') def index(): return "<h1>这是一个响应体内容，会解析html</h1>"
流式响应：如果视图函数返回的是迭代器或生成器，Flask将按流式响应处理，这意味着响应体内容将逐步发送给客户端。
JSON响应：对于字典或列表类型的返回值，Flask会通过jsonify()函数将它们转换为JSON格式的响应对象。 @app.route('/') def index(): return {'data':'this is index'}

元组处理：返回值若为元组，它应至少包含一个元素，并且可以提供额外的响应信息，如状态码或头部信息。元组的格式可以是(body, status)、(body, headers)或(body, status, headers)，其中status将覆盖默认的状态代码，headers则添加额外的响应头，一个简单的例子 @app.errorhandler(404) def errorPage(error): return 'sdfjlsdjf', 404 # 表示 ('sdfjlsdjf', 404)
WSGI应用：如果返回值不符合以上任何一种类型，Flask将尝试将返回值作为WSGI应用来处理，并将其转换为一个响应对象。

JSON格式的API

@app.route("/")
def me_api():
    user = get_user()
    return {
        "username": user.username,
        "pwd": user.pwd,
        "image": url_for("user_image", filename=user.image),
    }# 可以使用字典


@app.route("/user_data")
def users_api():
    users = get_user()
    return [user.to_json() for user in users] # 也可以使用列表字典

会话session

Session对象提供了跨请求存储信息的能力。它基于密钥签名的cookie实现，用户能够查看但无法修改，除非拥有相应的密钥。这确保了存储在session中的数据安全，防止了恶意篡改。所以在使用session之前必须设置一个密匙

from flask import session

# 设置你的密匙
app.secret_key = b'036421afea2dd14dd4016bf71304cc9b332e0a011895f38f07f62505fc41ca41'

@app.route('/')
def index():
    if 'username' in session:
        return f'Logged in as {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 method="post">
            <p><input type='text' name='username'>
            <p><input type='submit' value='Login'>
        </form>
    '''

@app.route('/logout')
def logout():
    # 删除用户名
    session.pop('username', None)
    return redirect(url_for('index'))

如果你不设置这个key也会报如下错误

可以在终端使用如下命令生成key

 python -c 'import secrets; print(secrets.token_hex())'
 '036421afea2dd14dd4016bf71304cc9b332e0a011895f38f07f62505fc41ca41'

Flask通过序列化会话对象的值并存储在cookie中来管理会话。如果请求中未能持续维护会话值，访问时可能失败且错误不明显。开发者应检查cookie大小是否符合浏览器限制。此外，Flask支持通过扩展实现的服务端会话，提供更高安全性，即使客户端禁用cookie也能维持会话状态。

CORS跨域

浏览器的同源策略（Same-Origin Policy）限制了跨域请求，如果不进行特殊处理，跨域请求将被浏览器拦截。

跨域请求提升了应用间的互操作性，尤其有利于前后端分离架构，允许独立开发和部署。但同时，它也可能引入XSS和CSRF等安全威胁，增加服务器负担，并可能因携带用户信息如cookies而泄露隐私。此外，预检请求可能导致网络延迟，影响性能。开发者需在实现时综合考虑安全性和性能，采取必要措施以保护数据和提升用户体验。

1、使用单个跨域在Flask框架中，@app.route装饰器用于定义路由，包括指定的URL路径和允许的HTTP请求方法。而@cross_origin装饰器则用于配置跨域资源共享（CORS），允许指定哪些域名可以访问该资源，以及允许使用哪些HTTP方法。

如果两个装饰器都指定了请求方法，它们的作用是不同的。@app.route的指定方法决定了哪些HTTP请求能够触发关联的视图函数。相比之下，@cross_origin中的请求方法设置只影响跨域请求的响应，例如，它决定了在预检请求（preflight request）中哪些方法可以被告知客户端是被允许的。

因此，即使两者都提到了请求方法，它们并不冲突，因为它们服务于不同的目的。@app.route确保了请求方法的匹配，而@cross_origin则处理了跨域请求的额外安全考量。开发者在使用时应确保两者的设置正确无误，以避免不必要的访问控制问题。

from flask import Flask
from flask_cors import CORS, cross_origin

app = Flask(__name__)

@app.route('/api/some_end', methods=['GET'])
@cross_origin(methods=['POST'])
def some_endpoint():
    if request.method == 'GET':
        # 处理GET请求
        return '这是 GET 请求!'
    elif request.method == 'POST':
        # 处理POST请求
        return '这是 POST 请求!'

2、使用全局跨域

Flask中，可以通过安装flask-cors扩展来支持跨域请求。

pip install flask-cors

导入将app加入即可

from flask import Flask
from flask_cors import CORS

app = Flask(__name__)
CORS(app) # 1. 指定所有域
# CORS(app, origins='http://example.com')# 2. 通过CORS扩展的origins参数来指定允许的来源

-----

日志

1、应用错误处理

应用程序在运行过程中难免会遇到错误，即使代码本身无懈可击。可能的原因包括客户端断开连接、数据库负载过高、存储空间不足、硬件故障、后台服务过载、依赖库存在缺陷或网络连接问题等。这些问题都是服务器运维中常见的挑战。

2、错误日志工具

嗯，这里介绍几个扩展Sentry Sentry 可以统计重复错误，捕获堆栈数据和本地变量用于排错，并在发生新的错误时或者按指定频度发送电子邮件。

pip install sentry-sdk[flask]

然后添加如下代码

import sentry_sdk
from sentry_sdk.integrations.flask import FlaskIntegration
# YOUR_DSN_HERE 需要被替换为在 Sentry 安装时获得的 DSN 值。
sentry_sdk.init('YOUR_DSN_HERE', integrations=[FlaskIntegration()])

安装好以后，内部服务出错信息会自动向 Sentry 报告，你会接收到出错通知。

3、默认日志logger类

下面是默认的日志系统logger类

app.logger.debug('一个调试器日志消息')
app.logger.warning('警告日志', 42)
app.logger.error('这是一个错误日志')

4、错误处理器

Flask通过HTTP状态码区分错误类型：400-499表示客户端错误，500-599表示服务器错误。

开发者可以通过注册错误处理器来自定义错误页面，这些处理器函数在特定错误发生时被调用，并返回个性化的响应。错误处理器接收一个HTTPException实例，但返回的响应状态码需手动设置。正确配置错误处理器，可以改善用户体验并提供调试信息。

5、注册出错处理器

通过使用errorhandler()装饰函数来注册或者稍后使用regist_error_handler()来注册。记得当返回响应的时候设置的状态码。

#使用errorhandler()装饰器来注册自定义错误页面
@app.route('/handle_exception')
@app.errorhandler(werkzeug.exceptions.BadRequest)
def handle_exception():
    return '这是一个自定义错误请求页面',502


#使用regist_error_handler()来注册
@app.route('/handle_exception')
def handle_exception():
    return '这是一个自定义错误请求页面，使用register_error_handler()注册的',502

app.register_error_handler(502,handle_exception)

在Flask中，werkzeug.exceptions.HTTPException及其子类如BadRequest（其代码为400）可被注册和抛出。对于非标准HTTP代码，Werkzeug无法直接识别，因此不应直接注册这些异常。正确的做法是定义一个带有合适HTTP代码的HTTPException子类，然后在应用中注册并使用这个自定义异常类。

class InsufficientStorage(werkzeug.exceptions.HTTPException):
    code = 507
    description = 'Not enough storage space.'
def handle_507():
    return '服务器内部错误',507

app.register_error_handler(InsufficientStorage, handle_507)
raise InsufficientStorage()

出错处理器可被用于任何异常类的注册，除了 HTTPException子类或者 HTTP 状态码。出错处理器可被用于特定类的注册，也可用于一个父类的所有子类的注册。

6、处理

在构建Flask应用时，您会遇到异常。如果在处理请求时（且没有注册错误处理器），你的代码中断了，那么默认返回”500内部服务器错误“（ InternalServerError）。同样，如果请求被发送到未注册的路由，则会产生”404未找到“（NotFound）错误。如果路由接收到被禁止请求方法，则会产生”405方法访问被禁止“（MethodNotAllowed）。Flask默认提供这些HTTPException

Flask 使您能够注册 Werkzeug 提供的任意 HTTP 异常。但是，默认的 HTTP 异常返回简单的异常页。您可能希望在发生错误时向用户显示自定义错误页面。可以通过注册错误处理器来完成。

7、通用异常处理器

可以为非常通用的基类注册异常处理器，例如HTTPException基类或者Exception基类。但是，请注意，这样会捕捉到超出你预期的异常。

基于 HTTPException 的异常处理器对于把缺省的 HTML 出错页面转换为 JSON 非常有用，但是这个处理器会触发不由你直接产生的东西，如路由过程中产生的 404 和 405 错误。请仔细制作你的处理器，确保不会丢失关于 HTTP 错误的信息。

from flask import json
from werkzeug.exceptions import HTTPException # 导入HTTPException
 
@app.errorhandler(HTTPException)
def handle_exception(e):
    """返回json，而不是html"""
    response = e.get_response()
    # 用json替换正文
    response.data = json.dumps({
        "code": e.code,
        "name": e.name,
        "description": e.description,
    })
    response.content_type = "application/json"
    return response

注意不能够这样写

# 注意这个返回结果是错误的，这里如果直接返回字典数据，并不会得到真实的状态码，而是200，他是一个请求数据
@app.errorhandler(HTTPException)
def handle_exception(e):
    response = e.get_response()
    return {
        "code": e.code,
        "name": e.name,
        "description": e.description,
    }

用于 Exception 的异常处理器有助于改变所有异常处理的表现形式，甚至包含未处理的异常。但是，与在 Python 使用 except Exception: 类似，这样会捕获所有未处理的异常，包括所有 HTTP 状态码。

因此，在大多数情况下，设定只针对特定异常的处理器比较安全。因为 HTTPException 实例是一个合法的 WSGI 响应，你可以直接传递该实例。

from werkzeug.exceptions import HTTPException

@app.errorhandler(Exception)
def handle_exception(e):
    # 跳过http异常
    if isinstance(e, HTTPException):
        return e

    # 只处理非http异常
    return render_template("500_generic.html", e=e), 500

异常处理器仍然遵循异常烦类的继承层次。如果同时基于 HTTPException 和 Exception 注册了异常处理器， Exception 处理器不会处理 HTTPException 子类，因为 HTTPException 更有针对性。

8、未处理的异常

当一个异常发生时，如果没有对应的异常处理器，那么就会返回一个500内部服务错误。

9、自定义错误页面

在Flask应用开发过程中，abort()函数是一个强大的工具，用于在检测到问题时立即终止请求并抛出一个HTTPException。这个函数不仅能够向用户明确地反馈错误，还能提供一个简洁的默认错误页面，帮助用户理解发生了什么。

例如，在处理用户配置文件的路由时，如果请求中缺少了用户名，我们可以使用abort(400)来告知用户请求不完整或格式错误。如果用户提供了用户名，但服务器上找不到对应的用户信息，我们则可以使用abort(404)来明确告知用户请求的资源不存在。

from flask import abort, render_template, request
from flask import render_template

@app.route("/profile")
def user_profile():
    username = request.arg.get("username")
    if username is None:
        abort(400) # 没有获取到username直接返回400状态码的，错误处理页面

    user = get_user(username=username)
    if user is None:
        abort(404) # 如果没有找到用户，就直接返回404页面

    return render_template("index.html", user=user)


@app.errorhandler(404)
def page_not_found(e):
    # 自定义错误页面
    return render_template('404.html'), 404

通过这种方式，abort()函数不仅帮助我们优雅地处理错误情况，还能够提供给用户清晰的反馈，增强了应用的用户体验和健壮性。此外，通过自定义错误处理函数，我们还可以进一步定制错误页面，提供更友好的错误信息和解决方案。

一个模板示例

{% extends "layout.html" %}
{% block title %}Page Not Found{% endblock %}
{% block body %}
  <h1>Page Not Found</h1>
  <p>What you were looking for is just not there.
  <p><a href="{{ url_for('index') }}">go somewhere nice</a>
{% endblock %}

10、将API错误作为JSON返回

from flask import abort, jsonify

@app.errorhandler(404)
def resource_not_found(e):
    return jsonify(error=str(e)), 404

@app.route("/cheese")
def get_one_cheese():
    resource = get_resource()

    if resource is None:
        abort(404, description="Resource not found")

    return jsonify(resource)

当然，还可以创建自定义异常类。

from flask import jsonify, request

#定义一个错误处理类，并继承Exception类
class InvalidAPIUsage(Exception):
    status_code = 400

    def __init__(self, message, status_code=None, payload=None):
        super().__init__()
        self.message = message
        if status_code is not None:
            self.status_code = status_code
        self.payload = payload

    def to_dict(self):
        rv = dict(self.payload or ())
        rv['message'] = self.message
        return rv

#使用错误处理装饰器
@app.errorhandler(InvalidAPIUsage)
def invalid_api_usage(e):
    # 将错误 e 转换为dict，再转为json数据，后面接的请求状态码
    return jsonify(e.to_dict()), e.status_code


# 获取用户信息的API应用路由#正确的请求是/api/user?user_id=420
@app.route("/api/user")
def user_api(user_id):
    user_id = request.arg.get("user_id")
    if not user_id:
        raise InvalidAPIUsage("没有该用户id")

    user = get_user(user_id=user_id)
    if not user:
        raise InvalidAPIUsage("没有该用户!", status_code=404)

    return jsonify(user.to_dict())

一个视图现在可以引发带有错误信息的异常。此外，一些额外的内容可以通过 payload 参数，以字典的方式提供。

集成WSGI中间件

如果想要在应用中添加一个 WSGI 中间件，那么可以用应用的 wsgi_app 属性来包装。例如，假设需要在 Nginx 后面使用 ProxyFix 中间件，那么可以这样做:

from werkzeug.middleware.proxy_fix import ProxyFix
app.wsgi_app = ProxyFix(app.wsgi_app)

用 app.wsgi_app 来包装，而不用 app 包装，意味着 app 仍旧指向您的 Flask 应用，而不是指向中间件。这样可以继续直接使用和配置 app 。

消息闪现

在Web应用中，向用户反馈操作结果很关键，通常通过网页上的文字提示实现，如确认信息、警告或错误提示。

在Flask中，使用flash message(闪现消息)，具体使用的方法是flash()

flash(message, category)# message: 具体的消息内容 。category: 可选参数，表示消息类型，比如错误、警告等

在视图函数中发送了消息，自然的，就需要在模板文件中取出消息，我们使用方法get_flashed_message

get_flashed_messages(with_categories, category_filter)

with_categories: 消息类型，与上面的flash匹配
category_filter: 过滤条件例如，

from flask import Flask, render_template, request, redirect, url_for, flash

app = Flask(__name__)
app.secret_key = "xxx"


@app.route('/')
def index():
    return render_template('index.html')


@app.route('/login', methods=['GET', 'POST'])
def login():
    error = None
    if request.method == "POST":
        if request.form['email'] != 'test@gmail.com' or request.form['password'] != 'test':
            error = "Invalid account."
        else:
            flash("Login successfully") # 当邮箱和密码输入正确的时候，调用`flash`方法
            return redirect(url_for('index'))
    
    return render_template('login.html', error=error)


if __name__ == '__main__':
    app.run(debug=True)

index.html模板文件

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Index</title>
</head>
<body>
    {% with messages = get_flashed_messages() %}
         {% if messages %}
               {% for message in messages %}
                    <p>{{ message }}</p>
               {% endfor %}
         {% endif %}
    {% endwith %}

<h3>Welcome!</h3>
<a href = "{{ url_for('login') }}">login</a>
</body>
</html>

login.html文件内容

@app.route('/login', methods=['GET', 'POST'])
def login():
    error = None
    if request.method == "POST":
        if request.form['email'] != '123@163.com' or request.form['password'] != '123':
            error = "Invalid account."
        else:
            flash("Login successfully")
            return redirect(url_for('index'))

    return render_template('login.html', error=error)

首页

登录失败

登录成功

蓝图(Blueprint)

本文介绍Flask蓝图，一种封装路由和视图函数的容器，用于模块化构建客户端请求与URL的映射，实现应用的组织

和扩展。在Flask中，使用蓝图可以帮助我们实现模块化应用的功能，比如，现在有一个users.py和main.py实现用户的登录

users.py

from flask import Blueprint

user_app=Blueprint('user_app',__name__)

@user_app.route('/login')
def login():
    return '''
        <form action="/index">
        <input type="text" value="123"/>
        <button type="submit">Login</button>
        <form>
    '''
@user_app.route('/get_user')
def get_users():
    return {
        'username':'张三',
        'password':'123456',
    }

main.py

from flask import  Blueprint
from users import user_app

app = Flask(__name__)
app.register_blueprint(user_app)

@app.route('/index')
def index():
    return 'hello world'

运行效果，路由在不同文件中的时候也能够正常访问。

强大的Pandas数据分析库操作数据库、Excel、CSV等，配合flask使用

后续会出一期pandas详细使用教程，pandas，python+data+analysis的组合缩写，是python中基于numpy和matplotlib的第三方数据分析库，与后两者共同构成了python数据分析的基础工具包，享有数分三剑客之名，减少了我们使用原生sql语句的使用，如果数据量达到万级别，可以使用pandarallel来提升他的运行效率，介绍一个见到那的案例

import pandas as pd
import pymysql

@app.route('/')
def index():
    db_conn = pymysql.connect(
        host='localhost',
        port=3306,
        user='root',
        password='123456',
        database='demo',
        charset='utf8'
    )

    # 读取这个表的数据
    sql = "select * from t_user"
    df=pd.read_sql(sql, con=db_conn)
    # 开始处理这些数据
    df.drop_duplicates(inplace=True)# 去重
    # df.columns # 获取t_user的列名称
    # df.index # 获取t_user的索引
    # df=df.to_dict()# 将df转化为字典
    # sql = "select * from dog"
    # df_dog=pd.read_sql(sql, con=db_conn)
    # df.merge(df_dog, on='id', how='left')# 将t_user表和df_dog根据id进行左连接
    # df=pd.read_csv('data.csv')
    # df=pd.read_excel('data.xlsx',engine='openpyxl')
    # ..........................
    return df.to_dict()

如果有朋友需要pandas练习题的可以关注我的公众号，【小羽网安】回复【pandas】

总结

Flask 是一个用Python编写的轻量级Web应用框架，以其简洁和灵活性而著称，非常适合开发小型至中型的Web应用。以下是对Flask框架的全面总结：

基本特点

轻量级：Flask核心简单，但支持丰富的扩展来构建复杂应用。
灵活性：开发者可以根据项目需求选择所需组件。
RESTful支持：易于创建符合REST风格的接口。
模板引擎：内建支持Jinja2模板。
安全性：支持安全cookie和会话管理。

安装与启动

安装命令：pip install Flask。
创建应用：定义视图函数并使用@app.route()装饰器映射URL。
运行应用：使用flask run或app.run()命令启动服务器。

路由

使用@app.route()装饰器定义路由。
支持变量规则和多种HTTP方法。

模板渲染

使用render_template()函数渲染HTML模板。

请求和响应

通过request对象访问请求数据。
视图函数返回值自动转换为响应对象。

错误处理

注册错误处理器以自定义错误页面。

会话管理

使用session对象跨请求存储信息。

蓝图(Blueprint)

使用蓝图实现应用的模块化。

静态文件

通过url_for('static', filename='...')提供静态文件。

JSON支持

内建支持JSON数据的序列化和反序列化。

安全性

自动转义HTML以防止XSS攻击。
使用escape()函数手动转义用户输入。

部署

可以部署在外部服务器上，使用--host=0.0.0.0选项。

调试模式

使用--debug选项启动应用，提供错误调试信息。

CORS跨域请求

通过flask-cors扩展或@cross_origin装饰器处理跨域请求。

日志和错误监控

使用Sentry等工具监控和报告错误。

集成WSGI中间件

通过app.wsgi_app属性集成中间件。

消息闪现

使用flash()和get_flashed_messages()在用户会话中显示消息。

测试

test_request_context()和request_context()帮助模拟请求环境。

文件上传

支持文件上传，需设置enctype="multipart/form-data"。

集成数据分析

与Pandas等数据分析库结合，进行数据库和数据文件操作。

总结

Flask是一个功能强大且灵活的Web框架，通过其丰富的扩展和简洁的语法，能够快速开发出从简单到复杂的Web应用。其轻量级的特性和对开发者友好的设计，使得Flask成为Python Web开发中的一个受欢迎的选择。

原文链接：https://mp.weixin.qq.com/s/tGNY0E24Pbd6ug6wgeDrqA

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

python

flask

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

python

flask

从0到1，Flask全网最全教学！全文1w字，蓝图、会话、日志、部署等使用Flask搭建中小型企业级项目

从0到1，Flask全网最全教学！全文1w字，蓝图、会话、日志、部署等使用Flask搭建中小型企业级项目

从0到1，Flask全网最全教学！全文1w字，蓝图、会话、日志、部署等使用Flask搭建中小型企业级项目

什么是flask？

优点

缺点

安装 Flask

启动

外部服务器（--host）

调试模式（ --debug）

HTML 转义

路由

变量规则

唯一的URL/重定向行为

URL构建

HTTP方法

静态文件

渲染模板

操作请求数据

本地环境

请求对象

文件上传

Cookies

重定向和错误

关于响应

JSON格式的API

会话session

CORS跨域

日志

集成WSGI中间件

消息闪现

蓝图(Blueprint)

强大的Pandas数据分析库操作数据库、Excel、CSV等，配合flask使用

总结

基本特点

安装与启动

路由

模板渲染

请求和响应

错误处理

会话管理

蓝图(Blueprint)

静态文件

JSON支持

安全性

部署

调试模式

CORS跨域请求

日志和错误监控

集成WSGI中间件

消息闪现

测试

文件上传

集成数据分析

总结

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐