Flask on Dapeng Zhang

flask使用sqlalchemy实现一个group by并且order by的查询

Wed, 30 Jul 2025 10:40:51 +0800

比如我要将我的Tags表的title，按照使用次数最多的并进行降序排列，而且获取前20条Tag
如果是sql查询的话，如果下


select count(*) as total, title 
from tags 
where title <> '' 
group by title 
order by total DESC 
limit 0, 20;

用sqlalchemy的使用方式如下


from sqlalchemy import func

Tag.query.with_entities(
 Tag.title, func.count(Tag.title).label('total')
).filter(Tag.title != '')\
 .group_by(Tag.title)\
 .order_by('total DESC')\
 .limit(20)\
 .all()

但是上面的使用方式在执行的时候会报如下错误


SAWarning: Can't resolve label reference 'total DESC'; converting to text() (this warning may be suppressed after 10 occurrences)
 util.ellipses_string(element.element))

解决方案的代码如下


from sqlalchemy import func, desc

order_by_total = func.count(Tag.title).label('total')

Tag.query.with_entities(
 Tag.title, func.count(Tag.title).label('total')
).filter(Tag.title != '')\
 .group_by(Tag.title)\
 .order_by(desc(order_by_total))\
 .limit(20)\
 .all()

使用方式还是挺奇怪的

如何在Flask扩展开发的过程中加入异常日志

Wed, 30 Jul 2025 09:57:08 +0800

之前开发了一个扩展叫做flask_dxcaptcha

最近在使用他的过程中发现了一个问题，发现异常的时候直接导致使用的他的程序奔溃了，异常让人崩溃，但是不能给使用者带来崩溃，于是做了修复，加了下日志处理逻辑。

但是如果自己再定义一个好像显得有些麻烦，毕竟定义一套虽说可以更加责任化（就是出了问题知道是自己扩展的问题），但是既然是Flask扩展，应该跟使用Flask框架结合下会更好，于是决定先暂时这样处理吧，添加的代码如下


from flask import current_app

try:
 ......
except Exception as e:
 current_app.logger.exception(str(e))
 ......

测试如下


from flask import current_app

try:
	raise Exception('测试异常')
 ......
except Exception as e:
 current_app.logger.exception(str(e))
 ......

于是得到的异常结果如下


[2019-12-27 10:51:12,653] ERROR in captchaclient: 测试异常
Traceback (most recent call last):
 File "/Users/durban/python/baby/.env3_baby/lib/python3.7/site-packages/flask_dxcaptcha/captchaclient.py", line 57, in checkToken
 raise Exception('测试异常')
Exception: 测试异常

如何发布一个Flask扩展包

Wed, 30 Jul 2025 09:56:59 +0800

如何开发和发布一个Flask扩展，如何开发一个Flask扩展，官方介绍在这里

如何开发Flask扩展 - 实战篇（以我最近开发的flask_dxcaptcha为例）

OS - MAX OS

创建一个目录flask_dxcaptcha


mkdir flask_dxcaptcha
cd flask_dxcaptcha

创建python虚拟环境并激活


virtualenv .env -p /usr/local/bin/python3
source .env/bin/activate

创建包并开发具体的逻辑(flask_dxcaptcha目录下)


mkdir flask_dxcaptcha
cd flask_dxcaptcha
touch __init__.py

编写__init__.py文件开始开发扩展逻辑，记录下flask_dxcaptcha的__init__.py


# -*- coding: utf-8 -*-
# @Author: durban.zhang
# @Date: 2019-12-25 17:02:16
# @Last Modified by: durban
# @Last Modified time: 2019-12-25 18:43:25

from flask import current_app, _app_ctx_stack

from flask_dxcaptcha.captchaclient import CaptchaClient

class DXCaptcha(object):

 def __init__(self, app=None):
 self.app = app
 if app is not None:
 self.init_app(app)

 def init_app(self, app):
 app.config.setdefault('DX_APP_ID', '')
 app.config.setdefault('DX_APP_SECRECT', '')

 def init_captcha_client(self):
 if current_app.config['DX_APP_ID'] == '' or \
 current_app.config['DX_APP_SECRECT'] == '':
 raise Exception('DX_APP_ID and DX_APP_SECRECT can not empty.')

 return CaptchaClient(
 current_app.config['DX_APP_ID'],
 current_app.config['DX_APP_SECRECT'],
 )

 @property
 def client(self):
 ctx = _app_ctx_stack.top
 if ctx is not None:
 if not hasattr(ctx, 'dx_captcha'):
 ctx.dx_captcha = self.init_captcha_client()
 return ctx.dx_captcha

flask_dxcaptcha包下的目录结构如下


.
├── __init__.py
├── captchaclient.py
├── captcharesponse.py
├── ctuclient.py
├── cturequest.py
├── cturesponse.py
├── cturesponsestatus.py
├── cturesult.py
├── hitrule.py
├── risklevel.py
├── risktype.py
├── suggestion.py
└── suggestpolicy.py

然后先项目目录下面添加如下几个文件 setup.py # 具体打包和安装配置 MANIFEST.in # 打包文件配置 README.md # 项目介绍包括如何安装、如何使用 LICENSE # 项目许可类型

这里比较重要的是setup.py和MANIFEST.in，着重记录下这两个文件，其余两个文件可以去参考这个扩展flask_dxcaptcha

setup.py的配置如下


# -*- coding: utf-8 -*-
# @Author: durban
# @Date: 2019-12-25 18:00:43
# @Last Modified by: durban.zhang
# @Last Modified time: 2019-12-25 19:03:55

from setuptools import find_packages, setup

setup(
 name='Flask-DXCaptcha',
 version='1.0.0',
 url='https://github.com/durban89/flask_dxcaptcha',
 license='MIT',
 author='durban zhang',
 author_email='[email protected]',
 description='Flask-DXCaptcha是依赖顶象科技提供的无感验证功能开发的Flask 扩展',
 long_description=__doc__,
 packages=find_packages(),
 zip_safe=False,
 include_package_data=True,
 platforms='any',
 install_requires=[
 'Flask>=1.1.1'
 ],
 python_requires=">=3.7.4",
 classifiers=[
 'Environment :: Web Environment',
 'Intended Audience :: Developers',
 'License :: OSI Approved :: BSD License',
 'Operating System :: OS Independent',
 'Programming Language :: Python :: 3',
 'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
 'Topic :: Software Development :: Libraries :: Python Modules'
 ]
)

具体关于setup参数的介绍，请点这里

MANIFEST.in的配置如下


include MANIFEST.in
include README
include LICENSE
recursive-exclude *.pyc

具体关于参数的介绍，请点这里

如何发布Flask扩展

如何发布Flask扩展，具体的可以参考官方介绍，点这里

这里以flask_dxcaptcha为例介绍下，前提是项目开发后，自己测试没有问题再发布

在flask_dxcaptcha项目目录下面运行如下命令（注意是我们的虚拟环境）

如果没有安装setuptools和wheel执行下面命令


pip install setuptools wheel

打包扩展


python3 setup.py sdist bdist_wheel

在dist目录下生成如下文件


$ tree dist
dist
├── Flask-DXCaptcha-1.0.0.tar.gz
└── Flask_DXCaptcha-1.0.0-py3-none-any.whl

上传包到Test PyPI


pip install twine -i https://mirrors.aliyun.com/pypi/simple/

-i 参数指定了包的镜像源

上传所有打包文件到Test PyPI


twine upload --repository-url https://test.pypi.org/legacy/ dist/*

示例如下


$ twine upload --repository-url https://test.pypi.org/legacy/ ./dist/*
Uploading distributions to https://test.pypi.org/legacy/
Enter your username: [your_username]
Enter your password:
Uploading Flask_DXCaptcha-1.0.0-py3-none-any.whl
100%|███████████████████████████████████████████████████████████████████████████████████████████████| 13.0k/13.0k [00:04<00:00, 3.01kB/s]
Uploading Flask-DXCaptcha-1.0.0.tar.gz
100%|███████████████████████████████████████████████████████████████████████████████████████████████| 9.53k/9.53k [00:01<00:00, 7.57kB/s]

View at:
https://test.pypi.org/project/Flask-DXCaptcha/1.0.0/

测试安装上传的包


pip install -i https://test.pypi.org/simple/ --no-deps Flask-DXCaptcha==1.0.0

如果安装成功，就可以正常使用了


$ python
Python 3.7.4 (default, Jul 9 2019, 18:14:44)
[Clang 9.0.0 (clang-900.0.39.2)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> import flask_dxcaptcha
>>>

如果以上都是正常包的话，那么将包发布到正式的PyPI中


twine upload dist/*

示例如下


$ twine upload dist/*
Uploading distributions to https://upload.pypi.org/legacy/
Enter your username: durban_zhang
Enter your password:
Uploading Flask_DXCaptcha-1.0.0-py3-none-any.whl
100%|███████████████████████████████████████████████████████████████████████████████████████████████| 13.0k/13.0k [00:09<00:00, 1.41kB/s]
Uploading Flask-DXCaptcha-1.0.0.tar.gz
100%|███████████████████████████████████████████████████████████████████████████████████████████████| 9.53k/9.53k [00:01<00:00, 6.87kB/s]

View at:
https://pypi.org/project/Flask-DXCaptcha/1.0.0/

打开地址 https://pypi.org/project/Flask-DXCaptcha/1.0.0/ 就能看到发布的Flask扩展了

Flask 1.0进阶 - 扩展

Wed, 30 Jul 2025 09:56:50 +0800

扩展是为flask应用程序添加功能的额外包。例如，扩展可能会添加对发送电子邮件或连接到数据库的支持。一些扩展添加了全新的框架来帮助构建某些类型的应用程序，比如REST API。

查找扩展

Flask扩展通常命名为“Flask-Foo”或“Foo-Flask”。您可以在PyPI中搜索带有 Framework :: Flask 标记的包。

使用扩展

关于每个扩展的安装、配置和使用说明，请查询他们的文档。通常，扩展从 app.config 获取他们自己的配置参数并在初始化的时候传参到应用程序实例中。举个例子，比如扩展“Flask-Foo”的使用方式可能如下：


from flask_foo import Foo

foo = Foo()

app = Flask(__name__)
app.config.update(
 FOO_BAR='baz',
 FOO_SPAM='eggs',
)

foo.init_app(app)

创建扩展

尽管PyPI包含了许多Flask扩展，但是仍没有找到适合你的扩展。如果是这样的话，你可以创建一个你自己的扩展。请参考Flask Extension Development来开发你自己的Flask扩展。

命令行界面

安装Flask后，会默认安装flask脚本的，这个脚本一个Click命令行接口会被安装到虚拟环境中。

通过终端，这个脚本可以访问内建的命令、扩展的命令和程序定义的命令。使用--help选项可以获取到更多关于命令的信息和关于命令的选项

应用程序发现

flask命令是被Flask安装的，不是你的应用安装的。为了使用这个命令，必须告诉你的应用程序在哪里。FLASK_APP环境变量则是用来告诉在哪里能找到应用程序

使用方式如下：

Unix Bash (Linux, Mac, etc.):


$ export FLASK_APP=hello
$ flask run

Windows CMD:


> set FLASK_APP=hello
> flask run

Windows PowerShell:


> $env:FLASK_APP = "hello"
> flask run

FLASK_APP支持多种形式的选项来具体化你的应用程序，大多数都是用比较简单的方式。

下面是一些比较典型的例子

(不做任何设置)


wsgi.py文件将被导入，并自动的检查是否有app(```app```)，它提供了最简单的方式去创建了一个带有额外参数的工厂函数

FLASK_APP=hello 名字将被导入，并自动检查是否有app(app)或者工厂函数(create_app)

FLASK_APP有三个部分：一个设置了当前工作目录的可选路径，一个Python文件或者有点的导入路径和一个可选的实例或者工厂函数变量名。如果是一个工厂函数的话可以通过小括号传入需要的参数，下面看下具体的例子

FLASK_APP=src/hello


设置当前目录的src目录并导入hello

FLASK_APP=hello.web


导入```hello.web```路径

FLASK_APP=hello:app2


使用在hello中的```app2``` Flask实例

FLASK_APP="hello:create_app('dev')"


```create_app```工厂函数在```hello```中被调用并传递参数```'dev'```字符串

如果FLASK_APP没有设置，执行命令时将尝试导入“app”或者“wsgi”（作为一个“.py”文件，或者包）并尝试去检查一个应用实例或者工厂

如果导入的信息被设置了，即FLASK_APP被设置了的话。执行命令时，程序查找一个应用实例名字叫做app或者application，它是一个应用的实例。如果没有找到实例，程序会查找一个工厂行数，名称是create_app或者make_app，它会返回一个实例

当应用工厂函数被调用，如果工厂函数带有一个名字叫做script_info的参数，则ScriptInfo实例会作为一个关键字参数传递进去。如果工厂函数只带有一个参数并且没有圆括号跟在工厂函数名字后面，则ScriptInfo实例将作为一个位置参数传递进去。如果圆括号跟在工厂函数后面的话，他们的内容将被解析喂Python字符串并作为参数传入到函数中。这意味着字符串始终在引号中。

启动开发服务器

run命令将启动一个开发服务器，在许多情况下替代了 Flask.run() 方法


$ flask run
 * Serving Flask app "baby" (lazy loading)
 * Environment: development
 * Debug mode: on
 * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
 * Restarting with stat
 * Debugger is active!
 * Debugger PIN: 267-735-523

注意

不要使用run命令再生产环境中，只使用开发服务器在开发环境中。开发服务器虽然提供了便利，但是不是安全的、不是稳定的、不是高效率的。

进阶结束更新说明

先说下此系列的进阶，主要是以官方文档为主线，边阅读边实践，并记录分享，其中有部分官方的实例是有问题的，但是没有找到反馈入口，也出于没有人访问的情况，所以结束继续分享。如果有疑问可以转到官方文档这里去查看

flask在pytest中如何使用session

Wed, 30 Jul 2025 09:56:47 +0800

先看代码


class AuthActions(object):

 def __init__(self, client):
 self._client = client

 def login(self, username='test', password='test', code='1111'):
 with self._client.session_transaction() as session:
 session['captcha_key'] = '1111'

 return self._client.post(
 '/auth/login',
 data={'username': username, 'password': password,
 'verification-code': code}
 )

 def logout(self):
 return self._client.get('/auth/logout')

这里为什么会提到session，因为我们正常使用的过程中，在登录或者注册的逻辑中会遇到session记录验证码，然后用户用户进行登录或者注册提交表单时的验证，但是这个逻辑在pytest中会遇到一些问题，因为要伪造一个类似于session的情况来测试类似登录或者注册的逻辑中使用session的情况。

这个问题在flask的官网也有介绍如何在测试环境中使用session，可以参考

https://flask.palletsprojects.com/en/1.1.x/testing/#accessing-and-modifying-sessions

https://flask.palletsprojects.com/en/1.1.x/api/#flask.testing.FlaskClient.session_transaction

都有对应的说明但是具体没有实例的话时没有办法具体了解其使用场景的

不过今天在进行测试单元改写的时候发现原来可以这样使用特此记录下方便日查找

上段代码是自我在conftest.py中的代码

使用的时候可以像下面这样调用


@pytest.fixture
def auth(client):
 return AuthActions(client)

然后在测试函数中可以直接这样写


def test_login(client, auth):
 # ... 省略 
 response = auth.login()

 # ... 省略

当然还要自己定义一个叫做client的fixture

Flask中如何获取Server的相关信息

Wed, 30 Jul 2025 09:55:29 +0800

在使用Flask做web开发的时候，偶尔会需要调用Request中的Server信息，比如端口号，域名之类的

在Flask中这个Server的相关信息获取是非常简单的

通过request.environ可以获取到几乎全部的Server信息

比如我这里访问http://127.0.0.1:5000/post/item 然后将request.environ的信息输出到日志，可以获取到类似如下的信息


{'wsgi.errors': <_io.TextIOWrapper name='<stderr>' mode='w' encoding='UTF-8'>, 'wsgi.version': (1, 0), 'wsgi.multithread': True, 'wsgi.multiprocess': False, 'wsgi.run_once': False, 'wsgi.url_scheme': 'http', 'REQUEST_METHOD': 'GET', 'SCRIPT_NAME': '', 'RAW_PATH_INFO': '/post/item', 'PATH_INFO': '/post/item', 'CONTENT_TYPE': 'text/plain', 'SERVER_PROTOCOL': 'HTTP/1.0', 'SERVER_NAME': '127.0.0.1', 'SERVER_PORT': '5000', 'REMOTE_ADDR': '127.0.0.1', 'REMOTE_PORT': '58405', 'GATEWAY_INTERFACE': 'CGI/1.1', 'headers_raw': (('Host', '127.0.0.1:5000'), ('Connection', 'keep-alive'), ('Cache-Control', 'max-age=0'), ('Upgrade-Insecure-Requests', '1'), ('User-Agent', 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.87 Safari/537.36'), ('Sec-Fetch-User', '?1'), ('Accept', 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3'), ('Sec-Fetch-Site', 'none'), ('Sec-Fetch-Mode', 'navigate'), ('Accept-Encoding', 'gzip, deflate, br'), ('Accept-Language', 'zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7,zh-TW;q=0.6,lb;q=0.5,co;q=0.4'), ('Cookie', 'access_token=4b68629fe81a7982728adbea50357c1d382017b8; is_hide_download=true; isShowRedpacket=1; platform=web; QN_HIDDEN_INVEST_TIPS=; QN_HIDDEN_PRODUCT_BUY_PAGE_TIPS=; QN_saveplan_product_id=193; web_device_key=BWDFI2CF7ATW30TXPH07PK2BQTU0YE; zg_did=%7B%22did%22%3A%20%2216680adccf7a2c-0f4a3f6c3160ce-2d604637-3d10d-16680adccf8845%22%7D; _ga=GA1.1.430310970.1544409236; __wzd96bb85a21755618844b8=1556007296|d5311aa69976; UM_distinctid=16b4e888bbd24a-0fffcd4765422c-37677e05-fa000-16b4e888bbeb3; zg_99e520e4c4f745888ab0223f331b0032=%7B%22sid%22%3A%201567655012.547%2C%22updated%22%3A%201567655012.547%2C%22info%22%3A%201567395368068%7D; responseTimeline=1939; io=gwqkVXtguegCXzK5AAAD; __wzdd49646447596a96dfec7=1570773843|a90819629f09; __wzdeea8348a655ff8b452a8=1571706979|dee6f4a108b0; CNZZDATA5587427=cnzz_eid%3D52917038-1544409237-http%253A%252F%252F127.0.0.1%253A3041%252F%26ntime%3D1573781899; Hm_lvt_1ac5a848f7ad883bf5520aa84eda1200=1573781902; Hm_lpvt_1ac5a848f7ad883bf5520aa84eda1200=1573784001; __wzd3bcf756fc5845d894763=1574414880|4bfd4bec505e')), 'HTTP_HOST': '127.0.0.1:5000', 'HTTP_CONNECTION': 'keep-alive', 'HTTP_CACHE_CONTROL': 'max-age=0', 'HTTP_UPGRADE_INSECURE_REQUESTS': '1', 'HTTP_USER_AGENT': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.87 Safari/537.36', 'HTTP_SEC_FETCH_USER': '?1', 'HTTP_ACCEPT': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3', 'HTTP_SEC_FETCH_SITE': 'none', 'HTTP_SEC_FETCH_MODE': 'navigate', 'HTTP_ACCEPT_ENCODING': 'gzip, deflate, br', 'HTTP_ACCEPT_LANGUAGE': 'zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7,zh-TW;q=0.6,lb;q=0.5,co;q=0.4', 'HTTP_COOKIE': 'access_token=4b68629fe81a7982728adbea50357c1d382017b8; is_hide_download=true; isShowRedpacket=1; platform=web; QN_HIDDEN_INVEST_TIPS=; QN_HIDDEN_PRODUCT_BUY_PAGE_TIPS=; QN_saveplan_product_id=193; web_device_key=BWDFI2CF7ATW30TXPH07PK2BQTU0YE; zg_did=%7B%22did%22%3A%20%2216680adccf7a2c-0f4a3f6c3160ce-2d604637-3d10d-16680adccf8845%22%7D; _ga=GA1.1.430310970.1544409236; __wzd96bb85a21755618844b8=1556007296|d5311aa69976; UM_distinctid=16b4e888bbd24a-0fffcd4765422c-37677e05-fa000-16b4e888bbeb3; zg_99e520e4c4f745888ab0223f331b0032=%7B%22sid%22%3A%201567655012.547%2C%22updated%22%3A%201567655012.547%2C%22info%22%3A%201567395368068%7D; responseTimeline=1939; io=gwqkVXtguegCXzK5AAAD; __wzdd49646447596a96dfec7=1570773843|a90819629f09; __wzdeea8348a655ff8b452a8=1571706979|dee6f4a108b0; CNZZDATA5587427=cnzz_eid%3D52917038-1544409237-http%253A%252F%252F127.0.0.1%253A3041%252F%26ntime%3D1573781899; Hm_lvt_1ac5a848f7ad883bf5520aa84eda1200=1573781902; Hm_lpvt_1ac5a848f7ad883bf5520aa84eda1200=1573784001; __wzd3bcf756fc5845d894763=1574414880|4bfd4bec505e', 'wsgi.input': <eventlet.wsgi.Input object at 0x109933550>, 'eventlet.input': <eventlet.wsgi.Input object at 0x109933550>, 'eventlet.posthooks': [], 'flask.app': <Flask 'baby'>, 'werkzeug.request': <Request 'http://127.0.0.1:5000/post/item' [GET]>}

这里我们看下常见的Server有哪些

HTTP_HOST

HTTP_USER_AGENT

HTTP_ACCEPT

HTTP_COOKIE

SERVER_NAME

SERVER_PORT

REMOTE_ADDR

REMOTE_PORT

REQUEST_METHOD

SCRIPT_NAME

RAW_PATH_INFO

PATH_INFO

CONTENT_TYPE

SERVER_PROTOCOL

当我们想要获取其中的值的话，可以使用下面的方法比如获取SERVER_NAME的值


request.environ.get('SERVER_NAME')

Flask 1.0 - Celery管理后台任务-工厂模式

Tue, 29 Jul 2025 10:56:33 +0800

管理后台任务，在许多项目中都是必不可少的，Flask的文档中推荐的Celery，但是官方文档简单介绍了非工厂模式的使用方式，简单的介绍了使用方法，但是对于使用工厂模式创建应用的我来说，完全达不到我使用的目的，根本不完美

文章参考

https://citizen-stig.github.io/2016/02/17/using-celery-with-flask-factories.html

经过搜索找到了这篇文章，给了我启发。so，记录下我自己项目的使用方式吧

baby/__init__.py保持create_app不变

添加文件

baby/celery.py文件，代码如下


# -*- coding: utf-8 -*-
# @Author: durban.zhang
# @Date: 2019-11-13 17:19:11
# @Last Modified by: durban.zhang
# @Last Modified time: 2019-11-13 17:19:25
from celery import Celery

def create_celery(app=None):
 celery = Celery(
 app.import_name,
 backend=app.config['CELERY_RESULT_BACKEND'],
 broker=app.config['CELERY_BROKER_URL']
 )
 celery.conf.update(app.config)

 class ContextTask(celery.Task):

 def __call__(self, *args, **kwargs):
 with app.app_context():
 return self.run(*args, **kwargs)

 celery.Task = ContextTask

 return celery

然后创建baby/task.py文件，代码如下


# -*- coding: utf-8 -*-
# @Author: durban.zhang
# @Date: 2019-11-13 16:30:07
# @Last Modified by: durban.zhang
# @Last Modified time: 2019-11-13 17:19:48
from baby import create_app
from baby.celery import create_celery
celery = create_celery(create_app())

@celery.task(name="tasks.add_together")
def add_together(a, b):
 return a + b

这些添加完之后，运行celery


celery -A baby.task worker -E --loglevel=info

输入类似如下


celery@durbanzhangdeMacBook-Pro v4.3.0 (rhubarb)

Darwin-16.7.0-x86_64-i386-64bit 2019-11-13 17:20:02

[config]
.> app: baby:0x1030c1310
.> transport: redis://localhost:6379//
.> results: redis://localhost:6379/
.> concurrency: 4 (prefork)
.> task events: ON

.> celery exchange=celery(direct) key=celery

[tasks]
 . tasks.add_together

[2019-11-13 17:20:03,547: INFO/MainProcess] Connected to redis://localhost:6379//
[2019-11-13 17:20:03,561: INFO/MainProcess] mingle: searching for neighbors
[2019-11-13 17:20:04,617: INFO/MainProcess] mingle: all alone
[2019-11-13 17:20:04,649: INFO/MainProcess] celery@durbanzhangdeMacBook-Pro ready.

Celery相关的参数配置如下（使用的是Redis）


app.config['CELERY_BROKER_URL'] = 'redis://localhost:6379'
app.config['CELERY_RESULT_BACKEND'] = 'redis://localhost:6379'

下面看下在view中如何调用这个任务吧


from baby.celery import create_celery

@bp.route('/together')
def together():
 celery = create_celery(current_app)
 result = celery.send_task(name='tasks.add_together', args=(2, 3))
 print(result.wait())
 return 'success'

我这里使用的是Blueprint，所以只说使用Blueprint的情况

运行项目，访问http://localhost:5000/stream/together

看下celery的输出


[2019-11-13 17:51:47,160: INFO/MainProcess] Received task: tasks.add_together[b37ca0cc-1fa3-4182-9ca8-3404aafc6ad3]
[2019-11-13 17:51:47,201: INFO/ForkPoolWorker-2] Task tasks.add_together[b37ca0cc-1fa3-4182-9ca8-3404aafc6ad3] succeeded in 0.0225263449999602s: 5
[2019-11-13 17:52:19,636: INFO/MainProcess] Received task: tasks.add_together[223f1ead-cbf4-46c3-b5fc-18f362d9a3b5]
[2019-11-13 17:52:19,672: INFO/ForkPoolWorker-1] Task tasks.add_together[223f1ead-cbf4-46c3-b5fc-18f362d9a3b5] succeeded in 0.01702427300006093s: 5
[2019-11-13 17:52:20,395: INFO/MainProcess] Received task: tasks.add_together[87b47fde-daae-4a9a-940a-3d038577af0d]
[2019-11-13 17:52:20,398: INFO/ForkPoolWorker-2] Task tasks.add_together[87b47fde-daae-4a9a-940a-3d038577af0d] succeeded in 0.0009092729999338189s: 5

一切运行正常。当然我这边也有一个输出


127.0.0.1 - - [13/Nov/2019 17:52:19] "GET /stream/together HTTP/1.1" 200 160 0.212275
5

注意这里输出的值“5”

好了，记录到此结束。

Flask 1.0 - Flask MongoEngine 'QuerySet' object has no attribute 'get_or_404'

Tue, 29 Jul 2025 10:56:29 +0800

学习Flask 1.0中使用“flask-mongoengine==0.9.5”，遇到类似“ AttributeError: ‘QuerySet’ object has no attribute ‘first_or_404’”这个错误

网上查了文档，说要在创建model类的时候添加一段代码，如下


meta = {'abstract': True, 'queryset_class': BaseQuerySet}

从代码的逻辑上来说，应该不会有问题的，而且Flask 1.0的官方文档应该也不会傻到用错误的实例来误导大家吧

文档地址：https://flask.palletsprojects.com/en/1.1.x/patterns/mongoengine/中有个创建Movie Model的代码


import mongoengine as me

class Movie(me.Document):
 title = me.StringField(required=True)
 year = me.IntField()
 rated = me.StringField()
 director = me.StringField()
 actors = me.ListField()

于是去看了“flask-mongoengine==0.9.5”的源代码，不看不知道，一看醒然大悟呀

在源码文件中“site-packages/flask_mongoengine/__init__.py”这个文件中有Document这个类如下


class Document(mongoengine.Document):
 """Abstract document with extra helpers in the queryset class"""

 meta = {'abstract': True,
 'queryset_class': BaseQuerySet}

 def paginate_field(self, field_name, page, per_page, total=None):
 """Paginate items within a list field."""
 # TODO this doesn't sound useful at all - remove in next release?
 count = getattr(self, field_name + "_count", '')
 total = total or count or len(getattr(self, field_name))
 return ListFieldPagination(self.__class__.objects, self.pk, field_name,
 page, per_page, total=total)

于是明白了，官方文档果然有点傻，忽悠我们上当嘞，我将Movie的Model类代码修改下，如下


from flask_mongoengine import Document
import mongoengine as me
from . import Imdb

class Movie(Document):
 title = me.StringField()
 year = me.IntField()
 rated = me.StringField()
 director = me.StringField()
 actors = me.ListField()
 imdb = me.EmbeddedDocumentField(Imdb)

再次运行试试，果然代码没有再报错误了。

再次进行写入操作后，写入逻辑如下


bttf = Movie(title='Back To The Feature', year=1985)
bttf.actors = [
 'Michael J. Fox',
 'Christopher Lloyd'
]
bttf.imdb = Imdb(imdb_id='tt0088763', rating=8.5)
bttf.save()

bttf = Movie.objects(title='Back To The Feature').first_or_404()

终于可以查到了


> use baby
switched to db baby
> db.collection
baby.collection
> coll = db.baby
baby.baby
> coll.find()
> coll.find({'title':'Back To The Feature'})
> coll.find({'title':'Back To The Feature'})
> col = db.movie
baby.movie
> col.find({'title':'Back To The Feature'})
{ "_id" : ObjectId("5dcb58d3bff86222392e8ca6"), "title" : "Back To The Feature", "year" : 1985, "actors" : [ "Michael J. Fox", "Christopher Lloyd" ], "imdb" : { "imdb_id" : "tt0088763", "rating" : 8.5 } }
{ "_id" : ObjectId("5dcb5a06e08d79942ea2184b"), "title" : "Back To The Feature", "year" : 1985, "actors" : [ "Michael J. Fox", "Christopher Lloyd" ], "imdb" : { "imdb_id" : "tt0088763", "rating" : 8.5 } }
{ "_id" : ObjectId("5dcb5c0299c8eebebb5f6ce0"), "title" : "Back To The Feature", "year" : 1985, "actors" : [ "Michael J. Fox", "Christopher Lloyd" ], "imdb" : { "imdb_id" : "tt0088763", "rating" : 8.5 } }
{ "_id" : ObjectId("5dcb5c105a4bbdabd53bc2f6"), "title" : "Back To The Feature", "year" : 1985, "actors" : [ "Michael J. Fox", "Christopher Lloyd" ], "imdb" : { "imdb_id" : "tt0088763", "rating" : 8.5 } }
{ "_id" : ObjectId("5dcb5c20fc294890b9693548"), "title" : "Back To The Feature", "year" : 1985, "actors" : [ "Michael J. Fox", "Christopher Lloyd" ], "imdb" : { "imdb_id" : "tt0088763", "rating" : 8.5 } }
{ "_id" : ObjectId("5dcb5f41a6fb86c4f3bc4d4d"), "title" : "Back To The Feature", "year" : 1985, "actors" : [ "Michael J. Fox", "Christopher Lloyd" ], "imdb" : { "imdb_id" : "tt0088763", "rating" : 8.5 } }
{ "_id" : ObjectId("5dcb5f42a6fb86c4f3bc4d4e"), "title" : "Back To The Feature", "year" : 1985, "actors" : [ "Michael J. Fox", "Christopher Lloyd" ], "imdb" : { "imdb_id" : "tt0088763", "rating" : 8.5 } }
>

最后还发现这个文档这里的一个坑，mongodb的配置如果按照下面的写法


app.config['MONGODB_SETTINGS'] = {
 'db': 'baby'
}

会报错提示如下错误

MongoEngineConnectionError: You have not defined a default connection

改为如下可正常运行


app.config['MONGODB_SETTINGS'] = {
 'db': 'baby',
 'alias': 'default'
}

刚刚又遇到一个问题

在使用get_or_404()这个方法的时候，居然报404错误，但是如果去掉get_or_404()，直接使用如下代码


movies = Movie.objects(title='Back To The Feature')

然后将数据渲染到前端居然可以获取到数据，是不是说，不需要使用get_or_404()还是说我使用的方法错误了，应该还需要做些什么操作。


return render_template('langcode/me.j2', movies=movies)

渲染的html代码如下


{% extends "base.j2" %}

{% block content %}
 {% for movie in movies %}
 <p>{{ movie.id }}</p>
 <p>{{ movie.title }}</p>
 <p>{{ movie.year }}</p>
 <p>{{ movie.imdb.rating }}</p>
 {% endfor %}
{% endblock %}

Flask 1.0 - AttributeError: 'DispatcherMiddleware' object has no attribute 'config'

Tue, 29 Jul 2025 10:56:26 +0800

Flask 1.0使用过程中遇到“AttributeError: ‘DispatcherMiddleware’ object has no attribute ‘config’”，官方的文档暂时还没更新，这里经过资料搜集，暂时有了一个可使用的解决方案。

最近在偷偷的自学Flask，一边看文档，一边实践，发现了一些小问题。

官方文档在“绑定应用”的章节实例代码如下


from werkzeug.middleware.dispatcher import DispatcherMiddleware
from frontend_app import application as frontend
from backend_app import application as backend

application = DispatcherMiddleware(frontend, {
 '/backend': backend
})

但是在经过测试后运行报错了


Server initialized for eventlet.
Traceback (most recent call last):
 File "wsgi.py", line 12, in <module>
 socketio.run(application, debug=True)
 File "/Users/durban/python/baby/.env3_baby/lib/python3.7/site-packages/flask_socketio/__init__.py", line 498, in run
 server_name = app.config['SERVER_NAME']
AttributeError: 'DispatcherMiddleware' object has no attribute 'config'

可以看出错误的问题属性没有了

https://stackoverflow.com/questions/36219842/flask-app-wrapped-with-dispatchermiddleware-no-longer-has-test-client

于是在这里找到了答案

最后的实例使用方法如下


from baby_backend import application as backend
from werkzeug.middleware.dispatcher import DispatcherMiddleware

app.wsgi_app = DispatcherMiddleware(app.wsgi_app, {
 '/backend': backend
})

这里的baby_backend是个package

实战记录 - Flask中使用SQLAlchemy创建Model，实现“一对多”、“多对多”的方式

Tue, 29 Jul 2025 10:56:22 +0800

Flask中使用SQLAlchemy创建Model，实现“一对多”、“多对多”的方式

Flask==0.12.2 Flask-SQLAlchemy==2.3.2

实现“一对多”的情况

一个帖子对应一个分类，一个分类对应多个贴子

使用backref的方式如下

分类模型


class Category(db.Model):
 '''分类'''
 __tablename__ = 'category'

 id = db.Column(db.Integer, primary_key=True)
 title = db.Column(db.String(100), unique=True)

 def __repr__(self):
 return '<Category %r>' % self.title

帖子模型


class Article(db.Model):
 ''' 帖子'''
 __tablename__ = 'article'

 id = db.Column(db.Integer, primary_key=True, doc='自增id')
 title = db.Column(db.String(100), unique=True, doc='标题')
 content = db.Column(db.Text, doc='描述内容')
 user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
 category_id = db.Column(db.Integer, db.ForeignKey('category.id'))

 # 这里是关键点 通过使用backref的方式
 category = db.relationship('Category', backref='article')

 def __repr__(self):
 return '<Article %r>' % self.title

使用back_populates的方式如下

分类模型


class Category(db.Model):
 '''分类'''
 __tablename__ = 'category'

 id = db.Column(db.Integer, primary_key=True)
 title = db.Column(db.String(100), unique=True)
 # 这里是关键点 通过使用backref的方式
 article = db.relationship('Article', back_populates='back_populates')

 def __repr__(self):
 return '<Category %r>' % self.title

帖子模型


class Article(db.Model):
 ''' 帖子'''
 __tablename__ = 'article'

 id = db.Column(db.Integer, primary_key=True, doc='自增id')
 title = db.Column(db.String(100), unique=True, doc='标题')
 content = db.Column(db.Text, doc='描述内容')
 user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
 category_id = db.Column(db.Integer, db.ForeignKey('category.id'))

 # 这里是关键点 通过使用backref的方式
 category = db.relationship('Category', back_populates='article')

 def __repr__(self):
 return '<Article %r>' % self.title

实现“多对多”的情况

一个帖子对应多个标签，一个标签对应多个贴子

需要建立一个中间表

帖子标签关联表配置


ARTICLE_TAGS = db.Table('article_tags',
 db.Column('tag_id', db.Integer,
 db.ForeignKey('tags.id')),
 db.Column('article_id', db.Integer,
 db.ForeignKey('article.id'))
 )

帖子模型


class Article(db.Model):
 '''帖子'''
 __tablename__ = 'article'

 id = db.Column(db.Integer, primary_key=True, doc='自增id')
 title = db.Column(db.String(100), unique=True, doc='标题')
 content = db.Column(db.Text, doc='描述内容')
 user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
 category_id = db.Column(db.Integer, db.ForeignKey('category.id'))

 # 多对多的关联配置
 tags = db.relationship(
 'Tag',
 secondary=ARTICLE_TAGS,
 backref=db.backref('article', lazy='dynamic'))

 def __repr__(self):
 return '<Article %r>' % self.title

标签模型


class Tag(db.Model):
 '''标签'''
 __tablename__ = 'tags'

 def __init__(self, title):
 self.title = title

 id = db.Column(db.Integer, primary_key=True)
 title = db.Column(db.String(100))

疑问article_tags这个需要建表吗

答：当然需要，不然怎么存储多对多的关联呢

Flask 1.0 进阶 - 具有Blueprint的模块化应用程序

Tue, 29 Jul 2025 10:56:19 +0800

具有Blueprint的模块化应用程序

Flask使用蓝图概念来制作应用程序组件，并在应用程序或应用程序中支持常见模式。蓝图可以极大地简化大型应用程序的工作方式，并为Flask扩展提供注册应用程序操作的核心方法。 Blueprint 对象与 Flask 应用程序对象的工作方式类似，但它实际上并不是一个应用程序。相反，它是如何构建或扩展应用程序的蓝图。

为何选择蓝图？

Flask中的蓝图适用于以下情况：

将应用程序纳入一组蓝图中。这是大型应用的理想选择;项目可以实例化一个应用程序对象，初始化几个扩展，并注册一组蓝图。
在URL前缀和/或子域中的应用程序上注册蓝图。URL前缀/子域中的参数成为蓝图中所有视图函数的公共视图参数（具有默认值）。
在具有不同URL规则的应用程序上多次注册蓝图。
通过蓝图提供模板过滤器，静态文件，模板和其他实用程序。蓝图不必实现应用程序或查看功能。
在初始化Flask扩展时，在应用程序中为任何这些情况注册蓝图。

Flask中的蓝图不是一个可插拔的应用程序，因为它实际上不是一个应用程序 - 它是一组可以在应用程序上注册的操作，甚至多次。为什么没有多个应用程序对象？您可以这样做（请参阅应用程序调度），但您的应用程序将具有单独的配置，并将在WSGI层进行管理。

相反，蓝图在Flask级别提供分离，共享应用程序配置，并且可以根据需要在注册时更改应用程序对象。缺点是，一旦创建应用程序，您无法取消注册蓝图，而不必销毁整个应用程序对象。

蓝图的概念

蓝图的基本概念是它们记录在应用程序上注册时要执行的操作。在分派请求和从一个端点到另一个端点生成URL时，Flask将视图函数与蓝图相关联。

我的第一份蓝图

这是一个非常基本的蓝图。在这种情况下，我们希望实现一个简单渲染静态模板的蓝图：


from flask import Blueprint, render_template, abort
from jinja2 import TemplateNotFound

simple_page = Blueprint('simple_page', __name__,
 template_folder='templates')

@simple_page.route('/', defaults={'page': 'index'})
@simple_page.route('/<page>')
def show(page):
 try:
 return render_template('pages/%s.html' % page)
 except TemplateNotFound:
 abort(404)

在@simple_page.route装饰器的帮助下绑定函数时，蓝图将记录在应用程序稍后注册时在应用程序上注册函数show的意图。此外，它将为函数的端点添加蓝图的名称，该蓝图的名称是给予 Blueprint 构造函数的（在本例中也是simple_page）。蓝图的名称不会修改URL，只会修改endpoint。

注册蓝图

那么你如何注册这个蓝图？像这样：


from flask import Flask
from yourapplication.simple_page import simple_page

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

如果您检查在应用程序上注册的规则，您会发现：


[<Rule '/static/<filename>' (HEAD, OPTIONS, GET) -> static>,
 <Rule '/<page>' (HEAD, OPTIONS, GET) -> simple_page.show>,
 <Rule '/' (HEAD, OPTIONS, GET) -> simple_page.show>]

第一个显然来自应用程序本身的静态文件。另外两个用于simple_page蓝图的 show 函数。如您所见，它们还以蓝图的名称为前缀，并以点（.）分隔。

然而，蓝图也可以安装在不同的位置：


app.register_blueprint(simple_page, url_prefix='/pages')

然后，生成的规则对应如下：


[<Rule '/static/<filename>' (HEAD, OPTIONS, GET) -> static>,
 <Rule '/pages/<page>' (HEAD, OPTIONS, GET) -> simple_page.show>,
 <Rule '/pages/' (HEAD, OPTIONS, GET) -> simple_page.show>]

最重要的是，您可以多次注册蓝图，但并非每个蓝图都可以正确响应。实际上，如果蓝图可以多次安装，它取决于蓝图的实现方式。

蓝图资源

蓝图也可以提供资源。有时您可能只想为其提供的资源引入蓝图。

蓝图资源文件夹

与常规应用程序一样，蓝图被认为包含在文件夹中。虽然多个蓝图可以来自同一个文件夹，但并非必须如此，通常不建议这样做。

该文件夹是从 Blueprint 的第二个参数推断出来的，通常是*name*。此参数指定哪个逻辑Python模块或包对应于蓝图。如果它指向一个实际的Python包，那么包（它是文件系统上的文件夹）就是资源文件夹。如果它是一个模块，则包含模块的包将是资源文件夹。您可以访问 Blueprint.root_path 属性以查看资源文件夹是什么：


>>> simple_page.root_path
'/Users/username/TestProject/yourapplication'

要从此文件夹快速打开源，您可以使用 open_resource() 函数：


with simple_page.open_resource('static/style.css') as f:
 code = f.read()

静态文件

蓝图可以通过使用static_folder参数提供文件系统上文件夹的路径来公开具有静态文件的文件夹。它是绝对路径或相对于蓝图的位置：


admin = Blueprint('admin', __name__, static_folder='static')

默认情况下，路径的最右边部分是它在Web上公开的位置。可以使用static_url_path参数更改此设置。因为此处的文件夹名为static，所以它将在蓝图+/static的url_prefix中提供。如果蓝图具有前缀/admin，则静态URL将为/admin/static。

endpoint名为blueprint_name.static。您可以使用 url_for() 生成URL，就像使用应用程序的静态文件夹一样：


url_for('admin.static', filename='style.css')

但是，如果蓝图没有url_prefix，则无法访问蓝图的静态文件夹。这是因为在这种情况下URL将是/static，并且应用程序的/static路由优先。与模板文件夹不同，如果应用程序静态文件夹中不存在该文件，则不会搜索蓝图静态文件夹。

模板

如果您希望蓝图公开模板，可以通过向Blueprint构造函数提供template_folder参数来实现：


admin = Blueprint('admin', __name__, template_folder='templates')

对于静态文件，路径可以是蓝图资源文件夹的绝对路径或相对路径。

模板文件夹添加到模板的搜索路径中，但优先级低于实际应用程序的模板文件夹。这样，您可以轻松覆盖蓝图在实际应用程序中提供的模板。这也意味着如果您不希望意外覆盖蓝图模板，请确保没有其他蓝图或实际应用程序模板具有相同的相对路径。当多个蓝图提供相同的相对模板路径时，注册的第一个蓝图优先于其他蓝图。

因此，如果您在yourapplication/admin中的文件夹中有蓝图，并且您希望呈现模板'admin/index.html'并且您提供了templates作为template_folder，则必须创建如下文件：yourapplication/admin/templates/admin/index.html的。额外admin文件夹的原因是为了避免在实际应用程序模板文件夹中使用名为index.html的模板覆盖我们的模板。

为了进一步重申这一点：如果你有一个名为admin的蓝图，并且你想渲染一个名为index.html的模板，这个模板是特定于这个蓝图的，那么最好的想法就是像这样布置你的模板：


yourpackage/
 blueprints/
 admin/
 templates/
 admin/
 index.html
 __init__.py

然后，当您想要渲染模板时，使用admin/index.html作为名称来查找模板。如果您在加载正确的模板时遇到问题，请启用EXPLAIN_TEMPLATE_LOADING配置变量，该变量将指示Flask打印出在每次render_template调用时定位模板的步骤。

构建网址

如果你想从一个页面链接到另一个页面，你可以使用 url_for() 函数，就像你通常只需要在URL端点前面加上蓝图的名称和点（.）：


url_for('admin.index')

此外，如果您处于蓝图或渲染模板的视图功能中并且想要链接到同一蓝图的另一个端点，则可以通过在端点前面添加一个点来使用相对重定向：


url_for('.index')

这将链接到admin.index，例如，以防当前请求被分派到任何其他管理蓝图端点。

错误处理程序

蓝图支持errorhandler装饰器，就像 Flask 应用程序对象一样，因此很容易制作特定于蓝图的自定义错误页面。

以下是“404找不到页面”异常的示例：


@simple_page.errorhandler(404)
def page_not_found(e):
 return render_template('pages/404.html')

大多数错误处理程序将按预期工作;但是，有关404和405例外处理程序的警告。这些错误处理程序仅从相应的raise语句或另一个蓝图视图函数中的abort调用中调用;例如，无效的URL访问不会调用它们。这是因为蓝图不“拥有”某个URL空间，因此如果给定无效的URL，应用程序实例无法知道它应该运行哪个蓝图错误处理程序。如果您希望基于URL前缀对这些错误执行不同的处理策略，可以使用请求代理对象在应用程序级别定义它们：


@app.errorhandler(404)
@app.errorhandler(405)
def _handle_api_error(ex):
 if request.path.startswith('/api/'):
 return jsonify_error(ex)
 else:
 return ex

有关错误处理的更多信息请参阅自定义错误页

Flask 1.0 进阶 - 请求上下文

Tue, 29 Jul 2025 10:56:14 +0800

请求上下文在请求期间跟踪请求级数据。而不是将请求对象传递给在请求期间运行的每个函数，而是访问 request 和会话代理。

这类似于应用程序上下文，它独立于请求跟踪应用程序级数据。当推送请求上下文时，推送相应的应用程序上下文。

上下文的目的

当 Flask 应用程序处理请求时，它会根据从WSGI服务器收到的环境创建一个 Request 对象。由于worker（线程，进程或协程取决于服务器）一次只处理一个请求，因此在该请求期间可以将请求数据视为该工作者的全局请求。Flask为此使用术语context local。

Flask在处理请求时自动推送请求上下文。查看函数，错误处理程序以及在请求期间运行的其他函数将有权访问 request 代理，该代理指向当前请求的请求对象。

上下文的生命周期

当Flask应用程序开始处理请求时，它会push请求上下文，这也会push 应用程序上下文。当请求结束时，它会pop请求上下文，然后pop应用程序上下文。

上下文对于每个线程（或其他worker类型）是唯一的。request 无法传递给另一个线程，另一个线程将具有不同的上下文堆栈，并且不会知道父线程指向的请求。

上下文本地在Werkzeug中实现。有关其内部工作原理的更多信息，请参阅上下文本地。

手动推送上下文

如果您尝试在请求上下文之外访问请求或使用它的任何内容，您将收到以下错误消息：


RuntimeError: Working outside of request context.

This typically means that you attempted to use functionality that
needed an active HTTP request. Consult the documentation on testing
for information about how to avoid this problem.

通常只有在测试需要active请求的代码时才会发生这种情况。一种选择是使用test client 来模拟完整请求。或者，您可以在with块中使用test_request_context() ，并且块中运行的所有内容都可以访问请求，并填充测试数据。


def generate_report(year):
 format = request.args.get('format')
 ...

with app.test_request_context(
 '/make_report/2017', data={'format': 'short'}):
 generate_report()

如果您在代码中的其他位置看到与测试无关的错误，则很可能表示您应该将该代码移动到视图函数中。

有关如何使用交互式Python shell中的请求上下文的信息，请参阅使用命令行管理程序。

上下文如何运作

调用Flask.wsgi_app()方法来处理每个请求。它在请求期间管理上下文。在内部，请求和应用程序上下文用作堆栈，_request_ctx_stack 和_app_ctx_stack 。当上下文被压入堆栈时，依赖于它们的代理是可用的，并指向来自堆栈顶部上下文的信息

当请求开始时，创建并pushed RequestContext，如果该应用程序的上下文不是顶层上下文，则首先创建并pushes AppContext。在推送这些上下文时，current_app，g，request和session代理可用于处理请求的原始线程。

因为上下文是堆栈，所以可以推送其他上下文以在请求期间更改代理。虽然这不是一种常见的模式，但它可以在高级应用程序中使用，例如，进行内部重定向或将不同的应用程序链接在一起。

在调度请求并生成并发送响应之后，将poped请求上下文，然后popped应用程序上下文。在popped它们之前，执行teardown_request() 和teardown_appcontext() 函数。即使在发送期间发生未处理的异常，它们也会执行。

回调和错误

Flask在多个阶段调度请求，这可能会影响请求，响应以及如何处理错误。在所有这些阶段中，上下文都是活跃的。

Blueprint 可以为这些特定于blueprint的事件添加处理程序。如果blueprint拥有与请求匹配的路由，则将运行blueprint处理程序。

在每个请求之前，调用before_request() 函数。如果其中一个函数返回一个值，则跳过其他函数。返回值被视为响应，并且不调用视图函数。
如果before_request()函数未返回响应，则调用匹配路由的视图函数并返回响应。
视图的返回值将转换为实际响应对象并传递给after_request()函数。每个函数都返回一个修改的或新的响应对象。
返回响应后，弹出上下文，调用teardown_request()和teardown_appcontext()函数。即使在上面的任何点引发了未处理的异常，也会调用这些函数。

如果在拆卸函数之前引发异常，Flask会尝试将其与errorhandler()函数匹配以处理异常并返回响应。如果未找到错误处理程序，或者处理程序本身引发异常，Flask将返回通用的500内部服务器错误响应。仍然会调用拆卸函数，并传递异常对象。

如果启用了调试模式，则未处理的异常不会转换为500响应，而是传播到WSGI服务器。这允许开发服务器向交互式调试器提供回溯。

Teardown回调

teardown回调与请求分派无关，而是在popped时由上下文调用。即使在调度期间存在未处理的异常，也会调用函数，以及手动推送的上下文。这意味着无法保证请求调度的任何其他部分首先运行。请务必以不依赖于其他回调的方式编写这些函数，并且不会失败。

在测试期间，在请求结束后推迟popped上下文可能很有用，这样可以在测试函数中访问它们的数据。使用test_client()作为with块来保留上下文，直到with块退出。


from flask import Flask, request

app = Flask(__name__)

@app.route('/')
def hello():
 print('during view')
 return 'Hello, World!'

@app.teardown_request
def show_teardown(exception):
 print('after with block')

with app.test_request_context():
 print('during with block')

# teardown functions are called after the context with block exits

with app.test_client():
 client.get('/')
 # the contexts are not popped even though the request ended
 print(request.path)

# the contexts are popped and teardown functions are called after
# the client with block exists

Signals

如果signals_available为true，则发送以下信号：

request_started 在调用before_request() 函数之前发送。
在调用after_request()函数之后发送request_finished。
在开始处理异常时，但在查找或调用errorhandler() 之前发送got_request_exception 。
在调用teardown_request() 函数之后发送request_tearing_down 。

上下文保留错误

在请求结束时，将popped请求上下文，并销毁与其关联的所有数据。如果在开发过程中发生错误，则延迟销毁数据以进行调试非常有用。

当开发服务器以开发模式运行时（FLASK_ENV环境变量设置为'development'），错误和数据将被保留并显示在交互式调试器中。

可以使用 PRESERVE_CONTEXT_ON_EXCEPTION 配置控制此行为。如上所述，它在开发环境中默认为True。

不要在生产中启用 PRESERVE_CONTEXT_ON_EXCEPTION ，因为它会导致应用程序在异常时泄漏内存。

关于代理的注意事项

Flask提供的一些对象是其他对象的代理。对于每个工作线程，代理以相同的方式访问，但指向此页面中描述的绑定到幕后每个worker的唯一对象。

大多数情况下你不必关心它，但有一些例外情况，知道这个对象是一个真正的代理是很好的：

代理对象不能伪造其类型作为实际对象类型。如果要执行实例检查，则必须对要代理的对象执行此操作。
如果特定对象引用很重要，例如发送信号或将数据传递给后台线程。

如果需要访问代理的基础对象，请使用_get_current_object()方法：


app = current_app._get_current_object()
my_signal.send(app)

Flask 1.0 进阶 - 应用程序上下文

Tue, 29 Jul 2025 10:56:08 +0800

应用程序上下文在请求，CLI命令或其他活动期间跟踪应用程序级数据。而不是将应用程序传递给每个函数，而是访问current_app 和g 代理。

这类似于请求上下文，它在请求期间跟踪请求级数据。当推送请求上下文时，推送相应的应用程序上下文。

上下文的目的

Flask 应用程序对象具有诸如config 之类的属性，这些属性对于在视图和CLI命令中进行访问很有用。但是，在项目中的模块中导入app实例很容易出现循环导入问题。使用应用工厂模式或编写可重复使用的蓝图或扩展时，根本不会导入app实例。

Flask使用 应用程序上下文 解决了这个问题。您可以使用current_app 代理，而不是直接引用应用程序，该代理指向处理当前活动的应用程序。

Flask在处理请求时自动推送应用程序上下文。视图函数，错误处理程序以及在请求期间运行的其他函数将具有对 current_app 的访问权限。

使用@app.cli.command()运行在 Flask.cli 中注册的CLI命令时，Flask还会自动推送应用程序上下文。

上下文的生命周期

必要时创建并销毁应用程序上下文。当Flask应用程序开始处理请求时，它会pushes应用程序上下文和请求上下文。当请求结束时，它会pops请求上下文，然后pops应用程序上下文。通常，应用程序上下文与请求具有相同的生命周期。

有关上下文如何工作以及请求的完整生命周期的更多信息，请参阅请求上下文。

手动Push一个上下文

如果您尝试在应用程序上下文之外访问current_app 或使用它的任何内容，您将收到以下错误消息：


RuntimeError: Working outside of application context.

This typically means that you attempted to use functionality that
needed to interface with the current application object in some way.
To solve this, set up an application context with app.app_context().

如果在配置应用程序时发现错误，例如初始化扩展时，您可以手动push上下文，因为您可以直接访问app。在with块中使用 app_context() ，块中运行的所有内容都可以访问 current_app 。


def create_app():
 app = Flask(__name__)

 with app.app_context():
 init_db()

 return app

如果您在代码中的其他位置看到与配置应用程序无关的错误，则很可能表示您应将该代码移动到视图函数或CLI命令中。

存储数据

应用程序上下文是在请求或CLI命令期间存储公共数据的好地方。Flask为此提供了g object 。它是一个简单的命名空间对象，其生命周期与应用程序上下文相同。

注意：
g名称代表“全局”，但这指的是在上下文中是全局的数据。上下文结束后g上的数据丢失，并且它不是在请求之间存储数据的合适位置。使用 会话(session) 或数据库跨请求存储数据。

g的常见用途是在请求期间管理资源。

如果资源X不存在，则get_X()创建资源X，将其缓存为g.X.
如果资源存在，teardown_X()将关闭或以其他方式释放资源。它被注册为 teardown_appcontext() 处理程序。

例如，您可以使用此模式管理数据库连接：


from flask import g

def get_db():
 if 'db' not in g:
 g.db = connect_to_database()

 return g.db

@app.teardown_appcontext
def teardown_db():
 db = g.pop('db', None)

 if db is not None:
 db.close()

在请求期间，每次调用get_db()都将返回相同的连接，并在请求结束时自动关闭。

您可以使用 LocalProxy 从get_db()创建一个新的本地上下文：


from werkzeug.local import LocalProxy
db = LocalProxy(get_db)

访问db将在内部调用get_db，方法与 current_app 的工作方式相同。

如果您正在编写扩展名，则应为用户代码保留 g 。您可以将内部数据存储在上下文中，但请确保使用足够唯一的名称。使用_app_ctx_stack.top 访问当前上下文。有关更多信息，请参阅Flask Extension Development。

事件和信号

当弹出应用程序上下文时，应用程序将调用teardown_appcontext() 注册的函数。

Flask 1.0 进阶 - 可插拔视图（Pluggable Views）

Tue, 29 Jul 2025 10:56:05 +0800

Flask 0.7引入了可插拔视图，其灵感来自Django的通用视图，它们基于类而不是函数。主要目的是您可以替换部分实现，这种方式具有可自定义的可插拔视图。

基本原则

假设您有一个函数从数据库加载对象列表并呈现到模板中：


@app.route('/users/')
def show_users(page):
 users = User.query.all()
 return render_template('users.html', users=users)

这是简单而灵活的，但如果您想以通用方式提供此视图，以便适应其他模型和模板，您可能需要更多灵活性。这是可插入的基于类的视图的地方。作为将此转换为基于类的视图的第一步，您将执行此操作：


from flask.views import View

class ShowUsers(View):

 def dispatch_request(self):
 users = User.query.all()
 return render_template('users.html', objects=users)

app.add_url_rule('/users/', view_func=ShowUsers.as_view('show_users'))

正如您所看到的，您要做的是创建 flask.views.View 的子类并实现 dispatch_request() 。然后我们必须使用 as_view() 类方法将该类转换为实际的视图函数。传递给该函数的字符串是视图随后具有的端点的名称。但这本身并没有用，所以让我们稍微重构一下代码：


from flask.views import View

class ListView(View):

 def get_template_name(self):
 raise NotImplementedError()

 def render_template(self, context):
 return render_template(self.get_template_name(), **context)

 def dispatch_request(self):
 context = {'objects': self.get_objects()}
 return self.render_template(context)

class UserView(ListView):

 def get_template_name(self):
 return 'users.html'

 def get_objects(self):
 return User.query.all()

这当然对这样一个小例子没那么有用，但它足以解释基本原理。当你有一个基于类的视图时，问题出现在self指向的位置。这种方式的工作方式是每当调度请求时，都会创建一个新的类实例，并使用URL规则中的参数调用 dispatch_request() 方法。使用传递给 as_view() 函数的参数来实例化类本身。例如，你可以写一个这样的类：


class RenderTemplateView(View):
 def __init__(self, template_name):
 self.template_name = template_name
 def dispatch_request(self):
 return render_template(self.template_name)

然后你可以像这样注册：


app.add_url_rule('/about', view_func=RenderTemplateView.as_view(
 'about_page', template_name='about.html'))

方法提示

通过使用route()或更好的add_url_rule()，可插拔视图像常规函数一样附加到应用程序。但是，这也意味着您必须在附加此视图时提供视图支持的HTTP方法的名称。为了将该信息移动到类，您可以提供具有以下信息的方法属性：


class MyView(View):
 methods = ['GET', 'POST']

 def dispatch_request(self):
 if request.method == 'POST':
 ...
 ...

app.add_url_rule('/myview', view_func=MyView.as_view('myview'))

基于方法的调度

对于RESTful API，为每个HTTP方法执行不同的功能特别有用。使用 flask.views.MethodView ，您可以轻松地做到这一点。每个HTTP方法都映射到一个具有相同名称的函数（只是小写）：


from flask.views import MethodView

class UserAPI(MethodView):

 def get(self):
 users = User.query.all()
 ...

 def post(self):
 user = User.from_form_data(request.form)
 ...

app.add_url_rule('/users/', view_func=UserAPI.as_view('users'))

这样你就不必提供methods属性。它会根据类中定义的方法自动设置的。

装饰视图

由于视图类本身不是添加到路由系统的视图函数，因此装饰类本身没有多大意义。相反，你要么必须手工装饰as_view()的返回值：


def user_required(f):
 """Checks whether user is logged in or raises error 401."""
 def decorator(*args, **kwargs):
 if not g.user:
 abort(401)
 return f(*args, **kwargs)
 return decorator

view = user_required(UserAPI.as_view('users'))
app.add_url_rule('/users/', view_func=view)

从Flask 0.8开始，还有另一种方法可以指定要在类声明中应用的装饰器列表：


class UserAPI(MethodView):
 decorators = [user_required]

由于来自调用者视角的隐式self，您不能在视图的各个方法上使用常规视图装饰器，但请记住这一点。

API的方法视图

Web API通常与HTTP谓词密切配合，因此基于 MethodView 实现这样的API非常有意义。也就是说，您会注意到API将需要不同的URL规则，这些规则在大多数情况下都会转到相同的方法视图。例如，考虑您在Web上公开用户对象：

URL	Method	Description
/users/	GET	Gives a list of all users
/users/	POST	Creates a new user
/users/	GET	Shows a single user
/users/	PUT	Updates a single user
/users/	DELETE	Deletes a single user

那么你将如何使用 MethodView 做到这一点？诀窍是利用您可以为同一视图提供多个规则的事实。

我们暂时假设视图看起来像这样：


class UserAPI(MethodView):

 def get(self, user_id):
 if user_id is None:
 # return a list of users
 pass
 else:
 # expose a single user
 pass

 def post(self):
 # create a new user
 pass

 def delete(self, user_id):
 # delete a single user
 pass

 def put(self, user_id):
 # update a single user
 pass

那么我们如何将其与路由系统联系起来呢？通过添加两个规则并明确提到每个规则的方法：


user_view = UserAPI.as_view('user_api')
app.add_url_rule('/users/', defaults={'user_id': None},
 view_func=user_view, methods=['GET',])
app.add_url_rule('/users/', view_func=user_view, methods=['POST',])
app.add_url_rule('/users/<int:user_id>', view_func=user_view,
 methods=['GET', 'PUT', 'DELETE'])

如果你有很多类似的API，你可以重构那个注册码：


def register_api(view, endpoint, url, pk='id', pk_type='int'):
 view_func = view.as_view(endpoint)
 app.add_url_rule(url, defaults={pk: None},
 view_func=view_func, methods=['GET',])
 app.add_url_rule(url, view_func=view_func, methods=['POST',])
 app.add_url_rule('%s<%s:%s>' % (url, pk_type, pk), view_func=view_func,
 methods=['GET', 'PUT', 'DELETE'])

register_api(UserAPI, 'user_api', '/users/', pk='user_id')

Flask 1.0 进阶 - 信号(Signals)

Tue, 29 Jul 2025 10:56:01 +0800

从Flask 0.6开始，Flask中集成了对信号的支持。这种支持由优秀的 blinker 库提供，如果不可用，将优雅地退回。

什么是信号？信号通过在核心框架或其他Flask扩展中的其他位置发生操作时发送通知来帮助您解耦应用程序。简而言之，信号允许某些发送者通知订阅者发生了什么事。

Flask附带了几个信号，其他扩展可能提供更多信号。另请注意，信号旨在通知订阅者，不应鼓励订阅者修改数据。您会注意到有些信号看起来像一些内置装饰器那样做（例如： request_started 与 before_request() 非常相似）。但是，它们的工作方式存在差异。例如，核心 before_request() 处理程序以特定顺序执行，并且能够通过返回响应来提前中止请求。相反，所有信号处理程序都以未定义的顺序执行，不会修改任何数据。

信号优于处理程序的一大优势是，您可以一瞬间安全地订阅它们。例如，这些临时订阅有助于单元测试。假设您想知道哪些模板作为请求的一部分呈现：信号允许您完全执行此操作。

订阅信号

要订阅信号，您可以使用信号的 connect() 方法。第一个参数是在发出信号时应该调用的函数，可选的第二个参数指定发送者。要取消订阅信号，可以使用 disconnect() 方法。

对于所有核心Flask信号，发送方是发出信号的应用程序。订阅信号时，除非您真的想要收听来自所有应用程序的信号，否则请务必提供发件人。如果您正在开发扩展，则尤其如此。

例如，这里有一个帮助器上下文管理器，可以在单元测试中使用它来确定呈现了哪些模板以及将哪些变量传递给模板：


from flask import template_rendered
from contextlib import contextmanager

@contextmanager
def captured_templates(app):
 recorded = []
 def record(sender, template, context, **extra):
 recorded.append((template, context))
 template_rendered.connect(record, app)
 try:
 yield recorded
 finally:
 template_rendered.disconnect(record, app)

现在可以轻松地与测试客户端配对：


with captured_templates(app) as templates:
 rv = app.test_client().get('/')
 assert rv.status_code == 200
 assert len(templates) == 1
 template, context = templates[0]
 assert template.name == 'index.html'
 assert len(context['items']) == 10

确保订阅额外的**extra参数，以便在Flask为信号引入新参数时，您的调用不会失败。

现在，应用程序 app 在with块体中发出的代码中的所有模板呈现都将记录在templates变量中。每当呈现模板时，模板对象以及上下文都会附加到其上。

此外，还有一个方便的辅助方法（ connected_to() ），它允许您使用上下文管理器临时为函数订阅函数。因为无法以这种方式指定上下文管理器的返回值，所以必须将列表作为参数传递：


from flask import template_rendered

def captured_templates(app, recorded, **extra):
 def record(sender, template, context):
 recorded.append((template, context))
 return template_rendered.connected_to(record, app)

上面的例子如下所示：


templates = []
with captured_templates(app, templates, **extra):
 ...
 template, context = templates[0]

创建信号

如果要在自己的应用程序中使用信号，可以直接使用blinker库。最常见的用例是自定义 Namespace 中的命名信号。这是大多数时候建议的：


from blinker import Namespace
my_signals = Namespace()

现在您可以创建这样的新信号：


model_saved = my_signals.signal('model-saved')

此处信号的名称使其独一无二，并简化了调试。您可以使用name属性访问信号的名称。

####To扩展开发者:

如果您正在编写Flask扩展，并且希望对缺少的blinker安装进行优雅降级，则可以使用flask.signals.Namespace类来执行此操作。

发送信号

如果要发出信号，可以通过调用 send() 方法来实现。它接受发送方作为第一个参数，并可选择接收一些转发给信号订阅者的关键字参数：


class Model(object):
 ...

 def save(self):
 model_saved.send(self)

尽量选择一个好的发送者。如果您有一个发出信号的类，请将self作为发送者传递。如果从随机函数发出信号，则可以将current_app._get_current_object()作为发送方传递。

将代理作为发送者传递
永远不要将 current_app 作为发送者传递给信号。请改用current_app._get_current_object()。原因是 current_app 是代理而不是真正的应用程序对象。

信号和Flask的请求上下文

信号在接收信号时完全支持请求上下文。在 request_started 和 request_finished 之间始终可以使用上下文局部变量，因此您可以根据需要依赖于 flask.g 和其他变量。请注意发送信号和 request_tearing_down 信号中描述的限制。

基于装饰器的信号订阅

使用Blinker 1.1，您还可以使用新的 connect_via() 装饰器轻松订阅信号：


from flask import template_rendered

@template_rendered.connect_via(app)
def when_template_rendered(sender, template, context, **extra):
 print 'Template %s is rendered with %s' % (template.name, context)

核心信号

查看信号以获取所有内置信号的列表。

Flask 1.0 进阶 - 配置处理

Tue, 29 Jul 2025 10:55:58 +0800

应用程序需要某种配置。您可能希望更改不同的设置，具体取决于应用程序环境，例如切换调试模式，设置密钥以及其他此类特定于环境的内容。

Flask的设计方式通常要求在应用程序启动时配置可用。您可以对代码中的配置进行硬编码，对于许多小型应用程序而言，实际上并不是那么糟糕，但有更好的方法。

无论您如何加载配置，都有一个可用的配置对象，它保存已加载的配置值： Flask 对象的 config 属性。这是Flask本身放置某些配置值的地方，也是扩展可以放置其配置值的地方。但这也是您可以拥有自己的配置的地方。

基础配置

config 实际上是字典的子类，可以像任何字典一样进行修改：


app = Flask(__name__)
app.config['TESTING'] = True

某些配置值也会转发到 Flask 对象，以便您可以从那里读取和写入它们：


app.testing = True

要一次更新多个密钥，可以使用 dict.update() 方法：


app.config.update(
 TESTING=True,
 SECRET_KEY=b'_5#y2L"F4Q8z\n\xec]/'
)

环境和调试功能

ENV 和 DEBUG 配置值是特殊的，因为如果在应用程序开始设置后更改，它们可能会表现不一致。为了可靠地设置环境和调试模式，Flask使用环境变量。

该环境用于指示Flask，扩展和其他程序，如Sentry，Flask正在运行的上下文。它由 FLASK_ENV 环境变量控制，默认为production。

将FLASK_ENV设置为development将启用调试模式。flask run将在调试模式下默认使用交互式调试器和重新加载器。要与环境分开控制，请使用 FLASK_DEBUG 标志。

要将Flask切换到开发环境并启用调试模式，请设置 FLASK_ENV：


export FLASK_ENV=development
flask run

建议使用上述环境变量。虽然可以在配置或代码中设置 ENV 和 DEBUG ，但强烈建议不要这样做。使用flask命令无法及早读取它们，并且某些系统或扩展可能已根据先前的值配置了自身。

内置配置值

Flask在内部使用以下配置值，这里只是简单介绍下比较常用的几个，具体的详细的配置值可以去官网查看

ENV

应用程序运行的环境。 Flask和扩展可以启用基于环境的行为，例如启用调试模式。env 属性映射到此配置键。这是由FLASK_ENV环境变量设置的，如果在代码中设置，可能不会按预期运行。

在生产环境中部署时不要启用开发模式。

默认值：'production'

DEBUG

是否启用调试模式。当使用flask run启动开发服务器时，将显示一个交互式调试器，用于未处理的异常，并在代码更改时重新加载服务器。debug 属性映射到此配置键。当ENV 为'development'并被FLASK_DEBUG环境变量覆盖时，将启用此功能。如果在代码中设置，它可能不会按预期运行。

在生产中部署时，请勿启用调试模式。

默认值：如果ENV为'development'时值为True，否则为False

TESTING

启用测试模式。异常传播而不是由应用程序的错误处理程序处理。扩展也可能会改变其行为，以方便测试。您应该在自己的测试中启用它。

默认值：False

PROPAGATE_EXCEPTIONS

异常被重新引发而不是由应用程序的错误处理程序处理。

如果没有设置，在启用了TESTING或DEBUG，则隐含为true。

默认值: None

PRESERVE_CONTEXT_ON_EXCEPTION

发生异常时不要弹出请求上下文。

如果未设置，在DEBUG为true时，则为true。这允许调试器在错误上内省请求数据，通常不需要直接设置。

默认值: None

SECRET_KEY

用于安全签名会话cookie的密钥，可用于扩展或您的应用程序的任何其他安全相关需求。它应该是一个长的随机字节串，尽管也接受unicode。例如，将其输出复制到您的配置：


python -c 'import os; print(os.urandom(16))'
b'_5#y2L"F4Q8z\n\xec]/'

提交问题或提交代码时不要泄露密钥。

默认值: None

从文件配置

如果您可以将其存储在单独的文件中，理想情况下位于实际应用程序包之外，则配置会变得更有用。这使得可以通过各种包处理工具（使用Setuptools进行部署）来打包和分发应用程序，最后修改配置文件。

所以一个常见的模式是：


app = Flask(__name__)
app.config.from_object('yourapplication.default_settings')
app.config.from_envvar('YOURAPPLICATION_SETTINGS')

首先从 yourapplication.default_settings 模块加载配置，然后使用YOURAPPLICATION_SETTINGS环境变量指向的文件内容覆盖值。在启动服务器之前，可以使用shell中的export命令在Linux或OS X上设置此环境变量：


$ export YOURAPPLICATION_SETTINGS=/path/to/settings.cfg
$ python run-app.py
 * Running on http://127.0.0.1:5000/
 * Restarting with reloader...

在Windows系统上使用内置的 set 代替：


>set YOURAPPLICATION_SETTINGS=\path\to\settings.cfg

配置文件本身就是实际的Python文件。以后只有大写的值实际存储在配置对象中。因此，请确保为配置键使用大写字母。

以下是配置文件的示例：


# Example configuration
DEBUG = False
SECRET_KEY = b'_5#y2L"F4Q8z\n\xec]/'

确保尽早加载配置，以便扩展能够在启动时访问配置。配置对象上还有其他方法可以从单个文件加载。有关完整参考，请阅读 Config 对象的文档。

从环境变量配置

除了使用环境变量指向配置文件之外，您可能会发现直接从环境控制配置值很有用（或必要）。

在启动服务器之前，可以使用shell中的export命令在Linux或OS X上设置环境变量：


$ export SECRET_KEY='5f352379324c22463451387a0aec5d2f'
$ export MAIL_ENABLED=false
$ python run-app.py
 * Running on http://127.0.0.1:5000/

在Windows系统上使用内置的set代替：


>set SECRET_KEY='5f352379324c22463451387a0aec5d2f'

虽然这种方法很容易使用，但重要的是要记住环境变量是字符串 - 它们不会自动反序列化为Python类型。

以下是使用环境变量的配置文件的示例：


import os

_mail_enabled = os.environ.get("MAIL_ENABLED", default="true")
MAIL_ENABLED = _mail_enabled.lower() in {"1", "t", "true"}

SECRET_KEY = os.environ.get("SECRET_KEY")

if not SECRET_KEY:
 raise ValueError("No SECRET_KEY set for Flask application")

请注意，除了空字符串之外的任何值都将被解释为Python中的布尔值True，如果环境显式设置了值为False的值，则需要注意。

确保尽早加载配置，以便扩展能够在启动时访问配置。配置对象上还有其他方法可以从单个文件加载。有关完整参考，请阅读 Config 类文档。

配置最佳实践

前面提到的方法的缺点是它使测试更加困难。一般来说，这个问题没有单一的100％解决方案，但是您可以记住以下几点来改善这种体验：

在函数中创建应用程序并在其上注册blueprint。这样，您可以创建应用程序的多个实例，并附加不同的配置，这使得单元测试变得更加容易。您可以根据需要使用它来传递配置。
不要在导入时编写需要配置的代码。如果您将自己限制为仅对请求进行配置访问，则可以根据需要稍后重新配置对象。

开发/生产

大多数应用程序需要多个配置。生产服务器和开发期间使用的配置至少应该是单独的配置。处理此问题的最简单方法是使用始终加载的默认配置和版本控制的一部分，以及根据上述示例中提到的必要覆盖值的单独配置：


app = Flask(__name__)
app.config.from_object('yourapplication.default_settings')
app.config.from_envvar('YOURAPPLICATION_SETTINGS')

然后你只需要添加一个单独的config.py文件并导出YOURAPPLICATION_SETTINGS=/path/to/config.py就完成了。然而，也有其他方法。例如，您可以使用导入或子类化。

Django世界中非常流行的是通过将yourapplication.default_settings import *添加到文件顶部然后手动覆盖更改，在配置文件中显式导入。您还可以检查环境变量，如YOURAPPLICATION_MODE，并将其设置为生产，开发等，并根据该变量导入不同的硬编码文件。

一个有趣的模式也是使用类和继承进行配置：


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

要启用此类配置，您只需调用from_object()：


app.config.from_object('configmodule.ProductionConfig')

请注意，from_object()不会实例化类对象。如果需要实例化类，例如访问属性，则必须在调用from_object()之前执行此操作：


from configmodule import ProductionConfig
app.config.from_object(ProductionConfig())

# Alternatively, import via string:
from werkzeug.utils import import_string
cfg = import_string('configmodule.ProductionConfig')()
app.config.from_object(cfg)

实例化配置对象允许您在配置类中使用@property：


class Config(object):
 """Base config, uses staging database server."""
 DEBUG = False
 TESTING = False
 DB_SERVER = '192.168.1.56'

 @property
 def DATABASE_URI(self): # Note: all caps
 return 'mysql://user@{}/foo'.format(self.DB_SERVER)

class ProductionConfig(Config):
 """Uses production database server."""
 DB_SERVER = '192.168.19.32'

class DevelopmentConfig(Config):
 DB_SERVER = 'localhost'
 DEBUG = True

class TestingConfig(Config):
 DB_SERVER = 'localhost'
 DEBUG = True
 DATABASE_URI = 'sqlite:///:memory:'

有许多不同的方法，由您决定如何管理配置文件。不过这里列出了很好的建议：

在版本控制中保留默认配置。使用此默认配置填充配置，或者在覆盖值之前将其导入您自己的配置文件中。
使用环境变量在配置之间切换。这可以从Python解释器外部完成，并使开发和部署变得更加容易，因为您可以快速轻松地在不同的配置之间切换而无需触摸代码。如果您经常在不同的项目上工作，您甚至可以创建自己的源代码脚本来激活virtualenv并为您导出开发配置。
在生产中使用类似fabric的工具将代码和配置分别推送到生产服务器。有关如何执行此操作的一些详细信息，请转到使用Fabric进行部署模式。

实例文件夹

Flask 0.8引入了实例文件夹。Flask很长一段时间可以直接引用相对于应用程序文件夹的路径（通过 Flask.root_path ）。这也是有很多开发人员加载了存储在应用程序旁边的配置。不幸的是，这只适用于应用程序不是包的情况，在这种情况下根路径引用包的内容。

随着Flask 0.8引入了一个新属性： Flask.instance_path 。它指的是一个名为“实例文件夹”的新概念。实例文件夹旨在不受版本控制，并且是特定于部署的。它是丢弃在运行时或配置文件中更改的东西的理想场所。

您可以在创建Flask应用程序时显式提供实例文件夹的路径，也可以让Flask自动检测实例文件夹。对于显式配置，请使用 instance_path 参数：


app = Flask(__name__, instance_path='/path/to/instance/folder')

请记住，提供时此路径必须是绝对的。

如果未提供 instance_path 参数，则使用以下默认位置：

未安装模块：


/myapp.py
/instance

未安装包：


/myapp
 /__init__.py
/instance

已安装的模块或包装：


$PREFIX/lib/python2.X/site-packages/myapp
$PREFIX/var/myapp-instance

$PREFIX是Python安装的前缀。这可以是/usr或virtualenv的路径。您可以打印sys.prefix的值以查看前缀的设置。

由于配置对象提供了从相对文件名加载配置文件，因此我们可以通过文件名将加载更改为相对于实例路径（如果需要）。配置文件中相对路径的行为可以在“相对于应用程序根目录”（默认）到“相对于实例文件夹”之间通过 instance_relative_config 切换到应用程序构造函数：


app = Flask(__name__, instance_relative_config=True)

下面是一个完整的示例，说明如何配置Flask以从模块预加载配置，然后从实例文件夹中的文件覆盖配置（如果存在）：


app = Flask(__name__, instance_relative_config=True)
app.config.from_object('yourapplication.default_settings')
app.config.from_pyfile('application.cfg', silent=True)

可以通过 Flask.instance_path 找到实例文件夹的路径。Flask还提供了使用 Flask.open_instance_resource() 从实例文件夹中打开文件的快捷方式。

两者的示例用法：


filename = os.path.join(app.instance_path, 'application.cfg')
with open(filename) as f:
 config = f.read()

# or via open_instance_resource:
with app.open_instance_resource('application.cfg') as f:
 config = f.read()

Flask 1.0 进阶 - 日志

Tue, 29 Jul 2025 10:55:51 +0800

Flask使用标准的Python日志记录。所有与Flask相关的消息都记录在’flask’记录器命名空间下。Flask.logger返回名为“flask.app”的记录器，可用于记录应用程序的消息。


from flask import current_app

@app.route('/login', methods=['GET', 'POST'])
def login():
 if request.method == 'POST':
 username = request.form['username']
 password = request.form['password']

 db = get_db()
 error = None

 user = db.execute(
 'SELECT * FROM user WHERE username = ?', (username,)
 ).fetchone()

 if user is None:
 error = 'Incorrect username.'
 current_app.logger.info('%s logged fail', username)
 elif not check_password_hash(user['password'], password):
 app.logger.info('%s logged fail', username)
 error = 'Incorrect password.'

 if error is None:
 session.clear()
 session['user_id'] = user['id']
 current_app.logger.info('%s logged successfully', username)
 return redirect(url_for('blog.index'))

 flash(error)

 return render_template('auth/login.html')

基础配置

如果要为项目配置日志记录，则应在程序启动时尽快执行。如果在配置日志记录之前访问 app.logger ，它将添加默认处理程序。如果可能，在创建应用程序对象之前配置日志记录

此示例使用 dictConfig() 创建类似于Flask默认的日志记录配置，但所有日志除外：


from logging.config import dictConfig

dictConfig({
 'version': 1,
 'formatters': {
 'default': {
 'format': '[%(asctime)s] %(levelname)s \
in %(module)s: %(message)s ',
 }
 },
 'handlers': {
 'wsgi': {
 'class': 'logging.StreamHandler',
 'stream': 'ext://flask.logging.wsgi_errors_stream',
 'formatter': 'default'
 }
 },
 'root': {
 'level': 'INFO',
 'handlers': ['wsgi']
 }
})

app = Flask(__name__)

默认配置

如果您没有自己配置日志记录，Flask会自动将一个 StreamHandler 添加到 app.logger 。在请求期间，它将在environ ['wsgi.errors']（通常是 sys.stderr ）中写入由WSGI服务器指定的流。在请求之外，它将记录到 sys.stderr 。

移除默认的Handler

如果您在访问 app.logger 后配置了日志记录，并且需要删除默认处理程序，则可以导入和删除它：


from flask.logging import default_handler

app.logger.removeHandler(default_handler)

向管理员发送电子邮件错误

在远程服务器上运行应用程序进行生产时，您可能不会经常查看日志消息。WSGI服务器可能会将日志消息发送到文件，如果用户告诉您出错，只要检查该文件就可以了。

要主动发现和修复错误，您可以配置 logging.handlers.SMTPHandler 以在记录错误和更高错误时发送电子邮件。


import logging
from logging.handlers import SMTPHandler

mail_handler = SMTPHandler(
 (
 'server',
 'server_port'
 ),
 fromaddr='[email protected]',
 toaddrs=['[email protected]'],
 subject='Application Error',
 (
 'username',
 'password'
 )
)

mail_handler.setLevel(logging.ERROR)
mail_handler.setFormatter(logging.Formatter('[%(asctime)s] %(levelname)s \
in %(module)s: %(message)s '))

if not app.debug:
 app.logger.addHandler(mail_handler)

这要求您在同一服务器上设置SMTP服务器。有关配置处理程序的更多信息，请参阅Python文档。

注入请求信息

查看有关请求的更多信息（例如IP地址）可能有助于调试某些错误。您可以将 logging.Formatter 子类化为注入可以在消息中使用的自己的字段。您可以更改Flask的默认处理程序，上面定义的邮件处理程序或任何其他处理程序的格式化程序。


from flask.logging import default_handler

from flask import (
 has_request_context,
 request
)

def logging_common_formatter():
 class RequestFormatter(logging.Formatter):

 def format(self, record):
 if has_request_context():
 record.url = request.url
 record.remote_addr = request.remote_addr
 else:
 record.url = None
 record.remote_addr = None

 return super().format(record)

 formatter = RequestFormatter(
 '[%(asctime)s] %(remote_addr)s requested %(url)s\n'
 '%(levelname)s in %(module)s: %(message)s'
 )

 return formatter

formatter = logging_common_formatter()
mail_handler.setFormatter(formatter)
default_handler.setFormatter(formatter)

其他库

其他库可能会广泛使用日志记录，您也希望从这些日志中查看相关消息。最简单的方法是将处理程序添加到root记录器而不是仅添加应用程序记录器。


from flask.logging import default_handler

root = logging.getLogger()
root.addHandler(default_handler)
root.addHandler(mail_handler)

根据您的项目，配置您关注的每个记录器可能更有用，而不是仅配置root记录器。


for logger in (
 app.logger,
 logging.getLogger('sqlalchemy'),
 logging.getLogger('other_package'),
):
 logger.addHandler(default_handler)
 logger.addHandler(mail_handler)

Werkzeug

Werkzeug将基本请求/响应信息记录到'werkzeug'记录器。如果root记录器没有配置处理程序，Werkzeug会将 StreamHandler 添加到其记录器中。

Flask扩展

根据具体情况，扩展程序可以选择记录到app.logger或其自己的命名记录程序。有关详细信息，请参阅每个扩展的文档。

Flask 1.0 进阶 - 应用程序错误

Tue, 29 Jul 2025 10:55:48 +0800

应用程序失败，服务器失败迟早你会看到生产中的例外情况。即使您的代码100％正确，您仍会不时看到异常。为什么？因为所涉及的一切都会失败。以下是一些完美的代码可能导致服务器错误的情况：

客户端提前终止了请求，应用程序仍然从传入的数据中读取
数据库服务器挂了，无法处理查询
文件系统已满
一个硬盘崩溃了
一个后端服务器挂了
正在使用的库中出现了编程错误
服务器与另一个系统的网络连接失败

这只是您可能面临的一小部分问题。那么我们如何处理这类问题呢？默认情况下，如果您的应用程序在生产模式下运行，Flask将为您显示一个非常简单的页面，并将异常记录到 logger 中。

但是你可以做的更多，我们将介绍一些更好的设置来处理错误。

错误记录工具

如果有足够多的用户遇到错误并且通常从不查看日志文件，那么发送错误邮件（即使仅针对关键邮件）也会变得无法控制。这就是我们建议使用Sentry处理应用程序错误的原因。它可以在GitHub上作为开源项目使用，也可以作为托管版本使用，您可以免费试用。Sentry聚合重复错误，捕获完整堆栈跟踪和本地变量以进行调试，并根据新错误或频率阈值向您发送邮件。

要使用Sentry，您需要安装具有额外Flask依赖性的raven客户端：


pip install raven[flask]

然后将其添加到Flask应用中：


from raven.contrib.flask import Sentry
sentry = Sentry(app, dsn='YOUR_DSN_HERE')

或者，如果您正在使用工厂，您也可以稍后启动它：


from raven.contrib.flask import Sentry
sentry = Sentry(dsn='YOUR_DSN_HERE')

def create_app():
 app = Flask(__name__)
 sentry.init_app(app)
 ...
 return app

需要使用从Sentry安装获得的DSN值替换YOUR_DSN_HERE值。

之后故障会自动报告给Sentry，您可以从那里收到错误通知。

错误处理程序

您可能希望在发生错误时向用户显示自定义错误页面。这可以通过注册错误处理程序来完成。

错误处理程序是返回响应的普通视图函数，但它不是为路由注册，而是注册在尝试处理请求时引发的异常或HTTP状态代码。

注册

通过使用errorhandler() 装饰函数来注册处理程序。或者使用 register_error_handler() 稍后注册该函数。请记住在返回响应时设置错误代码。


@app.errorhandler(werkzeug.exceptions.BadRequest)
def handle_bad_request(e):
 return 'bad request!', 400

# or, without the decorator
app.register_error_handler(400, handle_bad_request)

werkzeug.exceptions.HTTPException 子类如 BadRequest 及其HTTP代码在注册处理程序时是可互换的。（BadRequest.code == 400）

代码无法注册非标准HTTP代码，因为Werkzeug不知道它们。相反，使用适当的代码定义 HTTPException 的子类并注册并引发该异常类。


class InsufficientStorage(werkzeug.exceptions.HTTPException):
 code = 507
 description = 'Not enough storage space.'

app.register_error_handler(InsuffcientStorage, handle_507)

raise InsufficientStorage()

可以为任何异常类注册处理程序，而不仅仅是HTTPException子类或HTTP状态代码。可以为特定类或父类的所有子类注册处理程序。

处理

当Flask在处理请求时捕获到异常时，首先按代码查找。如果没有为代码注册处理程序，则按类层次结构查找;选择最具体的处理程序。如果未注册任何处理程序，则HTTPException 子类显示有关其代码的通用消息，而其他异常则转换为通用500内部服务器错误。

例如，如果引发了 ConnectionRefusedError 的实例，并且为 ConnectionError 和 ConnectionRefusedError 注册了处理程序，则使用异常实例调用更具体的 ConnectionRefusedError 处理程序以生成响应。

在blueprint上注册的处理程序优先于在应用程序上全局注册的处理程序，假设blueprint正在处理引发异常的请求。但是，blueprint无法处理404路由错误，因为404可以在确定blueprint之前发生在路由级别。

版本0.11：处理程序的优先级取决于它们注册的异常类的特殊性，而不是它们注册的顺序

日志记录

有关如何记录异常的信息，请参阅记录，例如通过电子邮件将其发送给管理员。

调试应用程序错误

对于生产应用程序，使用应用程序错误中所述的日志记录和通知配置应用程序。本节提供了调试部署配置和深入挖掘全功能Python调试器的指针。

当有疑问时，手动运行

在为生产配置应用程序时遇到问题？如果您具有对主机的shell访问权限，请验证您是否可以从部署环境中的shell手动运行应用程序。请确保在与配置的部署相同的用户帐户下运行，以解决权限问题。您可以在生产主机上使用带有 debug = True 的Flask内置开发服务器，这有助于捕获配置问题，但 请务必在受控环境中暂时执行此操作 。不要使用 debug = True 在生产中运行。

使用调试器

为了深入挖掘，可能需要跟踪代码执行，Flask提供了一个开箱即用的调试器（参见调试模式）。如果您想使用其他Python调试器，请注意调试器会相互干扰。您必须设置一些选项才能使用您喜欢的调试器：

debug - 是否启用调试模式和捕获异常
use_debugger - 是否使用内部Flask调试器
use_reloader - 是否在异常时重新加载和分叉进程

debug必须为True（即必须捕获异常）才能使其他两个选项具有任何值。

如果您使用Aptana/Eclipse进行调试，则需要将use_debugger和use_reloader都设置为False。

一个可能有用的配置模式是在config.yaml中设置以下内容（当然，根据您的应用程序更改块）：


FLASK:
 DEBUG: True
 DEBUG_WITH_APTANA: True

然后在你的应用程序的入口点（main.py），你可以有类似的东西：


if __name__ == "__main__":
 # To allow aptana to receive errors, set use_debugger=False
 app = create_app(config="config.yaml")

 if app.debug: use_debugger = True
 try:
 # Disable Flask's debugger if external debugger is requested
 use_debugger = not(app.config.get('DEBUG_WITH_APTANA'))
 except:
 pass

 app.run(use_debugger=use_debugger, debug=app.debug,
 use_reloader=use_debugger, host='0.0.0.0')

Flask 1.0 进阶 - 测试Flask应用程序

Tue, 29 Jul 2025 10:55:45 +0800

“未经测试的东西被打破了”

这句话的起源是未知的，虽然它并不完全正确，但它也离真相不远。未经测试的应用程序使得现有代码难以改进，未经测试的应用程序的开发人员往往变得非常偏执。如果应用程序具有自动化测试，您可以安全地进行更改，并立即知道是否有任何中断。

Flask提供了一种方法来测试您的应用程序，方法是暴露Werkzeug测试Client并为您处理上下文本地。然后，您可以将其与您喜欢的测试解决方案一起使用。

在本分享中，我们将使用pytest包作为测试的基础框架。您可以使用pip安装它，如下所示：


pip install pytest

应用程序

首先，我们需要一个应用程序来测试;我们将使用教程中的应用程序。如果您还没有该应用程序，请从示例中获取源代码。

测试骨架搭建

我们首先在应用程序根目录下添加一个tests目录(如果有的话可以不用创建)。然后创建一个Python文件来存储我们的测试（test_baby.py）。当我们格式化文件名如test_*.py时，它将被pytest自动发现。

接下来，我们创建一个名为 client() 的pytest fixture，它配置应用程序以进行测试并初始化一个新的数据库，代码如下：


#! _*_ coding: utf-8 _*_
#
#

import os
import tempfile
import pytest
from baby import create_app
from baby.db import init_db, get_db

with open(os.path.join(os.path.dirname(__file__), 'data.sql'), 'rb') as f:
 _data_sql = f.read().decode('utf8')

@pytest.fixture
def client():
 db_fd, db_path = tempfile.mkstemp()

 app = create_app({
 'DATABASE': db_path,
 'TESTING': True
 })

 client = app.test_client()

 with app.app_context():
 init_db()
 get_db().executescript(_data_sql)

 yield client

 os.close(db_fd)
 os.unlink(app.config['DATABASE'])

每个单独的测试将调用此client fixture。它为我们提供了一个简单的应用程序接口，我们可以在其中触发对应用程序的测试请求。client还将为我们跟踪cookie。

在设置过程中，TESTING配置标志被激活。这样做是在请求处理期间禁用错误捕获，以便在对应用程序执行测试请求时获得更好的错误报告。

因为SQLite3是基于文件系统的，所以我们可以轻松地使用tempfile模块来创建临时数据库并对其进行初始化。mkstemp()函数为我们做了两件事：它返回一个低级文件句柄和一个随机文件名，后者我们用作数据库名。我们必须保持db_fd，以便我们可以使用 os.close() 函数来关闭文件。

要在测试后删除数据库，fixture会关闭文件并将其从文件系统中删除。

如果我们现在运行测试组件，我们应该看到以下输出：


$ pytest tests/test_baby.py
======================================== test session starts ======================================
platform darwin -- Python 3.6.5, pytest-4.4.0, py-1.8.0, pluggy-0.9.0
rootdir: /Users/durban/python/baby, inifile: setup.cfg
collected 0 items

==================================== no tests ran in 0.05 seconds =================================

即使它没有运行任何实际测试，我们已经知道我们的flaskr应用程序在语法上是有效的，否则导入将因异常而结束。

测试数据库

现在是时候开始测试应用程序的功能了。如果我们访问应用程序的根目录（/），让我们检查应用程序是否显示“Baby”。为此，我们向test_baby.py添加了一个新的测试函数，如下所示：


def test_empty_db(client):
 rv = client.get('/')
 assert b'Baby' in rv.data

请注意，我们的测试函数以单词test开头;这允许pytest自动将函数识别为要运行的测试。

通过使用client.get，我们可以使用给定路径向应用程序发送HTTP GET请求。返回值将是response_class对象。我们现在可以使用data属性来检查应用程序的返回值（作为字符串）。在这种情况下，我们确保“No entries here so far”是输出的一部分。

再次运行它，您应该看到一个通过测试：


$ pytest -v tests/test_baby.py
======================= test session starts ========================
platform darwin -- Python 3.6.5, pytest-4.4.0, py-1.8.0, pluggy-0.9.0 -- /Users/durban/python/baby/.env3/bin/python3
cachedir: .pytest_cache
rootdir: /Users/durban/python/baby, inifile: setup.cfg
collected 1 item

tests/test_baby.py::test_empty_db PASSED [100%]

===================== 1 passed in 0.10 seconds =====================

测试登录和注销

我们的应用程序的大部分功能仅适用于管理用户，因此我们需要一种方法来将我们的测试客户端记录到应用程序中。为此，我们使用所需的表单数据（用户名和密码）向登录和注销页面发出一些请求。并且由于登录和注销页面重定向，我们告诉客户端follow_redirects

将以下类添加到test_baby.py文件中：


class AuthActions(object):
 def __init__(self, client):
 self._client = client

 def login(self, username='test', password='test'):
 return self._client.post(
 '/auth/login',
 data={'username': username, 'password': password}
 )

 def logout(self):
 return self._client.get('/auth/logout')

现在，我们可以轻松地测试登录和注销是否正常工作，以及它是否因无效凭据而失败。添加这个新的测试功能：


def test_login(client, auth):
 auth.login('test', 'test')
 with client:
 client.get('/')
 assert session['user_id'] == 1

 rv = auth.login('testx', 'test')
 print(rv.data)
 assert b'Incorrect username' in rv.data

 rv = auth.login('test', 'testx')
 print(rv.data)
 assert b'Incorrect password' in rv.data

def test_logout(client, auth):
 auth.login('test', 'test')
 with client:
 rv = auth.logout()
 assert 'user_id' not in session

再次运行测试得到如下结果


$ pytest -v tests/test_baby.py
=========================== test session starts ============================
platform darwin -- Python 3.6.5, pytest-4.4.0, py-1.8.0, pluggy-0.9.0 -- /Users/durban/python/baby/.env3/bin/python3
cachedir: .pytest_cache
rootdir: /Users/durban/python/baby, inifile: setup.cfg
collected 3 items

tests/test_baby.py::test_empty_db PASSED [ 33%]
tests/test_baby.py::test_login PASSED [ 66%]
tests/test_baby.py::test_logout PASSED [100%]

========================= 3 passed in 0.71 seconds =========================

测试添加帖子

我们还应该测试添加帖子是否有效。添加一个新的测试函数，如下所示：


def test_add_post(client, auth):
 auth.login()
 with client:
 rv = client.post('/create', data=dict(
 title='<Hello>',
 body='<strong>Html</strong> is here'
 ), follow_redirects=True)

 assert b'&lt;strong&gt;Html&lt;/strong&gt; is here' in rv.data

 assert b'&lt;Hello&gt;' in rv.data

在这里，我们检查文本中是否允许HTML，而不是标题中的HTML，这是预期的行为。

运行它现在应该给我们四个通过测试：


$ pytest -v tests/test_baby.py
=================== test session starts ====================
platform darwin -- Python 3.6.5, pytest-4.4.0, py-1.8.0, pluggy-0.9.0 -- /Users/durban/python/baby/.env3/bin/python3
cachedir: .pytest_cache
rootdir: /Users/durban/python/baby, inifile: setup.cfg
collected 4 items

tests/test_baby.py::test_empty_db PASSED [ 25%]
tests/test_baby.py::test_login PASSED [ 50%]
tests/test_baby.py::test_logout PASSED [ 75%]
tests/test_baby.py::test_add_post PASSED [100%]

================= 4 passed in 0.71 seconds =================

其他测试技巧

除了使用如上所示的测试client之外，还有test_request_context()方法，该方法可以与with语句结合使用以临时激活请求上下文。通过这种方式，您可以访问request，g和session对象，例如视图函数。以下是演示此方法的完整示例：


import flask

app = flask.Flask(__name__)

with app.test_request_context('/?name=Peter'):
 assert flask.request.path == '/'
 assert flask.request.args['name'] == 'Peter'

可以以相同的方式使用上下文绑定的所有其他对象。

如果要使用不同的配置测试应用程序并且似乎没有好的方法，请考虑切换到应用程序工厂（请参阅应用程序工厂）。

但请注意，如果使用测试请求上下文，则不会自动调用before_request()和after_request()函数。但是，当测试请求上下文离开with块时，确实执行了teardown_request()函数。如果你确实想要调用before_request()函数，你需要自己调用preprocess_request()：


app = flask.Flask(__name__)

with app.test_request_context('/?name=Peter'):
 app.preprocess_request()
 ...

根据应用程序的设计方式，这可能是打开数据库连接或类似连接所必需的。

如果要调用after_request()函数，则需要调用preprocess_request()，但是要求您将响应对象传递给它：


app = flask.Flask(__name__)

with app.test_request_context('/?name=Peter'):
 resp = Response('...')
 resp = app.process_response(resp)
 ...

这通常不太有用，因为此时您可以直接开始使用测试客户端。

伪造资源和上下文

一种非常常见的模式是在应用程序上下文或flask.g对象上存储用户授权信息和数据库连接。一般的模式是在第一次使用时将对象放在那里，然后在拆卸时将其移除。想象一下这个代码来获取当前用户：


def get_user():
 user = getattr(g, 'user', None)
 if user is None:
 user = fetch_current_user_from_database()
 g.user = user
 return user

对于测试，从外部覆盖此用户而不必更改某些代码将是很好的。这可以通过挂钩flask.appcontext_pushed信号来完成：


from contextlib import contextmanager
from flask import appcontext_pushed, g

@contextmanager
def user_set(app, user):
 def handler(sender, **kwargs):
 g.user = user
 with appcontext_pushed.connected_to(handler, app):
 yield

然后想下面这样使用它


from flask import json, jsonify

@app.route('/users/me')
def users_me():
 return jsonify(username=g.user.username)

with user_set(app, my_user):
 with app.test_client() as c:
 resp = c.get('/users/me')
 data = json.loads(resp.data)
 self.assert_equal(data['username'], my_user.username)

保持上下文环境

有时触发常规请求保持上下文环境会有所帮助，但仍会将上下文保持一段时间，以便进行额外的内省。使用Flask 0.4，可以使用带有with块的test_client()：


app = flask.Flask(__name__)

with app.test_client() as c:
 rv = c.get('/?tequila=42')
 assert request.args['tequila'] == '42'

如果您只使用不带with块的test_client()，则断言将失败并显示错误，因为请求不再可用（因为您尝试在实际请求之外使用它）。

访问和修改会话

有时，从测试客户端访问或修改会话非常有用。通常有两种方法。如果您只是想确保某个会话将某些键设置为某些值，您可以保持上下文并访问flask.session：


with app.test_client() as c:
 rv = c.get('/')
 assert flask.session['foo'] == 42

但是，这无法在发出请求之前修改会话或访问会话。从Flask 0.8开始，我们提供了一个所谓的“会话事务”，它模拟在测试客户端上下文中打开会话的相应调用并对其进行修改。在事务结束时存储会话。这与所使用的会话后端无关：


with app.test_client() as c:
 with c.session_transaction() as sess:
 sess['a_key'] = 'a value'

 # once this is reached the session was stored

请注意，在这种情况下，您必须使用sess对象而不是flask.session代理。然而，对象本身将提供相同的接口。

测试JSON API

Flask非常支持JSON，是构建JSON API的流行选择。使用JSON数据发出请求并检查响应中的JSON数据非常方便：


from flask import request, jsonify

@app.route('/api/auth')
def auth():
 json_data = request.get_json()
 email = json_data['email']
 password = json_data['password']
 return jsonify(token=generate_token(email, password))

with app.test_client() as c:
 rv = c.post('/api/auth', json={
 'username': 'flask', 'password': 'secret'
 })
 json_data = rv.get_json()
 assert verify_token(email, json_data['token'])

在测试客户端方法中传递json参数将请求数据设置为JSON序列化对象，并将内容类型设置为application/json。您可以使用get_json从请求或响应中获取JSON数据。

测试CLI命令

Click附带了用于测试CLI命令的实用程序。CliRunner独立运行命令并捕获Result对象中的输出。

Flask提供了test_cli_runner()来创建FlaskCliRunner，它自动将Flask应用程序传递给CLI。使用其invoke()方法以与从命令行调用命令相同的方式调用命令。


import click

@app.cli.command('hello')
@click.option('--name', default='World')
def hello_command(name)
 click.echo(f'Hello, {name}!')

def test_hello():
 runner = app.test_cli_runner()

 # invoke the command directly
 result = runner.invoke(hello_command, ['--name', 'Flask'])
 assert 'Hello, Flask' in result.output

 # or by name
 result = runner.invoke(args=['hello'])
 assert 'World' in result.output

在上面的示例中，按名称调用命令很有用，因为它验证命令是否已正确注册到应用程序。

如果要测试命令如何解析参数而不运行命令，请使用其make_context()方法。这对于测试复杂的验证规则和自定义类型很有用。


def upper(ctx, param, value):
 if value is not None:
 return value.upper()

@app.cli.command('hello')
@click.option('--name', default='World', callback=upper)
def hello_command(name)
 click.echo(f'Hello, {name}!')

def test_hello_params():
 context = hello_command.make_context('hello', ['--name', 'flask'])
 assert context.params['name'] == 'FLASK'

Flask 1.0 进阶 - 模板

Tue, 29 Jul 2025 10:55:42 +0800

Flask利用Jinja2作为模板引擎。你显然可以自由使用不同的模板引擎，但你仍然需要安装Jinja2来运行Flask本身。此要求是启用丰富扩展所必需的。扩展可以依赖于Jinja2存在。

本节仅简要介绍Jinja2如何集成到Flask中。如果您需要有关模板引擎语法本身的信息，请访问官方Jinja2模板文档以获取更多信息。

Jinja 设置

除非定制，否则Jinja2由Flask配置如下：

使用render_template()时，对于以.html，.htm，.xml和.xhtml结尾的所有模板启用自动过滤。
使用render_template_string()时，为所有字符串启用自动过滤。
模板可以使用{％autoescape％}标记选择使用火不适用自动过滤。
除了默认存在的值之外，Flask还将一些全局函数和帮助程序插入到Jinja2上下文中。

标准上下文

默认情况下，Jinja2模板中提供以下全局变量：

config


当前配置对象(**flask.config**)

request


当前请求对象（**flask.request**）。如果在没有活动请求上下文的情况下呈现模板，则此变量不可用。

session


当前session对象（**flask.session**）。如果在没有活动请求上下文的情况下呈现模板，则此变量不可用。


全局变量的请求绑定对象（**flask.g**）。如果在没有活动请求上下文的情况下呈现模板，则此变量不可用。

url_for()


**flask.url_for()**函数

get_flash_messages()


**flask.get_flash_messages()**函数

Jinja上下文行为

这些变量被添加到变量的上下文中，它们不是全局变量。不同之处在于，默认情况下这些不会显示在导入模板的上下文中。这部分是由性能考虑因素造成的，部分原因是为了使事情明确。

这对你意味着什么？如果您有要导入的宏，则需要访问请求对象，您有两种可能：

您将request显式的传递给macro作为参数，或您感兴趣的请求对象的属性。

你可以用"with context"导入macro。

使用上下文导入如下所示：

{% from '_helpers.html' import my_macro with context %}

标准过滤器

除了Jinja2本身提供的过滤器之外，Jinja2还提供了这些过滤器：

tojson

此函数将给定对象转换为JSON表示。例如，如果您尝试动态生成JavaScript，这将非常有用。

请注意，内部脚本标记必须不进行转义，因此如果您打算在script标记内使用它，请确保在Flask 0.10之前禁用转义|safe;


<script type=text/javascript>
	doSomethingWith({{ user.username|tojson|safe }});
</script>

控制自动过滤

自动过滤是为您自动转义特殊字符的概念。HTML（或XML，因此XHTML）意义上的特殊字符是＆，>，<，'以及"。因为这些字符本身在文档中具有特定含义，所以如果要将它们用于文本，则必须用所谓的“entities”替换它们。不这样做不仅会导致用户因无法在文本中使用这些字符而感到沮丧，而且还会导致安全问题。（请参阅跨站点脚本（XSS））。

但有时您需要在模板中禁用自动转换。如果您想要将HTML显式地插入到页面中，例如，如果它们来自生成安全HTML的系统（如HTML转换器的markdown），则可能出现这种情况。

有三种方法可以实现这一目标：

在Python代码中，将HTML字符串包装在Markup对象中，然后再将其传递给模板。这通常是推荐的方式。
在模板内部，使用|safe过滤器将字符串显式标记为安全HTML（{{myvariable | safe}}）
暂时禁用autoescape系统。

要在模板中禁用autoescape系统，您可以使用{％autoescape％}块：


{% autoescape false %}
 <p>autoescaping is disabled here
 <p>{{ will_not_be_escaped }}
{% endautoescape %}

无论何时执行此操作，请对此块中使用的变量非常谨慎。

注册过滤器

如果您想在Jinja2中注册自己的过滤器，您有两种方法可以做到这一点。您可以手动将它们放入应用程序的jinja_env中，也可以使用template_filter())装饰器。

以下两个示例的工作方式相同，都反转了一个对象：


@app.template_filter('reverse')
def reverse_filter(s):
 return s[::-1]

def reverse_filter(s):
 return s[::-1]
app.jinja_env.filters['reverse'] = reverse_filter

在装饰器的情况下，如果要将函数名称用作过滤器的名称，则参数是可选的。注册后，您可以像使用Jinja2的内置过滤器一样在模板中使用过滤器，例如，如果您在上下文中有一个名为mylist的Python列表：


{% for x in mylist | reverse %}
{% endfor %}

上下文处理器

要将新变量自动注入模板的上下文，Flask中存在上下文处理器。上下文处理器在呈现模板之前运行，并且能够将新值注入模板上下文。上下文处理器是一个返回字典的函数。然后，对于应用程序中的所有模板，此字典的键和值将与模板上下文合并：


@app.context_processor
def inject_user():
 return dict(user=g.user)

上面的上下文处理器在模板中创建了一个名为user的变量，其值为g.user。这个例子不是很有趣，因为无论如何g都可以在模板中使用，但它可以让我知道这是如何工作的。

变量不限于数值;上下文处理器也可以使函数可用于模板（因为Python允许传递函数）：


@app.context_processor
def utility_processor():
 def format_price(amount, currency=u'€'):
 return u'{0:.2f}{1}'.format(amount, currency)
 return dict(format_price=format_price)

上面的上下文处理器使format_price函数可用于所有模板：


{{ format_price(0.33) }}

您还可以将format_price构建为模板过滤器（请参阅注册过滤器），但这演示了如何在上下文处理器中传递函数。

Flask 1.0 新手教程 - 持续开发

Tue, 29 Jul 2025 10:55:39 +0800

你已经通过此教程学了一部分关于Flask和Python的概念。返回去再重新看下新手教程一步一步对比下你的代码，将您的项目与示例项目进行比较，由于本教程的逐步特性，该项目可能看起来有点不同

Flask比你到目前为止看到的要多得多。即便如此，您现在已经准备好开始开发自己的Web应用程序了。查看快速入门，了解Flask可以做些什么，然后深入了解文档以继续学习。Flask在幕后使用Jinja，Click，Werkzeug和ItsDangerous，它们都有自己的文档。您还会对Extensions感兴趣，它可以使用数据库或验证表单数据等任务变得更容易，更强大。

如果您想继续开发Baby项目，可以参考以下内容：

一个展示帖子详情的视图，点击帖子的标题跳转到这个页面
喜欢/不喜欢帖子
评论
标签。点击一个标签显示所有关于这个标签的帖子
一个搜索框，能够通过名称过滤帖子
分页。一个页面只显示5个帖子
上传图片以配合帖子。
使用Markdown格式化帖子。
新帖子的RSS提要。

玩得开心，制作更加出色的应用程序！

完结。

Flask 1.0 新手教程 - 部署到生产环境

Tue, 29 Jul 2025 10:55:35 +0800

这部分假设你有一台可以部署你应用的服务器，它概述了如何创建分发文件并进行安装，但不会详细介绍要使用的服务器或软件。您可以在开发计算机上设置新环境以尝试以下说明，但可能不应将其用于托管真实的公共应用程序。有关托管应用程序的许多不同方法的列表，请参阅部署选项。

构建和安装

如果要在其他位置部署应用程序，可以构建分发文件。Python发行版的当前标准是wheel格式，扩展名为.whl。确保首先安装了wheel库。


pip install wheel

使用Python运行setup.py为您提供了一个命令行工具来发出与构建相关的命令。bdist_wheel命令将构建一个wheel分配文件。


python setup.py bdist_wheel

运行完之后，将会在目录dist下发现一个文件baby-1.0.0-py3-none-any.whl。文件名是项目的名称，版本以及有关该文件的一些标记可以安装。

将此文件复制到另一台计算机，设置一个新的virtualenv，然后使用pip安装该文件。


pip install baby-1.0.0-py3-none-any.whl

Pip将安装您的项目及其依赖项。

由于这是一台不同的机器，因此需要再次运行init-db以在instance文件夹中创建数据库。


export FLASK_APP=baby
flask init-db

当Flask检测到它已安装（不是可编辑模式）时，它会为instance文件夹使用不同的目录。你可以在venv/var/baby-instance找到它。

配置私钥（Secret Key）

在本教程的第一篇分享中，为SECRET_KEY提供了默认值。生产环境中应该改为一些随机字节。否则，攻击者可以使用公共“dev”密钥来修改会话cookie或使用密钥的任何其他内容。

您可以使用以下命令输出随机密钥：


python -c 'import os; print(os.urandom(16))'
b'\x05\x81\xb5\xa2xln&\\\xb8\xda\xecY\x94\xef\xb5'

在instance文件夹中创建config.py文件，如果存在，工厂将从中读取该文件。将生成的值复制到其中。

venv/var/baby-instance/config.py


SECRET_KEY=b'\x05\x81\xb5\xa2xln&\\\xb8\xda\xecY\x94\xef\xb5'

你也可以在这里设置任何其他必要的配置，虽然SECRET_KEY是Baby唯一需要的配置。

运行生产环境服务器

在生产环境中而不是在开发环境中运行时，不应使用内置开发服务器（flask run）。开发服务器由Werkzeug提供以方便使用，但其设计不是特别高效，稳定或安全。

而是使用生产WSGI服务器。例如，要使用Waitress，请先在虚拟环境中安装它：


pip install waitress

您需要告诉Waitress您的应用程序，但它不像Flask运行那样使用FLASK_APP。您需要告诉它导入并调用应用程序工厂以获取应用程序对象。


waitress-serve --call 'baby:create_app'
Serving on http://0.0.0.0:8080

有关托管应用程序的许多不同方法的列表，请参阅部署选项。Waitress只是一个例子，因为它同时支持Windows和Linux。您可以为项目选择更多WSGI服务器和部署选项。

下一期继续 - 继续开发！

Flask 1.0 新手教程 - 测试覆盖率

Tue, 29 Jul 2025 10:55:32 +0800

为我们开发的程序写单元测试是为了检查我们写的代码能够按照我们希望的逻方式去运行。Flask提供了一个测试客户端来模拟请求到应用程序然后返回响应的数据。

您应该尽可能多地测试代码。函数中的代码仅在调用函数时运行，分支中的代码（如if块）仅在满足条件时运行。您希望确保使用涵盖每个分支的数据测试每个函数。

您越接近100％覆盖率，您就越容易做出改变,而这个改变不会意外地改变其他行为。但是，100％的覆盖率并不能保证您的应用程序没有错误。特别是，它不能监测到用户如何在浏览器中与应用程序交互。尽管如此，测试覆盖率是开发过程中使用的重要工具。

注意

这是在本教程后期介绍的，但在您将来的项目中，您应该在开发时进行测试。

您将使用pytest和coverage来测试和测量代码，安装命令如下：


pip install pytest coverage

Setup和Fixtures

测试代码放在了tests目录中，这个目录跟baby包同层级，不在包里面。tests/conftest.py文件包含了设置函数。tests/conftest.py文件包含每个测试将使用的称为fixture的设置函数。测试是在以test_开头的Python模块中，并且这些模块中的每个测试函数也以test_开头。

每个测试都将创建一个新的临时数据库文件，并填充将在测试中使用的一些数据。编写一个SQL文件来插入该数据。

tests/data.sql


INSERT INTO user (username, password)
VALUES
 ('test', 'pbkdf2:sha256:50000$TCI4GzcX$0de171a4f4dac32e3364c7ddc7c14f3e2fa61f2d17574483f7ffbb431b4acb2f'),
 ('other', 'pbkdf2:sha256:50000$kJPKsz6N$d2d4784f1b030a9761f5ccaeeaca413f27f2ecb76d6168407af962ddce849f79');

INSERT INTO post (title, body, author_id, created)
VALUES
 ('test title', 'test' || x'0a' || 'body', 1, '2019-01-01 00:00:00');

应用程序fixture将调用工厂并传递test_config以配置应用程序和数据库以进行测试，而不是使用本地开发配置。

tests/conftest.py


#! _*_ coding: utf-8 _*_
import os
import tempfile

import pytest
from baby import create_app
from baby.db import get_db, init_db

with open(os.path.join(os.path.dirname(__file__), 'data.sql'), 'rb') as f:
 _data_sql = f.read().decode('utf8')

@pytest.fixture
def app():
 db_fd, db_path = tempfile.mkstemp()

 app = create_app({
 'TESTING': True,
 'DATABASE': db_path
 })

 with app.app_context():
 init_db()
 get_db().executescript(_data_sql)

 yield app

 os.close(db_fd)
 os.unlink(db_path)

@pytest.fixture
def client(app):
 return app.test_client()

@pytest.fixture
def runner(app):
 return app.test_cli_runner()

tempfile.mkstemp()创建并打开一个临时文件，返回文件对象及其路径。重写DATABASE路径，因此它指向此临时路径而不是实例文件夹。设置路径后，将创建数据库表并插入测试数据。测试结束后，临时文件将被关闭并删除。

TESTING告诉Flask应用程序处于测试模式。Flask更改了一些内部行为，因此更容易测试，而其他扩展也可以使用该标志来更轻松地测试它们。

clientfixture使用appfixture创建的应用程序对象调用app.test_client()。测试将使用客户端向应用程序发出请求而不运行服务器。

runnerfixture与client类似。app.test_cli_runner()创建一个可以调用在应用程序中注册的Click命令的runner。

Pytest通过将其函数名称与测试函数中的参数名称进行匹配来使用fixture。例如，您接下来要编写的test_hello函数将使用client参数。Pytest与clientfixture函数匹配，调用它，并将返回的值传递给测试函数。

工厂

关于工厂本身的测试并不多。大多数代码都将针对每个测试执行，因此如果某些内容失败，其他测试将会受到影响。

唯一可以改变的行为是传递测试配置。如果未传递config，则应该有一些默认配置，否则应该重写配置。

tests/test_factory.py


#! _*_ coding: utf-8 _*_

from baby import create_app

def test_config():
 assert not create_app().testing
 assert create_app({'TESTING': True}).testing

def test_baby(client):
 response = client.get('/baby')
 assert response.data == b'Baby'

在本教程开头编写工厂时，您添加了baby路由作为示例。它返回“Baby”，因此测试检查响应数据是否匹配。

数据库

在应用程序上下文中，get_db应在每次调用时返回相同的连接。在上下文之后，应该关闭连接。

tests/test_db.py


#! _*_ coding: utf-8 _*_
import sqlite3

import pytest

from baby.db import get_db

def test_get_close_db(app):
 with app.app_context():
 db = get_db()
 assert db is get_db()

 with pytest.raises(sqlite3.ProgrammingError) as e:
 db.execute('SELECT 1')

 assert 'closed' in str(e)

init-db命令应调用init_db函数并输出消息。


def test_init_db_command(runner, monkeypatch):
 class Recorder(object):
 called = False

 def fake_init_db():
 Recorder.called = True

 monkeypatch.setattr('baby.db.init_db', fake_init_db)
 result = runner.invoke(args=['init-db'])
 assert 'Initialized' in result.output
 assert Recorder.called

此测试使用Pytest的monkeypatchfixture将init_db函数替换为记录它已被调用的函数。您在上面编写的runner命令用于按名称调用init-db命令。

认证

对于大多数视图，用户需要登录。在测试中执行此操作的最简单方法是使用客户端向login视图发出POST请求。您可以编写一个包含方法的类，而不是每次都写出来，并使用fixture将每个测试的客户端传递给它。

tests/conftest.py


class AuthActions(object):
 def __init__(self, client):
 self._client = client

 def login(self, username='test', password='test'):
 return self._client.post(
 '/auth/login',
 data={'username': username, 'password': password}
 )

 def logout(self):
 return self._client.get('/auth/logout')

@pytest.fixture
def auth(client):
 return AuthActions(client)

使用authfixture，您可以在测试中调用auth.login()以作为测试用户登录，该测试用户作为测试数据的一部分插入到app fixture中。

register视图应在GET上成功渲染。在具有有效表单数据的POST上，它应该重定向到登录URL，并且用户的数据应该在数据库中。无效数据应显示错误消息。

tests/test_auth.py


#! _*_ coding: utf-8 _*_

import pytest

from flask import g, session
from baby.db import get_db

def test_register(client, app):
 assert client.get('/auth/register').status_code == 200
 response = client.post(
 '/auth/register', data={'username':'a','password':'a'}
 )
 assert 'http://localhost/auth/login' == response.headers['Location']

 with app.app_context():
 assert get_db().execute(
 "SELECT * FROM user WHERE username = 'a'"
 ).fetchone() is not None

@pytest.mark.parametrize(('username', 'password', 'message'), (
 ('', '', b'Username is required'),
 ('a', '', b'Password is required'),
 ('test', 'test', b'already registered'),
))
def test_register_validate_input(client, username, password, message):
 response = client.post(
 '/auth/register',
 data={'username':username, 'password': password}
 )
 assert message in response.data

client.get()发出GET请求并返回Flask返回的Response对象。类似地，client.post()发出POST请求，将data字典转换为表单数据。

要测试页面是否渲染成功，可以发出一个简单的请求并检查200 OK状态码。如果渲染失败，Flask将返回500内部服务器错误代码。

当注册视图重定向到登录视图时，header将是一个带有登录URL的Location标头。

data包含响应的主体作为字节。如果您希望在页面上呈现某个值，请检查它是否在数据中。必须将字节与字节进行比较。如果要比较Unicode文本，请改用get_data(as_text = True)。

pytest.mark.parametrize告诉Pytest使用不同的参数运行相同的测试函数。您可以在此处使用它来测试不同的无效输入和错误消息，而无需编写相同的代码三次。

login视图的测试与register的测试非常相似。session应该在登录后设置user_id，而不是测试数据库中的数据。

tests/test_auth.py


def test_login(client, auth):
 assert client.get('/auth/login').status_code == 200
 response = auth.login()
 assert 'http://localhost/' == response.headers['Location']

 with client:
 client.get('/')
 assert session['user_id'] == 1
 assert g.user['username'] == 'test'

@pytest.mark.parametrize(('username', 'password', 'message'),(
 ('a', 'test', b'Incorrect username.'),
 ('test', 'a', b'Incorrect password.'),
))
def test_login_validate_input(auth, username, password, message):
 response = auth.login(username, password)
 assert message in response.data

在with块中使用client允许在返回响应后访问上下文变量，例如session。通常，访问请求之外的session会引发错误。

测试logout与login相反。注销后，session不应包含user_id。

tests/test_auth.py


def test_logout(client, auth):
 auth.login()
 with client:
 auth.logout()
 assert 'user_id' not in session

博客

所有博客视图都使用之前编写的auth fixture。调用auth.login()以及来自客户端的后续请求将作为测试用户登录。

index视图应显示有关随测试数据添加的帖子的信息。以作者身份登录时，应该有一个链接来编辑帖子。

还可以在测试index视图时测试更多身份验证行为。未登录时，每个页面都会显示登录或注册的链接。登录后，会有一个注销链接。

tests/test_blog.py


#! _*_ coding: utf-8 _*_

import pytest
from baby.db import get_db

def test_index(client, auth):
 response = client.get('/')
 assert b'Log In' in response.data
 assert b'Register' in response.data

 auth.login()
 response = client.get('/')

 assert b'Log Out' in response.data
 assert b'test title' in response.data
 assert b'by test on 2019-01-01' in response.data
 assert b'test\nbody' in response.data
 assert b'href="/1/update"' in response.data

create,update,delete视图必须在用户登录后才能访问，update和delete视图必须在登录的用户是帖子的作者时才能被访问，否则返回403 Forbidden状态。如果post请求是给传递的id不存在，则update和delete视图应该返回404 Not Found状态。

tests/test_blog.py


@pytest.mark.parametrize('path', (
 '/create',
 '/1/update',
 '/1/delete'
))
def test_login_required(client, path):
 response = client.post(path)
 assert 'http://localhost/auth/login' == response.headers['Location']

def test_author_required(app, client, auth):
 with app.app_context():
 db = get_db()
 db.execute(
 'UPDATE post SET author_id = 2 WHERE id = 1'
 )
 db.commit()

 auth.login()

 assert client.post('/1/update').status_code == 403
 assert client.post('/1/delete').status_code == 403

 assert b'href="/1/update"' not in client.get('/').data

@pytest.mark.parametrize('path', (
 ('/2/update'),
 ('/2/delete')
))
def test_exists_required(client, auth, path):
 auth.login()
 assert client.post(path).status_code == 404

create和update视图在GET请求时应该渲染并返回200 OK状态。当有效的数据通过POST请求提交时，create视图应该输入新的数据到数据库，update视图应该修改存在的数据。两个视图在遇到无效的数据提交时应该显示错误信息。

tests/test_blog.py


def test_create(client, auth, app):
 auth.login()
 assert client.get('/create').status_code == 200

 client.post('/create', data={'title':'created','body':''})

 with app.app_context():
 db = get_db()
 count = db.execute('SELECT COUNT(id) FROM post').fetchone()[0]
 assert count == 2

def test_update(app, client, auth):
 auth.login()
 assert client.get('/1/update').status_code == 200
 client.post('/1/update', data={'title':'updated', 'body': ''})

 with app.app_context():
 db = get_db()
 post = db.execute('SELECT * FROM post WHERE id = 1').fetchone()
 assert post['title'] == 'updated'

@pytest.mark.parametrize('path', (
 '/create',
 '/1/update'
))
def test_create_update_validate(client, auth, path):
 auth.login()
 response = client.post(path, data={'title': '', 'body': ''})
 assert b'Title is required' in response.data

delete视图应该重新到index URL，并且数据库不应该存在该帖子。

tests/test_blog.py


def test_delete(app, client, auth):
 auth.login()
 response = client.post('/1/delete')
 assert response.headers['Location'] == 'http://localhost/'

 with app.app_context():
 db = get_db()
 post = db.execute('SELECT * FROM post WHERE id = 1').fetchone()
 assert post is None

运行测试

可以将一些额外的配置添加到项目的setup.cfg文件中，这些配置不是必需的，但可以使运行测试的覆盖范围更加冗长。

setup.cfg


[tool:pytest]
testpaths = tests

[coverage:run]
branch = True
source = 
 baby

要运行测试，请使用pytest命令。它将查找并运行我们编写的所有测试函数。


$ pytest
============================== test session starts ==============================
platform darwin -- Python 3.6.5, pytest-4.4.0, py-1.8.0, pluggy-0.9.0
rootdir: /Users/durban/python/baby, inifile: setup.cfg, testpaths: tests
collected 24 items

tests/test_auth.py ........ [ 33%]
tests/test_blog.py ............ [ 83%]
tests/test_db.py .. [ 91%]
tests/test_factory.py .. [100%]

=========================== 24 passed in 1.83 seconds ===========================
(.env3)

如果任何测试失败，pytest将显示引发的错误。您可以运行pytest -v来获取每个测试函数的列表而不是点。


$ pytest -v
===================================== test session starts ======================================
platform darwin -- Python 3.6.5, pytest-4.4.0, py-1.8.0, pluggy-0.9.0 -- /Users/durban/python/baby/.env3/bin/python3
cachedir: .pytest_cache
rootdir: /Users/durban/python/baby, inifile: setup.cfg, testpaths: tests
collected 24 items

tests/test_auth.py::test_register PASSED [ 4%]
tests/test_auth.py::test_register_validate_input[--Username is required] PASSED [ 8%]
tests/test_auth.py::test_register_validate_input[a--Password is required] PASSED [ 12%]
tests/test_auth.py::test_register_validate_input[test-test-already registered] PASSED [ 16%]
tests/test_auth.py::test_login PASSED [ 20%]
tests/test_auth.py::test_login_validate_input[a-test-Incorrect username.] PASSED [ 25%]
tests/test_auth.py::test_login_validate_input[test-a-Incorrect password.] PASSED [ 29%]
tests/test_auth.py::test_logout PASSED [ 33%]
tests/test_blog.py::test_index PASSED [ 37%]
tests/test_blog.py::test_login_required[/create] PASSED [ 41%]
tests/test_blog.py::test_login_required[/1/update] PASSED [ 45%]
tests/test_blog.py::test_login_required[/1/delete] PASSED [ 50%]
tests/test_blog.py::test_author_required PASSED [ 54%]
tests/test_blog.py::test_exists_required[/2/update] PASSED [ 58%]
tests/test_blog.py::test_exists_required[/2/delete] PASSED [ 62%]
tests/test_blog.py::test_create PASSED [ 66%]
tests/test_blog.py::test_update PASSED [ 70%]
tests/test_blog.py::test_create_update_validate[/create] PASSED [ 75%]
tests/test_blog.py::test_create_update_validate[/1/update] PASSED [ 79%]
tests/test_blog.py::test_delete PASSED [ 83%]
tests/test_db.py::test_get_close_db PASSED [ 87%]
tests/test_db.py::test_init_db_command PASSED [ 91%]
tests/test_factory.py::test_config PASSED [ 95%]
tests/test_factory.py::test_baby PASSED [100%]

================================== 24 passed in 1.94 seconds ===================================
(.env3)

要测量测试的代码覆盖率，请使用coverage命令运行pytest而不是直接运行它。


coverage run -m pytest

您可以在终端中查看简单的覆盖率报告：


coverage report


$ coverage report
Name Stmts Miss Branch BrPart Cover
----------------------------------------------------
baby/__init__.py 25 1 4 1 93%
baby/auth.py 54 0 22 0 100%
baby/blog.py 54 0 16 0 100%
baby/db.py 24 0 4 0 100%
----------------------------------------------------
TOTAL 157 1 46 1 99%
(.env3)

HTML报告允许您查看每个文件中包含的行：


coverage html

这会在htmlcov目录中生成文件。在浏览器中打开htmlcov/index.html以查看报告。

下一期继续 - 部署到生产

Flask 1.0 新手教程 - 使项目可安装

Tue, 29 Jul 2025 10:09:53 +0800

使项目可安装意味着您可以构建分发文件并将其安装在另一个环境中，就像在项目环境中安装Flask一样。这使得部署项目与安装任何其他库相同，因此您使用所有标准Python工具来管理所有内容。

安装还带来了其他一些好处，这些好处可能在教程中或作为新的Python用户不明显，包括：

目前，Python和Flask只了解如何使用baby包，因为你是从项目目录运行的。安装意味着无论您从何处运行，都可以导入它。
您可以像管理其他软件包一样管理项目的依赖项，因此请安装yourproject.whl安装它们。
测试工具可以将您的测试环境与开发环境隔离开来。

注意

这是在本教程后期介绍的，但是在您将来的项目中，您应该始终从这开始。

项目描述

setup.py文件描述了您的项目以及属于它的文件。

setup.py


#! _*_ coding: utf-8 _*_

from setuptools import find_packages, setup

setup(
 name='baby',
 version='1.0.0',
 author='张大鹏',
 author_email='[email protected]',
 packages=find_packages(),
 include_package_data=True,
 zip_safe=False,
 install_requires=[
 'flask'
 ]
)

packages告诉Python要包含哪些包目录（以及它们包含的Python文件）。find_packages()自动查找这些目录，因此您不必键入它们。要包含其他文件，例如static和templates目录，请设置include_package_data。Python需要另一个名为MANIFEST.in的文件来告诉其他数据是什么。

MANIFEST.in


include baby/schema.sql
graft baby/static
graft baby/templates
global-exclude *.pyc

这告诉Python复制static和template目录以及schema.sql文件中的所有内容，但要排除所有字节码文件。

有关所用文件和选项的其他说明，请参阅官方包装指南。

安装项目

使用pip在虚拟环境中安装项目。


pip install -e .

这告诉pip在当前目录中找到setup.py并将其安装在可编辑或开发模式下。可编辑模式意味着当您对本地代码进行更改时，如果更改有关项目的元数据（例如其依赖项），则只需重新安装。

您可以观察到项目现在已安装了pip list。


$ pip list
Package Version Location
----------------- ------- -------------------------
astroid 2.2.5
atomicwrites 1.3.0
attrs 19.1.0
autopep8 1.4.3
baby 1.0.0 /Users/durban/python/baby
Click 7.0
coverage 4.5.3
Flask 1.0.2
gunicorn 19.9.0
isort 4.3.16
itsdangerous 1.1.0
Jinja2 2.10
lazy-object-proxy 1.3.1
MarkupSafe 1.1.1
mccabe 0.6.1
more-itertools 7.0.0
pip 19.1.1
pluggy 0.9.0
py 1.8.0
pycodestyle 2.5.0
pylint 2.3.1
pytest 4.4.0
setuptools 39.0.1
six 1.12.0
typed-ast 1.3.1
waitress 1.2.1
Werkzeug 0.15.1
wheel 0.33.1
wrapt 1.11.1

到目前为止，您运行项目的方式没有任何变化。FLASK_APP仍然设置为baby并且flask run仍然运行应用程序。

下一期继续 - 测试覆盖率

Flask 1.0 新手教程 - 博客Blueprint

Tue, 29 Jul 2025 10:09:50 +0800

写博客的Blueprint跟写身份认证的Blueprint所使用的技术是一样的。博客应该列出所有的帖子，允许登录的用户去创建帖子，允许发帖用户去编辑或者删除帖子。

当我们实现每个视图的时候，请保持服务器一直处于运行状态。在保存更改时，请尝试访问浏览器中的URL并进行测试。

Blueprint

在应用程序工厂中定义blueprint并注册它

baby/blog.py


#! _*_ coding: utf-8 _*_

from flask import (
 Blueprint, flash, g, redirect, request, render_template, url_for
)

from werkzeug.exceptions import abort
from baby.auth import login_required
from baby.db import get_db

bp = Blueprint('blog', __name__)

使用app.register_blueprint()在工厂中导入并注册blueprint。放下面的代码在工厂的底部，在返回变量app之前。

baby/init.py


def create_app(test_config=None):
 # 忽略已经有的部分代码

 from . import blog
 app.register_blueprint(blog.bp)
 app.add_url_rule('/', endpoint='index')

 return app

不像身份认证blueprint，博客blueprint没有使用url_prefix，因此index视图将被放在/路由上，create视图位于/create，依此类推。博客是Baby的主要特色，因此博客索引将成为主要索引。

但是，下面定义的index视图的endpoint将是blog.index。一些身份验证视图引用了普通indexendpoint。app.add_url_rule()将endpoint名称为'index'与/url相关联，以便url_for('index')或url_for('blog.index')都可以工作，生成相同/URL的方式。

在另一个应用程序中，您可以为博客blueprint提供url_prefix，并在应用程序工厂中定义单独的index视图，类似于hello视图。然后index和blog.indexendpoint和URL会有所不同。

Index视图

index视图将显示所有的帖子，最近的一个。这里使用了JOIN，可以关联user表来获得用户的信息在结果中展示。

baby/blog.py


@bp.route('/')
def index():
 db = get_db()
 posts = db.execute(
 'SELECT p.id, title, body, created, author_id, username'
 ' FROM post p JOIN user u ON p.author_id = u.id'
 ' ORDER BY created DESC'
 ).fetchall()
 return render_template('blog/index.html', posts=posts)

baby/templates/blog/index.html


{% extends 'base.html' %}

{% block header %}
 <h1>{% block title %}Posts{% endblock %}</h1>
 {% if g.user %}
 <a class="action" href="{{url_for('blog.create')}}">New</a>
 {% endif %}
{% endblock %}

{% block content %}
 {% for post in posts %}
 <article class="post">
 <header>
 <div>
 <h1>{{ post['title'] }}</h1>
 <div class="about">by {{ post['username'] }} on {{ post['created'].strftime('%Y-%m-%d') }}
 </div>
 {% if g.user['id'] == post['author_id'] %}
 <a class="action" href="{{ url_for('blog.update', id=post['id']) }}">Edit</a>
 {% endif %}
 </header>
 <p class="body">{{ post['body'] }}</p>
 </article>
 {% if not loop.last %}
 <hr />
 {% endif %}
 {% endfor %}
{% endblock %}

当用户登录后，header部分会添加一个create视图的链接，当用户是帖子的作者，将会看到一个指向update视图的’Edit’链接。loop.last是Jinja for loops中的一个可用的特殊变量。它用于在每个帖子之后显示除最后一个之外的一行，以便在视觉上将它们分开。

Create视图

create视图与身份认证register视图的工作方式相同。显示表单，或验证发布的数据，并将帖子添加到数据库或显示错误。之前编写的login_required装饰器用于博客视图。一个用户必须在登录后才能访问这些视图，否则用户将被重定向到登录页面。

baby/blog.py


@bp.route('/create', methods=['GET', 'POST'])
@login_required
def create():
 if request.method == 'POST':
 title = request.form['title']
 body = request.form['body']
 error = None

 if not title:
 error = 'Title is required'

 if error is not None:
 flash(error)
 else:
 db = get_db()
 db.execute(
 'INSERT INTO post (title, body, author_id)'
 ' VALUES (?,?,?)',
 (title, body, g.user['id'])
 )
 db.commit()
 return redirect(url_for('blog.index'))

 return render_template('blog/create.html')

baby/templates/blog/create.html


{% extends 'base.html' %}

{% block header %}
 <h1>{% block title %}New Posts{% endblock %}</h1>
{% endblock %}

{% block content %}
 <form method="POST">
 <label for="title">Title</label>
 <input id='title' name='title' value="{{ request.form['title'] }}" required/>
 <label for="body">body</label>
 <textarea id='body' name='body' value="{{ request.form['body'] }}"></textarea>
 <input type="submit" value="Save" />
 </form>
{% endblock %}

Update视图

update和delete视图需要通过id获取post，并且检查post的作者与登录用户是否匹配。为了避免代码重复，可以写一个函数来获取post，并且每个视图都能调用。

baby/blog.py


def get_post(id, check_author=True):
 post = get_db().execute(
 'SELECT p.id, title, body, created, author_id, username'
 ' FROM post p JOIN user u ON p.author_id = u.id'
 ' WHERE p.id = ?',
 (id,)
 ).fetchone()

 if post is None:
 abort(404, "Post id {0} doesn't exist".format(id))

 if check_author and post['author_id'] != g.user['id']:
 abort(403)

 return post

abort()将引发一个返回HTTP状态代码的特殊异常。它需要一个可选的消息来显示错误，否则使用默认消息。 404意味着“Not Found”，403意味着“Forbidden”（401意味着“Unauthorized”，但是我们应该重定向到登录页面而不是返回该状态。）

定义的check_author参数，以便该函数可用于获取帖子而无需检查作者。如果您编写一个视图来显示页面上的单个帖子，用户无关紧要，因为他们没有修改帖子，这将非常有用。

baby/blog.py


@bp.route('/<int:id>/update', methods=['GET', 'POST'])
@login_required
def update(id):
 post = get_post(id)

 if request.method == 'POST':
 title = request.form['title']
 body = request.form['body']
 error = None

 if not title:
 error = 'Title is required'

 if error is not None:
 flash(error)
 else:
 db = get_db()
 db.execute(
 'UPDATE post SET title = ?, body = ?'
 ' WHERE id = ?',
 (title, body, id)
 )
 db.commit()
 return redirect(url_for('blog.index'))

 return render_template('blog/update.html', post=post)

这个视图跟前面的视图不太一样，update函数需要传递一个参数id，这对应于路径中的<int:id>。真实的URL看起来像这个/1/update/，Flask将会捕捉到1，并保证它是个int，并且传递它作为id参数。如果不是一个具体的int:而是一个<id>，获取到的参数将会是一个String。为了生成一个URL地址到update页面，url_for需要传递一个id参数，比如url_for('blog.update', id=post['id'])。这个也可以在上面的index.html中看到。

create和update视图看起来很像，最大的不同是update视图使用一个post对象并且UPDATE代替了INSERT。通过一些巧妙的重构，你可以使用一个视图和模板替换掉create和update视图，但是由于是新手教程，保持两个视图分离看起来会比较清晰。

baby/templates/blog/update.html


{% extends 'base.html' %}

{% block header %}
 <h1>{% block title %}Edit "{{ post['title'] }}"{% endblock %}</h1>
{% endblock %}

{% block content %}
 <form method="POST">
 <label for="title">Title</label>
 <input id="title" name="title" value="{{ request.form['title'] or post['title']}}" required />
 <label for="body">Body</label>
 <textarea name="body" id="body">{{ request.form['body'] or post['body'] }}</textarea>
 <input type="submit" value="Save" />
 </form>
 <hr />
 <form method="POST" action="{{url_for('blog.delete', id=post['id'])}}">
 <input class="danger" type="submit" value="Delete" onclick="return confirm('Are you sure?');" />
 </form>
{% endblock %}

{{ request.form['title'] or post['title'] }}用来选择表单中显示的数据，当表单没有被提交时，原始的post的数据将会显示，但是如果无效的表单数据被提交，我们希望显示这个错误的数据，并让用户去修改此错误，因此使用request.form['title']。request是另一个变量，可以自动在模板中使用。

Delete视图

delete视图没有自己的模板，delete按钮是update.htmls的一部分并发布到/<id>/delete网址。因此没有模板，它只是处理POST方法并且重定向到index视图。

baby/blog.py


@bp.route('/<int:id>/delete', methods=['POST'])
@login_required
def delete(id):
 get_post(id)
 db = get_db()
 db.execute(
 'DELETE FROM post where id = ?', (id,)
 )
 db.commit()
 return redirect(url_for('blog.index'))

到这里我们就已经完成了如何开发一个应用程序的新手教程，可喜可贺，花一些时间在浏览器上试试所有的功能。然而到这里在项目完成之前还是有很多要做的。

下一期继续 - 使项目可安装

Flask 1.0 新手教程 - 静态文件

Tue, 29 Jul 2025 10:09:47 +0800

身份验证视图和模板可以正常工作，但它们现在看起来很简单。可以添加一些CSS来为您构建的HTML布局添加样式。样式不会改变，因此它是静态文件而不是模板。

Flask会自动添加一个static视图，该视图采用相对于baby/static目录的路径并为其提供服务。base.html模板已经有一个指向app.css文件的链接


<link rel="stylesheet" href="{{url_for('static', filename='app.css')}}" />

除了CSS之外，其他类型的静态文件可能是具有JavaScript功能的文件或logo图像。它们都放在baby/static目录下，并用url_for('static'，filename ='...')引用。

这个教程的目标不在于教你如何写CSS，因此你只需要将下面的代码复制到baby/static/app.css文件中即可。

baby/static/app.css


html { font-family: sans-serif; background: #eee; padding: 1rem; }
body { max-width: 960px; margin: 0 auto; background: white; }
h1 { font-family: serif; color: #377ba8; margin: 1rem 0; }
a { color: #377ba8; }
hr { border: none; border-top: 1px solid lightgray; }
nav { background: lightgray; display: flex; align-items: center; padding: 0 0.5rem; }
nav h1 { flex: auto; margin: 0; }
nav h1 a { text-decoration: none; padding: 0.25rem 0.5rem; }
nav ul { display: flex; list-style: none; margin: 0; padding: 0; }
nav ul li a, nav ul li span, header .action { display: block; padding: 0.5rem; }
.content { padding: 0 1rem 1rem; }
.content > header { border-bottom: 1px solid lightgray; display: flex; align-items: flex-end; }
.content > header h1 { flex: auto; margin: 1rem 0 0.25rem 0; }
.flash { margin: 1em 0; padding: 1em; background: #cae6f6; border: 1px solid #377ba8; }
.post > header { display: flex; align-items: flex-end; font-size: 0.85em; }
.post > header > div:first-of-type { flex: auto; }
.post > header h1 { font-size: 1.5em; margin-bottom: 0; }
.post .about { color: slategray; font-style: italic; }
.post .body { white-space: pre-line; }
.content:last-child { margin-bottom: 0; }
.content form { margin: 1em 0; display: flex; flex-direction: column; }
.content label { font-weight: bold; margin-bottom: 0.5em; }
.content input, .content textarea { margin-bottom: 1em; }
.content textarea { min-height: 12em; resize: vertical; }
input.danger { color: #cc2f2e; }
input[type=submit] { align-self: start; min-width: 10em; }

您可以在示例代码中找到一个不太紧凑的style.css版本。

转到http://127.0.0.1:5000/auth/login，该页面应如下面的屏幕截图所示。

您可以从Mozilla的文档中了解有关CSS的更多信息。如果更改静态文件，请刷新浏览器页面。如果更改未显示，请尝试清除浏览器的缓存。

下一期继续 - 博客Blueprint

Flask 1.0 新手教程 - 模板

Tue, 29 Jul 2025 10:09:44 +0800

经过上篇文章，我们已经为应用程序编写了身份验证视图，当时当我们运行服务并且试着去访问其中任何一个URL的时候，将会看到TemplateNotFound的错误。那是因为视图调用了render_template()函数，但是我们还没有创建对应的模板。模板文件将被存储在baby包中的templates文件夹中。

模板是包含静态数据和动态数据占位符的文件。一个模板使用特定数据呈现以生成最终文档。Flask使用Jinja模板库来渲染模板。

在应用程序中，将使用templates去渲染将在用户浏览器上显示的HTML，在Flask中，Jinja被配置为自动转移将在HTML模板中渲染的任何数据。这意味着用户的输入将被安全的渲染，他们输入的任何字符都可能破坏HTML。例如<和>将转义为安全值，这些值在浏览器中看起来相同，但不会造成不必要的影响。

Jinja的外观和行为都很像Python。使用特殊的分隔符将Jinja语法与模板中的静态数据区分开来，{{和}}的表达式符号表示他们之间的任何内容都是将输出到最终文档。{%和%}符号表示类似if和for的控制流语句。不像Python，块由开始和结束标记表示，而不是缩进，因为块内的静态文本可以更改缩进。

基础布局

在应用程序中每个页面都有一个类似的基础布局包裹着不同的body。而不是在每个模板中编写整个HTML结构，每个模板将会继承基础布局然后重写具体的部分。

baby/templates/base.html


<!DOCTYPE html>
<title>{% block title %}{% endblock %} - Baby</title>
<link rel="stylesheet" href="{{url_for('static', filename='app.css')}}" />
<nav>
 <h1>Baby</h1>
 <ul>
 {% if g.user %}
 <li><span>{{g.user['username']}}</span></li>
 <li><a href="{{url_for('auth.logout')}}">Log Out</a></li>
 {% else %}
 <li><a href="{{url_for('auth.register')}}">Register</a></li>
 <li><a href="{{url_for('auth.login')}}">Log In</a></li>
 {% endif %}
 </ul>
</nav>
<section class="content">
 <header>
 {% block header %}{% endblock %}
 </header>
 {% for message in get_flashed_messages() %}
 <div class="flash">{{message}}</div>
 {% endfor %}
 {% block content %}{% endblock %}
</section>

g在模板中将会自动可用，基于g.user设置用户(从load_logged_in_user)，要么显示用户名和注销链接，要么显示注册和登录链接。url_for()也将会自动可用，并且被用于生成URL，而不是手动将他们写出来。

在页面title的后面，并且在content的前面，模板循环调用get_flashed_messages()返回的每个信息。您在视图中使用flash()来显示错误消息，下面的代码将显示它们。

这里的有三个被定义的块，在其他模板中将被重写。

{% block title %}将改变在浏览器标签显示的标题和窗口的标题
{% block header %}类似于title，但是会改变在页面上显示的标题
{% block content %}是每个页面的内容所在，例如登录表单或博客文章

基础模板直接在模板的目录下面。为了保持其他模板的组织，蓝图的模板将被放置在与蓝图同名的目录中

注册

baby/templates/auth/register.html


{% extends 'base.html' %}

{% block header %}
<h1>{% block title %}Register{% endblock %}</h1>
{% endblock %}

{% block content %}
<form method="POST">
 <label for="username">Username</label>
 <input name="username" id="username" required />
 <label for="password">Password</label>
 <input type="password" name="password"" id="password" required/>
 <input type="submit" value="Register" />
</form>
{% endblock %}

{% extends 'base.html' %}告诉Jinja这个模板应该替换掉基础模板中的block。所有渲染的内容都必须出现在{% block %}标记中，这些标记覆盖基础模板中的块。

这里使用的一个有用模式是将{% block title %}放在{% block header %}中。这将设置title块，然后将其值输出到header块中，这样窗口和页面就可以共享相同的标题，而不需要编写两次标题。

input标签有一个required属性，这是在告诉浏览器知道所有的输入框都填入数据才能被提交。如果用户使用的是老版本的浏览器并且不支持这个属性，或者使用了除了浏览器之外其他的工具做了请求操作，你仍然应该在视图中去验证数据。始终在服务器上完全验证数据是很重要的，即使客户机也执行一些验证。


{% extends "base.html" %}

{% block header %}
<h1>{% block title %}Login In{% endblock %}</h1>
{% endblock %}

{% block content %}
<form method="POST">
 <label for="username">Username</label>
 <input id="username" name="username" required />
 <label for="password">Password</label>
 <input type="password" id="password" name="password" required />
 <input type="submit" value="Login In" />
</form>
{% endblock %}

注册一个用户

现在身份认证模块已经写完，你可以注册一个用户。确保服务器仍在运行(如果没有运行，执行flask run)，然后访问http://127.0.0.1:5000/auth/register。试着在没有填写任何内容的情况下点击“注册”按钮，然后应该可以看到浏览器的错误提示信息。试着从register.html模板中将required属性移除，然后点击再次点击“注册”按钮。与浏览器显示错误不同，页面将重新加载，视图中的flash()将显示错误信息。

填充一个username和password，然后你将被重定向到一个登录页面，试着输入一个错误的username或者是正确的username和错误的password。如果你登录进去后，你将会得到一个错误因为还没有一个index视图去跳转。

下一期继续 - 静态文件

Flask 1.0 新手教程 - Blueprint和视图

Tue, 29 Jul 2025 10:09:41 +0800

视图函数是我们编写用于响应对应的应用程序的请求的代码。Flask使用模式将传入的请求URL与应该处理它的视图相匹配。该视图返回Flask转换后的响应数据。Flask也可以转向另一个方向，并根据其名称和参数生成视图的URL。

创建Blueprint

Blueprint是一种组织一组相关视图和其他代码的方法。他们不是直接在应用程序中注册视图和其他代码，而是使用蓝图进行注册。然后，当它在工厂功能中可用时，蓝图就会在应用程序中注册。

baby将会有两个Blueprint，一个用于身份验证功能，另一个用于博客帖子功能。每个蓝图的代码都将在一个单独的模块中。由于博客需要了解身份验证，因此首先要编写身份验证的部分。

baby/auth.py


#! _*_ coding: utf-8 _*_
import functools

from flask import (
 Blueprint, flash, g, redirect, render_template, request, session, url_for
)

from werkzeug.security import check_password_hash, generate_password_hash
from baby.db import get_db

bp = Blueprint('auth', __name__, url_prefix='/auth')

上面的代码创建了一个名为’auth’的Blueprint，像应用程序对象一样，blueprint需要知道它是在哪里定义的，因此传递一个__name__作为第二个参数。url_prefix的值将被追加到所有与blueprint有关的URLs的前面。

在工厂函数中，使用app.register_blueprint()导入并注册blueprint。放置新的代码在工厂函数末尾，在返回app之前。

baby/init.py


def create_app():
 app = ///
 # 忽略已存在的代码

 from . import auth
 app.register_blueprint(auth.bp)

 return app

身份认证功能的blueprint会有几个试图，注册新用户的视图、登录的视图、登出的视图。

第一个视图：注册

当用户访问/auth/register的URL时，register视图将返回一个HTML表单以供用户填写。当用户提交表单时，视图函数将会验证用户的输入，如果验证失败将会显示一个带有错误信息的表单，如果验证成功则创建一个新用户，并进入到登录页面。

现在我们先写一部分视图代码，在下一篇分享中，将介绍如何用模板去生成一个HTML表单。

baby/auth.py


@bp.route('/register', methods=['GET', 'POST'])
def register():
 if request.method == 'POST':
 username = request.form['username']
 password = request.form['password']
 db = get_db()
 error = None

 if not username:
 error = 'Username is required.'
 elif not password:
 error = 'Password is required.'
 elif db.execute(
 'SELECT id FROM user WHERE username = ?', (username,)
 ).fetchone() is not None:
 error = 'user {} is already registered.'.format(username)

 if error is None:
 db.execute(
 'INSERT INTO user (username, password) VALUES (?, ?)', 
 (username, generate_password_hash(password))
 )
 db.commit()
 return redirect(url_for('auth.login'))

 flash(error)

 return render_template('auth/register.html')

下面解说下这个register视图函数正在做的

@bp.route()将URL/register与register视图函数相关联。当Flask收到对/auth/register的请求时，它将调用register视图并使用返回值作为响应。
如果用户提交了表单，request.method将是'POST'，在这种情况下，请开始验证输入
request.form是一种特殊类型的dict映射，提交了表单键和值。用户将输入他们的username和password。
验证username和password不为空。
通过查询数据库并通过返回的结果验证username是否已经被注册过了。db.execute采用SQL查询?任何用户输入的占位符，以及用于替换占位符的值元组。数据库库将负责转义值，因此您不容易受到SQL注入攻击。

fetchone()从查询中返回一行。如果查询没有返回结果，它会返回None。稍后，使用fetchall()，它返回所有结果的列表。
如果验证成功了则插入新用户的数据到数据库。为了安考虑，密码永远都不要用明文还自己存储，而是使用generate_password_hash()安全地将明文密码机型哈希处理，然后存储哈希值。由于此查询修改数据，因此需要在之后调用db.commit()以保存更改。
存储用户之后，被重定向到登录页面。url_for()根据其名称生成一个登录视图URL。这比直接编写URL更好，因为它允许您稍后更改URL而不更改链接到它的所有代码。redirect()生成对生成的URL的重定向响应。
如果验证失败，错误信息将被显示给用户。flash()存储的信息，在模板渲染的时候能被检索出来。
当用户最初导航到auth/register，或者存在验证错误时，应显示带有注册表单的HTML页面。render_template()将呈现包含HTML的模板，您将在本教程的下一步中编写该模板。

第二个视图：登录

该视图遵循与上面的register视图相同的模式。

baby/auth.py


@bp.route('/login', methods=['GET','POST'])
def login():
 if request.method == 'POST':
 username = request.form['username']
 password = request.form['password']

 db = get_db()
 error = None

 user = db.execute(
 'SELECT * FROM user WHERE username = ?', (username,)
 ).fetchone()

 if user is None:
 error = 'Incorrect username.'
 elif not check_password_hash(user['password'], password):
 error = 'Incorrect password.'

 if error is None:
 session.clear()
 session['user_id'] = user['id']
 return redirect(url_for('blog.index'))

 flash(error)

 return render_template('auth/login.html')

这个视图与register视图有一些不同之处：

首先查询用户并将其存储在变量中以供以后使用。
check_password_hash()以存储的哈希相同的方式哈希处理提交的密码并安全地比较它们。如果匹配，则密码有效。
session是一个跨请求存储数据的字典。验证成功后，用户的id将存储在新会话中。数据存储在发送到浏览器的cookie中，然后浏览器将其与后续请求一起发回。Flask安全地对数据进行签名，以便不会被篡改。

现在用户的id存储在会话中，它将在后续请求中可用。在每个请求开始时，如果用户已登录，则应加载其信息并使其可供其他视图使用。

baby/auth.py


@bp.before_app_request
def load_logged_in_user():
 user_id = session.get('user_id')

 if user_id is None:
 g.user = None
 else:
 g.user = get_db().execute(
 'SELECT * FROM user WHERE id = ?', (user_id,)
 ).fetchone()

bp.before_app_request()注册一个在视图函数之前运行的函数，无论请求什么URL。load_logged_in_user检查用户id是否存储在session中并从数据库中获取该用户的数据，并将其存储在g.user上，该持续时间为请求的长度。如果没有用户ID，或者id不存在，则g.user将为None。

第三个视图：登出/退出

要注销，需要从会话中删除用户ID。然后load_logged_in_user将不会在后续请求中加载用户。

baby/auth.py


@bp.route('/logout', methods=['GET'])
def logout():
 session.clear()
 return redirect(url_for('blog.index'))

在其他视图中需要身份验证

创建，编辑和删除博客帖子将需要用户登录。装饰器可用于检查它应用于的每个视图。

baby/auth.py


def login_required(view):
 @functools.wraps(view)
 def wrapped_view(**kwargs):
 if g.user is None:
 return redirect(url_for('auth.login'))

 return view(**kwargs)

 return wrapped_view

这个装饰器返回一个新的视图函数，它包装了它应用的原始视图。新函数检查用户是否已加载，未加载的话将重定向到登录页面。如果加载了用户，则调用原始视图并继续正常运行。在编写博客视图时，您将使用此装饰器。

Endpoint和URL

url_for()函数根据名称和参数生成视图的URL。与视图关联的名称也称为endpoint，默认情况下，它与视图函数的名称相同。

例如，在本教程前面添加到app工厂的hello()视图名为'hello'，可以链接到url_for('hello')。如果这个视图函数带了一个参数，这部分将在后面的教程中看到，他将被连接到url_for('hello', who='World')。

使用blueprint时，blueprint的名称将附加到函数的名称前面，因此上面写入的登录函数的endpoint是'auth.login'，因为我们将其添加到'auth' blueprint中。

下一期继续 - 模板

Flask 1.0 新手教程 - 定义和访问数据库

Tue, 29 Jul 2025 10:09:38 +0800

本教程的应用程序将使用SQLite数据库来存储用户和帖子，Python在sqlite3模块中内置了对SQLite的支持

SQLite是很方便的，因为他不需要设置单独的数据库服务器并且内置与Python中。然而如果并发请求同时试着写入数据，随着每次写入顺序发生，它们会变慢。

小应用程序不会注意到这一点。一旦变大，您可能希望切换到其他数据库。

本教程不会详细介绍SQL。如果您不熟悉它，SQLite文档会描述该语言。

连接数据库

使用SQLite数据库（以及大多数其他Python数据库）时要做的第一件事就是创建一个连接。使用连接执行任何查询和操作，该连接在工作完成后关闭。

在Web应用程序中，此连接通常与请求相关联。它在处理请求时在某个时刻创建，并在发送响应之前关闭。

baby/db.py


#! _*_ coding: utf-8 _*_
import sqlite3

import click
from flask import current_app, g
from flask.cli import with_appcontext

def get_db():
 if 'db' not in g:
 g.db = sqlite3.connect(
 current_app.config['DATABASE'],
 detect_types=sqlite3.PARSE_DECLTYPES
 )
 g.db.row_factory = sqlite3.Row

 return g.db

def close_db(e=None):
 db = g.pop('db', None)

 if db is not None:
 db.close()

g是一个特殊对象，对每个请求都是唯一的。它用于存储请求期间可能由多个函数访问的数据。

如果在同一请求中第二次调用get_db，则会存储并重用连接，而不是创建新连接。

current_app是另一个指向处理请求的Flask应用程序的特殊对象。由于您使用的是应用程序工厂，因此在编写其余代码时没有应用程序对象。创建应用程序并处理请求时将调用get_db，因此可以使用current_app

sqlite3.connect()建立与DATABASE配置键指向的文件的连接。此文件尚不存在，并且在您稍后初始化数据库之前不会存在。

sqlite3.Row告诉连接返回行为类似于dicts的行。这允许按名称访问列。

close_db通过检查是否已设置g.db来检查是否创建了连接。如果连接存在，则关闭。再往下，您将告诉您的应用程序有关应用程序工厂中的close_db函数，以便在每次请求后调用它。

建表

在SQLite中，数据存储在表和列中。这些需要在存储和检索数据之前创建。Baby项目将用户存储在用户表中，并在post表中存储帖子。使用创建空表所需的SQL命令创建一个文件：

baby/schema.sql


DROP TABLE IF EXISTS user;
DROP TABLE IF EXISTS post;

CREATE TABLE user (
 id INTEGER PRIMARY KEY AUTOINCREMENT,
 username TEXT UNIQUE NOT NULL,
 password TEXT NOT NULL
);

CREATE TABLE post (
 id INTEGER PRIMARY KEY AUTOINCREMENT,
 author_id INTEGER NOT NULL,
 created TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
 title TEXT NOT NULL,
 body TEXT NOT NULL,
 FOREIGN KEY (author_id) REFERENCES user (id)
)

将运行这些SQL命令的Python函数添加到db.py文件中：

baby/db.py


def init_db():
 db = get_db()

 with current_app.open_resource('schema.sql') as f:
 db.executescript(f.read().decode('utf8'))

@click.command('init-db')
@with_appcontext
def init_db_command():
 """Clear the existing data and create new tables"""
 init_db()
 click.echo('Initialized the database.')

open_resource()打开一个相对于baby包的文件，这很有用，因为在以后部署应用程序时你不一定知道该位置在哪里。get_db返回数据库连接，用于执行从文件读取的命令。

click.command()定义了一个名为init-db的命令行命令，该命令调用init_db函数并向用户显示成功消息。您可以阅读命令行界面以了解有关编写命令的更多信息。

注册应用程序

close_db和init_db_command函数需要在应用程序中被注册，否则他们将不会被应用程序调用。但是，由于您使用的是工厂函数，因此在编写函数时该实例不可用。相反，编写一个接受应用程序并进行注册的函数。

baby/db.py


def init_app(app):
 app.teardown_appcontext(close_db)
 app.cli.add_command(init_db_command)

app.teardown_appcontext()告诉Flask在返回响应后清理时调用该函数。

app.cli.add_command()添加了一个可以使用flask命令调用的新命令。

从工厂导入并调用此功能。在返回应用程序之前，将新代码放在工厂函数的末尾。

baby/init.py


def create_app(test_config=None):
 # create and configure the app
 app = Flask(__name__, instance_relative_config=True)
 app.config.from_mapping(
 SECRET_KEY='dev',
 DATABASE=os.path.join(app.instance_path, 'baby.sqlite')
 )

 if test_config is None:
 app.config.from_pyfile('config.py', silent=True)
 else:
 app.config.from_mapping(test_config)

 try:
 os.makedirs(app.instance_path)
 except OSError:
 pass

 @app.route('/baby')
 def index():
 return 'Baby'

 # 新加
 from . import db
 db.init_app(app)

 return app

初始化数据库文件

现在已经在应用程序中注册了init-db，可以使用flask命令调用它，类似于上一节的run命令。

注意：

如果您仍在从上一页运行服务器，则可以停止服务器，也可以在新终端中运行此命令。如果您使用新终端，请记住更改到项目目录并激活env，如激活环境中所述。您还需要设置FLASK_APP和FLASK_ENV，如上一节所示。

运行init-db命令


flask init-db
Initialized the database

现在，项目中的实例文件夹中将有一个baby.sqlite文件。

下一期继续 - Blueprint和视图

Flask 1.0 新手教程 - 应用程序设置

Tue, 29 Jul 2025 10:09:35 +0800

Flask应用程序是一个Flask类的实例。关于应用的任何事情，例如配置和URLs都将通过这个类来注册。

最直截了当的方式创建一个Flask应用是直接在代码顶部通过创建一个全局的Flask实例，就像上一篇教程的“Hello，World！”示例一样。虽然这在某些情况下很简单且有用，但随着项目的增长，它可能会导致一些棘手的问题。

在函数内创建Flask实例，而不是全局创建Flask实例。此功能称为应用程序工厂。应用程序需要的任何配置，注册和其他设置都将在函数内部进行，然后将返回应用程序。

应用程序工厂

是时候开始编码了！创建baby目录并添加__init__.py文件。__init__.py提供双重任务：它将包含应用工厂，并且它将告诉Python，baby目录将被作为一个包来对待。


make baby

baby/init.py


#! _*_ coding: utf-8 _*_

import os

from flask import Flask

def create_app(test_config=None):
 # 创建和配置应用程序
 app = Flask(__name__, instance_relative_config=True)
 app.config.from_mapping(
 SECRET_KEY='dev',
 DATABASE=os.path.join(app.instance_path, 'baby.sqlite')
 )

 if test_config is None:
 # 加载实例配置（如果存在），不测试时
 app.config.from_pyfile('config.py', silent=True)
 else:
 # 如果传入则加载测试配置
 app.config.from_mapping(test_config)

 # 确保实例文件夹存在
 try:
 os.makedirs(app.instance_path)
 except OSError:
 pass

 # 一个简单的页面
 @app.route('/hello')
 def index():
 return 'Hello, World!'

 return app

application = create_app()

if __name__ == "__main__":
 application.run()

create_app是应用程序工厂函数。您将在本教程的后面添加它，但它已经做了很多

app = Flask(__name__, instance_relative_config=True)创建Flask实例
- __name__是当前Python模块的的名称。应用程序需要知道它所在的位置以设置一些路径，并__name__是告诉它的一种方便的方法
- instance_relative_config=True告诉应用程序配置文件是相对于instance文件夹的。这个instance文件夹位于baby包外面并且可以保存本地数据，且数据不能被提交到版本库，例如配置密码和数据库文件。
app.config.from_mapping()设置一些应用程序将会使用的默认配置：
- SECRET_KEY 被Flask和扩展使用用来保证数据的安全。它被设置为’dev’以在开发期间提供方便的值，但在部署时应该用随机值覆盖它。
- DATABASE 是保存SQLite数据库文件的路径。它位于app.instance_path下，这是Flask为实例文件夹选择的路径。您将在下一篇教程中了解有关数据库的更多信息。
app.config.from_pyfile()使用从instance文件夹中的config.py文件获取的值覆盖默认配置（如果存在）。例如当部署的时候，将被用于设置一个真实的SECRET_KEY。
- test_config也可以传递给工厂，而不是实例配置。这样您将在本教程后面编写的测试可以独立于您配置的任何开发值进行配置
[os.makedirs()]确保app.instance_path存在。Flask不会自动创建一个instance文件夹，但是它需要被创建，因为你的项目将在这创建SQLite数据库文件。
@app.route()创建了一个简单的路由，以便在进入本教程的其余部分之前可以看到应用程序正常工作。它在URL /hello和返回响应的函数之间创建了一个连接，在这种情况下响应函数会返回一个字符串’Hello，World！'

运行应用程序

现在可以通过Flask命令运行应用程序。通过终端，告诉Flask在哪里找到你的应用程序，然后通过开发者模式运行

开发者模式，只要页面引发异常，就显示一个交互式调试器，在改变代码的时候重启服务器。您可以让它保持运行，只需按照教程重新加载浏览器页面即可。

对于Linux和Mac：


export FLASK_APP=baby
export FLASK_ENV=development
flask run

对于Windows cmd，使用set而不是export：


set FLASK_APP=baby
set FLASK_ENV=development
flask run

对于Windows PowerShell，请使用$env：而不是export：


$env:FLASK_APP = "baby"
$env:FLASK_ENV = "development"
flask run

你会看到与此类似的输出：


$ flask run
 * Serving Flask app "baby" (lazy loading)
 * Environment: development
 * Debug mode: on
 * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
 * Restarting with stat
 * Debugger is active!
 * Debugger PIN: 390-520-193

在浏览器中访问http://127.0.0.1:5000/hello，您应该看到“Hello，World！”消息。恭喜，您现在正在运行Flask Web应用程序！

下一期继续 - 定义和访问数据库

Flask 1.0 新手教程 - 项目布局

Tue, 29 Jul 2025 10:09:32 +0800


mkdir baby
cd baby

然后参考安装说明来设置Python虚拟环境并且为项目安装Flask

本教程假设您从现在开始使用baby目录，每个代码块顶部的文件名都与该目录相关。

Flask应用程序可以像单个文件一样简单。

hello.py


from flask import Flask
app = Flask(__name__)

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

然而随着项目越来复杂，所有代码放在一个文件将会变得越来越臃肿。Python项目使用包将代码组织成多个模块，可以在需要的地方导入，本教程也会这样做。

本教程项目目录将会包括如下内容：

baby/，一个包含应用程序代码和文件的Python包
tests/，一个包含测试模块的目录
.env3，一个Flask和其他依赖库被安装的Python虚拟环境
安装文件告诉Python如何安装项目。
版本控制配置，例如git。您应养成给所有项目使用某种类型的版本控制的习惯，无论大小如何。
您将来可能添加的任何其他项目文件

最后，您的项目布局将如下所示：


/Users/durban/python/baby
├── tests
│ ├── test_factory.py
│ ├── test_db.py
│ ├── test_blog.py
│ ├── test_auth.py
│ ├── data.sql
│ └── conftest.py
├── setup.py
├── setup.cfg
├── gunicorn.example.conf
├── gunicorn.conf
├── baby
│ ├── templates
│ │ ├── blog
│ │ │ ├── update.html
│ │ │ ├── index.html
│ │ │ └── create.html
│ │ ├── base.html
│ │ └── auth
│ │ ├── register.html
│ │ └── login.html
│ ├── static
│ │ └── app.css
│ ├── schema.sql
│ ├── db.py
│ ├── blog.py
│ ├── auth.py
│ └── __init__.py
├── README.md
└── MANIFEST.in

如果你使用了版本控制，应忽略在运行项目时生成的以下文件。根据您使用的编辑器，可能还有其他文件。通常，忽略您未编写的文件。例如，使用git：

.gitignore


.env3/

*.pyc
__pycache__/

instance/

.pytest_cache/
.coverage
htmlcov/

dist/
build/
*.egg-info/

下一期继续 - 应用程序设置

Flask 1.0 新手教程 - 概览

Tue, 29 Jul 2025 10:09:28 +0800

教程内容有：

本教程将指导您创建一个名为Baby的基本博客应用程序。用户可以注册，登录，创建帖子，编辑或删除自己的帖子。您将能够在其他计算机上打包并安装该应用程序。

假设您已熟悉Python。Python文档中的官方教程是首先学习或复习的好方法。

虽然这个新手教程旨在提供一个良好的起点，但本教程并未涵盖Flask的所有功能。查看快速入门，了解Flask可以做的事情，然后深入了解文档以了解更多信息。本教程仅使用Flask和Python提供的内容。在其他项目中，您可能决定使用Extensions或其他库来简化某些任务。

Flask是很灵活的，它不需要您使用任何特殊的项目或者代码布局。然后，首次使用时，使用更结构化的方法会很有帮助。这意味着该新手教程需要预先考虑一些样板，但这样做是为了避免新开发人员遇到的许多常见陷阱，并创建一个易于扩展的项目。一旦你对Flask更加舒适，你可以走出这个结构并充分利用Flask的灵活性。

如果您希望在学习本教程时将项目与最终产品进行比较，那么本教程项目可作为Flask存储库中的示例提供。

下一期继续 - 项目布局

Flask 1.0 快速入手【四】

Tue, 29 Jul 2025 10:09:23 +0800

Sessions

除了请求对象之外，还有一个叫做session的第二个对象，它允许您将特定于某个用户的信息从一个请求存储到下一个请求。这是在cookie的基础上实现的，并以加密方式对cookie进行签名。这意味着用户可以查看cookie的内容但不能修改它，除非他们知道用于签名的密钥。

要使用session的话，您必须设置一个密钥。以下是session的工作方式：


from flask import Flask, session, redirect, url_for, escape, request

app = Flask(__name__)

app.secret_key = b'\xbc\xf6\x8aTP\xba\xe7\xf8*\xcc\xa7\xbe\xb2S\xd5\x83'

@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=['POST', 'GET'])
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>
			<p><input type='submit' value='Login' /></p>
		</form>
	'''

@app.route('/logout')
def logout():
 session.pop('username', None)
 return redirect(url_for('index'))

如果你没有使用模板引擎（如本例所示），这里提到的escape()会为你做转义处理。

如何生成一个好一点的密钥

密钥应尽可能随机。您的操作系统可以基于加密随机生成器生成相当随机的数据。使用以下命令快速生成一个值给Flask.secret_key (或者 SECRET_KEY):


$ python -c 'import os; print(os.urandom(16))'
b'\xbc\xf6\x8aTP\xba\xe7\xf8*\xcc\xa7\xbe\xb2S\xd5\x83'

关于基于cookie的会话的说明：Flask将获取您放入session对象的值，并将它们序列化为cookie。如果您发现某些值不会在请求中保留，则确实启用了Cookie，并且您没有收到明确的错误消息，请检查页面响应中的Cookie大小与Web浏览器支持的大小相比较。

除了默认的基于客户端的session，如果你想在服务器端处理session，有几个Flask扩展支持这个。

即时消息

好的应用和用户体验是关于反馈的，如果用户没有得到足够的反馈，他们可能最终会厌恶应用程序，Flask提供了一种使用即时系统向用户提供反馈的简单方法。即时系统基本上可以在请求结束时记录消息，并在下一个（也是下一个）请求中访问它。这通常与布局模板结合使用以显示消息。

要使用flash()方法添加一个即时消息，要获取即时消息，可以使用get_flashed_messages()的方法，这些消息也可以在模板中使用。查看即时消息以获取完整示例。

日志

有时您可能处理的数据应该是正确的，但事实并非如此。例如，您可能有一些客户端代码向服务器发送HTTP请求，但显然格式不正确。这可能是由用户篡改数据或客户端代码失败引起的。在大多数情况下，在这种情况下回复400 Bad Request是可以的，但有时不会这样做，而且代码必须继续工作。

您可能仍想记录发生了可疑的事情。这是loggers派上用场的地方。从Flask 0.3开始，预先配置了一个logger供您使用。

以下是一些日志调用示例：


app.logger.debug('A value for debuging')
app.logger.warning('A warning occurred (%d apples)', 42)
app.logger.error('A error occurred')

附加自带的logger是标准的Logger，因此请访问官方logging文档以获取更多信息。

详细了解应用程序错误

挂钩WSGI中间件

如果要将WSGI中间件添加到应用程序，可以包装内部WSGI应用程序。例如，如果你想使用Werkzeug包中的一个中间件来处理lighttpd中的bug，你可以这样做


from werkzeug.contrib.fixers import LighttpdCGIRootFix
app.wsgi_app = LighttpdCGIRootFix(app.wsgi_app)

使用Flask Extensions

扩展程序是帮助您完成常见任务的程序包。例如，Flask-SQLAlchemy提供SQLAlchemy支持，使其易于与Flask一起使用。

有关Flask扩展的更多信息，请查看扩展。

部署到Web服务器

准备部署新的Flask应用了吗？转到“部署选项”。

Flask 1.0 快速入手【三】

Tue, 29 Jul 2025 10:09:19 +0800

Cookies

你可以通过cookies这个属性来访问到cookies，可以使用响应对象的set_cookie方法来设置cookies。请求对象的cookies属性是一个字典类型，它包含了所有从客户端传递过来的cookies数据。如果你想使用cookies，不要直接使用cookies，而是使用Flask中的Sessions，它为您在cookies的上一层添加了一些安全的处理。

读取cookies


from flask import request

@app.route('/')
def index()：
 username = request.cookies.get('username')
 # 为了避免键值不存在的情况，使用cookies.get(key)替换cookies[key]

存储cookies


from flask import make_response

@app.route('/')
def index():
 resp = make_response(render_template('....'))
 resp.set_cookie('username', 'the other username')
 return resp

请注意，cookies是在响应对象中设置的。由于我们通常只是从视图函数返回字符串，Flask会为你将它们转换为响应对象。如果您明确要这样做，可以使用make_response()函数然后修改它。

有时您可能希望在响应对象尚不存在的位置设置cookie，这可以通过使用延迟请求回调模式来实现。

为此，请参阅关于响应。

重定向和错误

将用户重定向到另一个端点，使用redirect()函数。用一个错误代码提前中止请求，使用abort()函数。


from flask import abort, redirect, url_for

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

@app.route('/login')
def login():
 abort(401)
 this_is_never_executed()

这是一个毫无意义的例子，因为它将一个用户从index页面重定向到了一个不能访问的401页面，但是这个例子演示了如何使用的。

默认情况下，每一个错误码都会显示一个黑白的错误页面，如果你想自定义这个错误页面，可以使用errorhandler()装饰器


from flask import render_template

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

请注意render_template()调用后的404。这将告诉Flask页面的状态码是404，404意味着页面不存在。默认情况下，页面状态码为200，意思是：一切正常。

有关详细信息，请参阅错误处理程序

关于响应

视图函数返回的值被自动转换为一个响应对象。如果返回值是一个字符串，它将被转换为一个带有该字符串的响应对象作为响应体，状态码200和一个text/htmlMIME类型。Flask转换返回值为一个响应对象的逻辑如下：

如果返回一个正确类型的响应对象，这个响应对象将会从视图函数直接返回。
如果返回一个字符串，一个影响对象将携带改字符串和默认的参数被创建。
如果返回元组，则元组中的项可以提供额外信息。这样的元组必须采用(response, status, headers)或(response, headers)的形式，其中至少有一个项目必须在元组中。status值将覆盖状态代码，headers可以是其他标头值的列表或字典。
如果这些都不起作用，Flask将假定返回值是有效的WSGI应用程序并将其转换为响应对象。

如果要在视图中获取生成的响应对象，可以使用make_response()函数。

假如你有一个像下面这样的视图


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

您只需要使用make_response()包装返回表达式并获取响应对象以对其进行修改，然后将其返回：


@app.errorhandler(404)
def not_found(error):
 resp = make_response(render_template('error.html'), 404)
 resp.headers['X-Something'] = 'A value'
 return resp

Flask 1.0 快速入手【二】

Tue, 29 Jul 2025 10:09:16 +0800

静态文件

动态web应用也需要静态文件。通常包括CSS和Javascript文件。理想情况下，你的服务器配置为为你自己服务的，但是在开发环境Flask也能做到这些，只要创建一个static文件夹在包里面或者在你模块的旁边创建一个static文件夹，在应用中通过/static调用的方式就会起作用

为了给static文件生成一个URLs，可以使用一个特殊的static节点，如下


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

模板渲染

从Python中生成HTML并不好玩，而且实际上非常麻烦，你必须自己进行HTML转义以保证应用程序的安全。因此Flask自动为你配置了Jinja2模板引擎。

为了渲染一个模板你可以使用 render_template() 方法。你必须传递一个模板的名字和你想要传递给模板的变量到模板引擎作为关键字参数。下面这个是一个简单例子，演示了如何渲染一个模板


from flask import render_template

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

Flask将在templates文件夹中寻找对应的模板，如果你的应用是一个模块，这个文件夹将在模块的同一级，如果你的应用是一个包的话，则这个文件夹应该在包的里面，如下例子例子1：一个模块


/application.py
/templates
 /hello.html

例子2：一个包


/application
 /__init__py
 /templates
 /hello.html

对于模板，您可以使用Jinja2模板的全部功能。有关更多信息，请访问官方Jinja2模板文档。

下面是一个模板的例子


<!doctype html>
<title>
	Hello from Flask
</title>
{% if name %}
	<h1>Hello {{ name }}!</h1>
{% else %}
	<h1>Hello, World!</h1>
{% endif %}

在模板内部你可以访问request,session和g[1]对象，并且还可以使用get_flasjed_message()函数

模板的继承是非常有用的。如果你想要知道如何工作的，可以访问模板继承模式文档。基本上，模板继承可以在每个页面上保留某些元素（例如头部，导航和底部）

模板启动了自动转移功能，因为如果name中含有HTML，则会自动转义。如果你信任一个变量并且你知道它是一个安全的HTML（例如，它来自将wiki标记转换为HTML的模块）你可以使用Markup类标记他是安全的，或者通过使用|safe过滤下在模板中，有关更多示例，请访问Jinja 2文档

下面是一个简单的介绍，关于如何使用Markup类


>>> from flask import Markup
>>> Markup('<string>Hello %s!</strong>') % '<blink>hacker</blink>'
Markup('<string>Hello &lt;blink&gt;hacker&lt;/blink&gt;!</strong>')
>>> Markup.escape('<blink>hacker</blink>')
Markup('&lt;blink&gt;hacker&lt;/blink&gt;')
>>> Markup('<em>Marked up</em> &raquo; Html').striptags()
'Marked up » Html'

更改日志在0.5版本修改：不再为所有的模板启动自动转义。以.html,.htm,.xml,.xhtml扩展的模板将自动触发转义过滤。从字符串加载的模板将禁用自动转义。

[1] 不知道g对象是什么？它是一个你能存储你需要的信息的东西,有关详细信息，请查看该对象的文档（g）和使用带有Flask的SQLite 3。

访问请求数据

对于web应用程序，对客户端发送到服务器的数据做出相应是非常重要的，在Flask中这些信息通过全局request对象提供。如果你有一些Python开发经验，你也许想要知道改对象如何是全局的以及如何Flask如何设置他仍然是线程安全的。答案是上下文本地化

上下文本地化

如果你想知道它是如何工作的，并且想知道它是如何实现的，请阅读这部分否则跳过继续

Flask中的某些对象是全局对象，但是不是通常的对象。这些对象实际上是一个协议，而且能够本地化到一个特定的上下文。非常绕，但是实际上很容易理解。

想象下，这个上下文是一个处理中的线程。一个请求过来后服务器端决定产生一个新的线程（或其他东西，底层对象能够处理除线程之外的并发系统）。当Flask启动它的内部请求去处理它时，他会判断出当前线程是活动上下文并将当前应用程序和WSGI环境绑定到改上下文（线程）。它以智能的方式实现了这个逻辑，以便一个应用程序可以在不中断情况下调用另一个应用程序。

这对于你意味着什么呢？基本上你能完全忽略这个情况，除非你做了一些事情比如单元测试，你将注意到因为没有请求对象导致依赖于对象请求的代码将突然中断。这个解决方案就是你自己创建了一个请求对象然后绑定它到上下文，最简单的单元测试解决方案是使用test_request_context()上下文管理器。结合with语句时，它将会绑定一个测试请求使你能够跟它进行交互。下面是一个例子：


from flask import request

with app.test_request_context('/hello', method='POST'):
 assert request.path == '/hello'
 assert request.method == 'POST'

其他可能的情况是传入整个WSGI环境的到request_context()方法


from flask import request

with app.request_context(env):
 assert request.method == 'POST'

请求对象

请求对象被记录在API部分，这里暂时不做全覆盖的介绍，具体详情可以看Request或者看我后面的介绍，这里暂时只介绍下普通情况下用的比较频繁的操作，首先我们必须从flask模块导入它


from flask import request

通过使用method属性可以获取当前请求的方式。为了访问到表单数据（数据通过POST或者PUT方式请求）你可以使用form属性。这里是一个完整的例子，关于这两个属性的


@app.route('/login', methods=['POST', 'GET'])
def login():
 error = None
 if request.method == 'POST':
 if valid_login(request.form['username'], request.form['password']):
 return log_the_user_in(request.form['username'])
 else:
 error = 'Invalid username/password'

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

如果form的属性中没有对应的key会发生什么呢？这种情况下将会抛出一个KeyError异常。你可以像标准KeyError一样捕获它，但如果不这样做，则会显示HTTP 400错误请求错误页面。所以很多情况下你没必要处理这个问题。

要访问URL(?key=value)中提交的参数，可以使用args属性


key = request.args.get('key')

建议使用get或捕获KeyError来访问URL参数，因为用户可能会更改URL并向他们显示400个错误请求页面，在这种情况下体验并不友好。

有关请求对象的方法和属性的完整列表，请转到Request文档。

文件上传

你能很容易的使用Flask处理上传的文件。只要确保在提交的表单中不要忘记设置enctype="multipart/form-data"属性，否则浏览器将不会传递你的提交的文件

上传到文件存储在内存或者文件系统的一个临时的位置。你能通过request对象的files这个属性访问这些文件。每个上传的文件存储在一个字典中。它的行为就想标准的Python文件对象一样，但是也有一个**save()**方法，这个防范允许你将文件存储到服务器的文件系统中。下面是一个简单的演示例子


from flask import request

@app.route('/upload', methods=['GET','POST'])
def upload_file():
 if request.method == 'POST':
 f = request.files['file']
 f.save('/var/www/uploads/upload.txt')

如果您想知道文件在上传到您的应用程序之前在客户端上的命名方式，你可以通过访问filename属性。但请记住，这个价值可以伪造，所以永远不要相信这个价值。如果你想要使用客户端的文件名去存储到服务器上，通过Werkzeug为您提供的**secure_filename()**函数传递它。


from flask import request
from werkzeug.utils import secure_filename

@app.route('/upload', methods=['GET', 'POST'])
def upload_file():
 if request.method == 'POST':
 f = request.files['file']
 f.save('/var/www/upload/' + secure_filename(f.filename))

有关更好的示例，请查看上传文件章节。

Flask 1.0 快速入手【一】

Tue, 29 Jul 2025 10:09:13 +0800

是不是已经很想快点尝试下Flask了，本次分享将尽量全面的介绍Flask，继续下面的内容之前请确保您已经安装了Flask，如果你还没有安装的话，请回到前面的部分“Flask 1.0安装”再了解下如何安装。

一个小的应用

一个小应用的代码看起来像是下面这个样子


from flask import Flask
app = Flask(__name__)

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

下面解释下这段代码做了什么

首先我们导入了Flask类，这个类的实例将是我们WSGI应用的实例
下面创建这个类的实例。第一个参数是应用的模块或者包的名称。如果你使用一个单独的模块（比如这里的例子），你应该使用__name__，因为这个取决于应用是否作为一个应用程序启动还是作为一个模块导入，它的名称将是不同的（__main__与实际导入的名称相对应）。这个是必须要传入的参数，会让Flask知道去哪里查找模板、静态文件等等，有关于更多的信息可以查看Flask的官方文档
我们使用route()装饰器去告诉Flask什么样的URL路由将会触发我们的函数
hello_world这个函数的名称也是有用的，后面在生成URLs的时候会有特殊的功能，而且函数的返回值将展示在用户的浏览器上。

只需要保存上面的代码到文件hello.py或者是其他的名称带有后缀.py的文件即可，同时确保文件的名称不能叫做flask.py，因为这样会是的自己的文件脚本跟Flask自己冲突。

为了运行应用程序，你既可以使用flask命令也可以使用python的-m启动Flask.不过在你运行程序前你应该在终端导入一个环境变量FALSK_APP，如下：


$ export FLASK_APP=hello.py
$ flask run
 * Serving Flask app "hello.py"
 * Environment: production
 WARNING: Do not use the development server in a production environment.
 Use a production WSGI server instead.
 * Debug mode: off
 * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)

如果您使用的是Windows，则环境变量语法取决于命令行解释程序。在命令提示符上:


C:\path\to\app>set FLASK_APP=hello.py

在PowerShell上：


PS C:\path\to\app> $env:FLASK_APP = "hello.py"

另外你也可以使用python -m flask


$ export FLASK_APP=hello.py
$ python -m flask run
 * Serving Flask app "hello.py"
 * Environment: production
 WARNING: Do not use the development server in a production environment.
 Use a production WSGI server instead.
 * Debug mode: off
 * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)

外部可见服务器

这将运行一个非常简单的内置服务器，对于开发和测试是足够用了，但是不是你想在生产环境使用的东西。后面会有相关部署环节的介绍。

如果你启动了上面的程序的话，你将会注意到，运行起来的服务只能你自己的电脑才能访问，网络上其他的电脑是没有办法访问的。在debug模式中这是默认的行为，只允许你自己在你自己的电脑上随意的执行Python代码

如果你禁止了debug模式或者新人在在同一网络上的用户，你可以公开你的服务，只需要简单的在命令行中加入--host=0.0.0.0


flask run --host=0.0.0.0

这个操作将会告诉你的电脑，去监听所有公开的网络ip

如果服务没有启动该做什么

一旦python -m flask启动失败或者flask不存在，这总情况可能有多种原因，首先你需要仔细看一下报错的错误信息

旧的flask版本

Flask版本小于0.11的话会有不同的方式启动应用，简而言之，flask命令不存在，而且也没有python -m flask。这种情况下有两种选择，一是将Flask升级到新版本，二是看下这个开发服务器文档遭到启动服务器的替代方法

导入名称无效

FLASK_APP环境变量是在flask run的时候导入的模块的名称，在这种情况下，模块的名称是错误的话你将得到一个启动时导入错误提示（或者，如果导航到应用程序时启用了调试），它将告诉你试图导入的内容以及失败的原因。

最常见的错误是拼写错误或者是因为你实际上并没有创建一个应用程序对象

调试模式

(想要记录错误和堆栈跟踪？请看应用程序错误) flask脚本能够很适合启动一个本地的开发服务器，但是每次更改代码后都需要重新启动服务器。这不是很好，Flask能做的更好，如果启动了调试支持，服务器将在代码改动后自动重新加载，如果出现问题，他还会提供一个有用的调试器。

为了启用所有开发功能（包括调试模式），你需要在启动服务器前导入FLASK_ENV环境变量并且设置它的值为development


$ export FLASK_ENV=development
$ flask run

（在Windows环境中需要用set代替export）

这样做有以下几点：

它激活了调试器
它激活了自动重新加载器
它启用了Flask应用程序上的调试模式。

你也能通过导入变量FLASK_DEBUG=1来单独控制调试模式

在开发服务器中有更多关于参数的介绍

注意

尽管交互调试器不能在工作在分叉环境中（几乎不可能在生产环境中使用），他仍然允许执行任务的代码，这就使得服务器非常的不安全，所以绝对不要在生产服务上使用

下面是一个调试器的截图

有关使用调试器的更多信息，请参阅Werkzeug文档。还有另一个调试器吗？请参阅使用调试器。

路由

现代的web应用使用更加有意义的URLs去帮助用户，如果页面使用有意义的并且用户可以记住的URL，用户可能会更喜欢这个页面并返回来直接访问该页面。

使用route()装饰器来绑定一个函数到一个URL地址上：


@app.route('/')
def index():
	return 'Index Page'

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

你可以做得更多！可以将URL的一部分动态化并将多个规则附加到函数。

变量规则

使用<variable_name>标记部分添加变量部分到URL。你的函数将接收到<variable_name>作为关键字参数。你也可以一个转换器，来定义具体的参数类型像这样<converter:variable_name>(可选)


@app.route('/user/<username>')
def show_user_profile(username):
	return 'User %s' % username

@app.route('/post/<int:post_id>')
def show_post(post_id):
	return 'Post %d' % post_id

@app.route('/path/<path:subpath>')
def show_subpath(subpath):
	return 'Showpath %s' % subpath

转换器类型：

类型	描述
string	接收任意字符串除了斜杠（默认情况下接收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地址不带有最后的斜杠，Flask则重定向到一个尾部带有斜杠的规范路由

about的规范路由最后部分没有斜杠，类似于一个文件的文件路径名。如果你访问这个URL地址最后带有斜杠的话，会产生一个404“Not Found”错误。这有助于保持URL对这些资源的唯一性，并且保持搜索引擎避免两次索引同一页面

URL构建

为了构建一个URL地址到一个具体的函数，使用url_for()函数。它接收一个函数的名字作为第一个参数和任意数量的关键字参数，每一个对应到URL规则变量的对应部分。未知的变量部分作为查询参数附加到URL

为什么要使用URL转换函数url_for()来构建URL，而不是用硬编码的方式写在模板里面

转换要比硬编码十分具有描述性
你可以一次性修改网址而不比记住它手动去修改硬编码的URL网址
URL构建处理特殊字符和Unicode数据的转义
产生的网址路径都是绝对的，避免了不必要的相对路径的麻烦
如果您的应用程序位于URL根目录之外，例如，在/myapplication而不是/，url_for()能够妥善处理这些问题

例如下面我们使用test_request_context()方法来测试url_for().test_request_context()告诉Flask。即使我们使用Python shell，它也会像处理请求一样。请参阅上下文本地。


from flask import Flask, url_for
app = Flask(__name__)

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

@app.route('/login')
def login():
 return 'Login page'

@app.route('/user/<username>')
def profile(username):
 return '{}\'s profile'.format(username)

with app.test_request_context():
 print(url_for('index'))
 print(url_for('login'))
 print(url_for('login', next='/'))
 print(url_for('profile', username='Durban'))

/
/login
/login?next=%2F
/user/Durban

HTTP方法

Web应用程序在访问URL时使用不同的HTTP方法，在使用Flask开发时，你自己应该熟悉HTTP方法，默认情况下，一个路由只回应一个GET请求，你可以使用route()装饰器的第二个参数来处理不同的HTTP方法


from flask import Flask

@app.route('/login', methods=['GET', 'POST'])
def login():
	if request.method == 'POST':
		return 'do the login'
	else:
		return 'show the login form'

如果存在GET，Flask会自动添加对HEAD方法的支持，并根据HTTP RFC处理HEAD请求。同样，OPTIONS会自动为您实施

Flask 1.0 - 安装

Tue, 29 Jul 2025 10:09:10 +0800

Python版本要求

Flask从1.0开始支持Python 3，Flask支持Python 3.4和最新版本，以及Python 2.7和PyPy，同时官方建议使用Python 3的最新版本，由此可以看出Flask 从1.0开始拥抱Python 3

包依赖

Werkzeug 实现WSGI，它是应用程序和服务器之间的标准Python接口
Jinja 一种模板语言，用于呈现应用程序所服务的页面
MarkupSafe 附带Jinja. 它在渲染模板时逃避不受信任的输入以避免注入攻击。
ItsDangerous 安全地签署数据以确保其完整性。这用于保护Flask的会话cookie。
Click 是一个用于编写命令行应用程序的框架。它提供flask命令并允许添加自定义管理命令。

这些包会在安装Flask后自动安装

其他可选包

Blinker 为Signals提供支持.
SimpleJSON 是一个快速的JSON实现，与Python的json模块兼容。如果安装了JSON操作，则首选它。
python-dotenv 在运行flask命令时启用对 dotenv的环境变量的支持。
Watchdog 为开发服务器提供更快，更高效的重新加载器。

以上的可选包不会自动安装，不过，如果你安装了的话，Flask将自动监测并使用他们

虚拟环境

建议在开发和生产中使用虚拟环境来管理你项目的依赖库。

虚拟环境能解决什么问题呢？如果你拥有Python的项目越多，你需要使用不同版本的Python库的可能性就越大，甚至是Python本身。一个较新版本的Python库可能会打破另一个项目的兼容性

虚拟环境是独立的Python库组合，每个项目一个。一个项目安装的软件包不会影响其他项目或操作系统的软件包。

Python 3已经绑定了venv模块用来创建虚拟环境。如果你使用的是Python 3，可以继续下面的操作。

如果你使用的是Python 2，首先先看下“安装virtualenv”

创建虚拟环境

创建一个项目目录然后添加一个.venv_baby文件夹，当然这个文件夹你也可以根据自己的需要来定义：


mkdir baby
cd baby
python3 - venv .venv_baby

Windows环境下的操作


py -3 -m venv .venv_baby

如果您使用的是旧版本的Python，您需要安装virtualenv，请使用一下命令：


virtualenv .venv_baby

Windows环境下的操作


\Python27\Scripts\virtualenv.exe .venv_baby

激活环境

在你的项目中工作前，激活相应的环境


. .venv_baby/bin/activate

在Windows环境下


.venv_baby\Scripts\activate

你的shell提示中将显示激活环境的名称

安装Flask

在激活的环境中使用下面的命令安装Flask


pip install Flask

如果您希望在发布之前使用最新的Flask代码，请安装或更新主分支中的代码：


pip install -U https://github.com/pallets/flask/archive/master.tar.gz

安装virtualenv

如果你使用的是Python 2，venv模块是不可用的，因此需要安装virtualenv 在Linux系统中，virtualenv由包管理器提供


# Debian, Ubuntu
sudo apt-get install python-virtualenv

# CentOS, Fedora
sudo yum install python-virtualenv

# Arch
sudo pacman -S python-virtualenv

如果你的系统是Mac OS或者Windows，先下载get-pip.py，然后执行下面的代码


sudo python2 Downloads/get-pip.py
sudo python2 -m pip install virtualenv

在Windows系统上，已administrator的身份执行


\Python27\python.exe Downloads\get-pip.py
\Python27\python.exe -m pip install virtualenv

现在返回到上面的“创建虚拟环境”.

Flask 1.0 生产环境部署记录

Tue, 29 Jul 2025 10:09:06 +0800

Flask 1.0 开始支持Python3啦，一直在使用Flask构建自己的博客，今天重温看了下Flask1.0，感觉还是有很多优点的，随后根据官网的教程搞了一个简易的小博客，整体使用下来，还算是比较轻便的。唯独在部署上不是那么的轻松，但是经过查询也算是找到了解决办法，跟之前的Flask版本不同的是，我这次想试下Gunicorn+Nginx+Supervisor。

安装的部分就不用我多说，我是把Gunicorn安装在了项目目录下，实际上作为一个项目的话Gunicorn是没必要放在项目中的，毕竟一个是服务层一个是逻辑层。

为了Gunicorn的启动配置项简单明了，最好是建立一个配置文件，这样下次也能清楚里面启动的时候配置了哪些参数，网上找了一个配置，仅供参考

gunicorn.conf


# 并行工作进程数
workers = 4
# 指定每个工作者的线程数
threads = 2
# 监听内网端口5000
bind = '127.0.0.1:8000'
# 设置守护进程,将进程交给supervisor管理
daemon = 'false'
# 设置最大并发量
worker_connections = 2000
# 设置进程文件目录
pidfile = '/var/tmp/gunicorn.pid'
# 设置访问日志和错误信息日志路径
accesslog = '/var/tmp/gunicorn_access.log'
errorlog = '/var/tmp/gunicorn_error.log'
# 设置日志记录水平
loglevel = 'warning'

这里的配置注意daemon为false

然后添加supervisor的配置，这里要做的只是简单的添加supervisor配置，至于supervisor的安装还是很简单的，mac下建议使用brew安装

贴出一份我这边测试时使用的配置

baby.ini


[program:baby]
directory = /Users/durban/python/baby ; 程序的启动目录
command = gunicorn -c /Users/durban/python/baby/gunicorn.conf baby ; 启动命令，可以看出与手动在命令行启动的命令是一样的
autostart = true ; 在 supervisord 启动的时候也自动启动
startsecs = 5 ; 启动 5 秒后没有异常退出，就当作已经正常启动了
autorestart = true ; 程序异常退出后自动重启
startretries = 3 ; 启动失败自动重试次数，默认是 3
user = durban ; 用哪个用户启动
redirect_stderr = true ; 把 stderr 重定向到 stdout，默认 false
stdout_logfile_maxbytes = 20MB ; stdout 日志文件大小，默认 50MB
stdout_logfile_backups = 20 ; stdout 日志文件备份数
; stdout 日志文件，需要注意当指定目录不存在时无法正常启动，所以需要手动创建目录（supervisord 会自动创建日志文件）
stdout_logfile = /var/tmp/baby_stdout.log

; 可以通过 environment 来添加需要的环境变量，一种常见的用法是修改 PYTHONPATH
; environment=PYTHONPATH=$PYTHONPATH:/path/to/somewhere

然后重启下supervisor就可以了

这里注意下supervisor的问题，如果你supervisor的配置文件是在/etc/等supervisor默认搜索的目录下的话直接使用supervisorctl reload是没有任何问题的，如果配置文件不在默认的搜索目录下的话，就会报类似refused connection的错误提示，建议操作supervisor的时候，指定下配置文件，如下


supervisorctl -c /usr/local/etc/supervisord.ini reload

然后配置nginx，简单的配置示例如下


server {
	charset utf-8;

	client_max_body_size 128M;

	listen 80;

	server_name flask1.walkerfree.local; # 这是HOST机器的外部域名，用地址也行

	access_log /var/log/flask1.walkerfree.local.access.log;
	error_log /var/log/flask1.walkerfree.local.error.log;

	location / {
		proxy_pass http://127.0.0.1:8000; # 这里是指向 gunicorn host 的服务地址
		proxy_set_header Host $host;
		proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
	}

	location ~ /\.(git|svn|ht) {
		deny all;
	}
}

Flask 日志邮件发送客户端授权密码验证错误

Mon, 28 Jul 2025 17:52:42 +0800

最近在使用flask的日志邮件发送功能，就是程序出现问题的时候，可以通过邮件发送到指定的邮箱，当时使用的是QQ邮箱的

基本上会有如下的错误

smtplib.SMTPAuthenticationError: (535, b’Error: authentication failed')

smtplib.SMTPServerDisconnected: Connection unexpectedly closed

Connection unexpectedly closed: timed out

开始的配置如下


ADMINS = ['xxx@xxx']
MAIL_SUBJECT_PREFIX = '[Walkerfree]'
MAIL_SENDER = 'xxx@xxx'
MAIL_SERVER = 'smtp.qq.com'
MAIL_PORT = 465
MAIL_USE_SSL = True
MAIL_USE_TLS = False
MAIL_USERNAME = 'xxx@xxx'
MAIL_PASSWORD = '123456'

在测试的时候会遇到超时，但是是这里的问题


mail_handler = SMTPHandler(
 application.config['MAIL_SERVER']
 application.config['MAIL_SENDER'],
 application.config['ADMINS'],
 'application error',
 (
 application.config['MAIL_USERNAME'],
 application.config['MAIL_PASSWORD'],
 )
 )

第一个参数没有传递端口号，可以看源码


self.mailhost, self.mailport = mailhost

有mailhost和mailport，没有端口号怎么能行呢

修改后如下


mail_handler = SMTPHandler(
 (
 application.config['MAIL_SERVER'],
 application.config['MAIL_PORT']
 ),
 application.config['MAIL_SENDER'],
 application.config['ADMINS'],
 'application error',
 (
 application.config['MAIL_USERNAME'],
 application.config['MAIL_PASSWORD'],
 )
 )

报错如下


SMTPServerDisconnected: Connection unexpectedly closed: timed out

最后修改了配置，如下


ADMINS = ['xxx@xxx']
MAIL_SUBJECT_PREFIX = '[Walkerfree]'
MAIL_SENDER = 'xxx@xxx'
MAIL_SERVER = 'smtp.qq.com'
MAIL_PORT = 25
MAIL_USE_SSL = True
MAIL_USE_TLS = False
MAIL_USERNAME = 'xxx@xxx'
MAIL_PASSWORD = '123456'

最后发送成功。客户端授权码的这个需要自己去搞，QQ帮助中心有指引的。

快捷链接:http://service.mail.qq.com/cgi-bin/help?subtype=1&&id=28&&no=1001256%27)

Flask 之 Gunicorn启动应用程序

Tue, 22 Jul 2025 18:31:35 +0800

Gunicorn的介绍我就不锁了，但是我这里简单记录一下我自己是如何使用Gunicorn的。

首先安装Gunicorn

pip install gunicorn

然后添加一下gunicorn的启动文件-gunicorn.conf

workers = 8
bind = '127.0.0.1:3041'
daemon = True
accesslog = './walkerfree/logs/access.log'
errorlog = './walkerfree/logs/error.log'

上面的log路径可以根据自己的情况进行修改，bind的内容也是一样的

最后启动自己的web应用

gunicorn wsgi:application -c gunicorn.conf

到这里会有一个疑问是：wsgi:application，是这样的，首先创建一个wsgi文件，是的就是这个文件，这个跟python的包有关

# _*_ coding=utf-8 _*_

from walkerfree import app
from walkerfree.config import config
from walkerfree import bootstrap
from walkerfree import mail
from walkerfree import moment
from walkerfree import db
from walkerfree import cache
from walkerfree import dispatch_handlers, register_blueprints, register_jinja_env, configure_assets, configure_logging

def create_app(config_name):
 app.config.from_object(config[config_name])
 config[config_name].init_app(app)
 bootstrap.init_app(app)
 mail.init_app(app)
 moment.init_app(app)
 db.init_app(app)
 cache.init_app(app)

 dispatch_handlers(app)
 register_blueprints(app)
 register_jinja_env(app)
 configure_logging(app)
 configure_assets(app)

 return app

application = create_app('production')

if __name__ == '__main__':
 application.run()

我这里的代码，是根据自己的情况定义的。

Flask之更新表结构

Tue, 22 Jul 2025 18:31:31 +0800

使用Flask的过程中，对于操作数据库这一块会用到Flask-SqlAlchemy,项目开始的时候是没有什么问题的，但是在后面由于业务需求会涉及到修改表的操作，那么问题来了，表的结构被修改之后，又如何才能同步到生产环境的数据库呢。

这里推荐使用一个Flask的插件-Flask-Migrage.下面掩饰一下如何去操作。

Flask-Migrate的安装：

pip install flask-migrate

创建app.py，代码如下：

from flask import Flask
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.script import Manager
from flask.ext.migrate import Migrate, MigrateCommand

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///app.db'

db = SQLAlchemy(app)
migrate = Migrate(app, db)

manager = Manager(app)
manager.add_command('db', MigrateCommand)

class User(db.Model):
 id = db.Column(db.Integer, primary_key=True)
 name = db.Column(db.String(128))

if __name__ == '__main__':
 manager.run()

保存如何代码后，实行如下代码：

python app.py db init

这个动作是说，初始化migrate需要的环境，接下来生成一个数据表操作的代码文件：

python app.py db migrate

如果没有报错的话，会出现一系列的提示信息，这里具体情况不一样，我就不一列出来了。

如果上面执行后没有问题的话，就可以进行数据库表的更新了。

python app.py db upgrade

执行上面的代码，就可以更新数据库表的结构了。

Flask SqlAlchemy Like 查询

Tue, 22 Jul 2025 18:31:27 +0800

SQLAlchemy 如何进行 mysql的Like查询呢？

Article.query.join(Category).filter(Article.title.like("%%s%", name), Article.is_deleted == 0).order_by(Article.id.desc())

supervisor + uwsgi + flask

Fri, 04 Jul 2025 11:48:04 +0000

supervisor启动flask项目中，配置了uwsgi，即通过supervisor启动uwsgi，uwsgi再启动flask项目
这个过程中uwsgi是个坑

<uwsgi>
 <chdir>/relativeProjectPath</chdir>
 <module>wsgi_handler</module>
 <socket>/tmp/walkerfree-uwsgi.sock</socket> 
 <daemonize>/tmp/uwsgi.walkerfree.log</daemonize>
 <master>4</master>
 <chmod-socket>666</chmod-socket>
 <enable-threads />
 <processes>4</processes>
 <harakiri>30</harakiri>
 <workers>6</workers>
 <memory-report />
 <vacuum/>
</uwsgi>

这个是我的初始配置文件，如果单独使用uwsgi启动是没有问题的，但是放在supervisor就有问题，会启动很多个uwsgi进程，而且supersior也会报错
我见到的错误如下几种
1】ERROR (spawn error)
2】BACKOFF Exited too quickly (process log may have details)

先给下最终的uwsgi配置方案,如下

<uwsgi>
 <chdir>relativeProjectPath</chdir>
 <module>wsgi_handler</module>
 <socket>/tmp/walkerfree_uwsgi.sock</socket> 
 <logto>/tmp/walkerfree_uwsgi.log</logto>
 <chmod-socket>666</chmod-socket>
 <enable-threads />
 <processes>1</processes>
 <harakiri>30</harakiri>
 <memory-report />
 <vacuum/>
</uwsgi>

具体有几个坑吧，我试了两种，具体有一下几个方法
第一个:
修改daemonize为logto
第二个:
去掉master【这项可以不用去掉，如果不起作用可以试试】
去掉workers【这项可以不用去掉，如果不起作用可以试试】
修改processes为1

supervisor中项目的配置如下

[program:walkerfree]
# http://supervisord.org/configuration.html#program-x-section-example
command=/projectPath/env/bin/uwsgi -x /projectPath/uwsgi.xml
autostart=true
autorestart=true
stdout_logfile=/projectPath/supervisor/out.log
stderr_logfile=/projectPath/supervisor/err.log

2015-09-10 工作记录

Tue, 01 Jul 2025 15:04:20 +0000

1、查看innodb死锁情况

查看事务情况

show engine innodb status\G

查看事务详情

SELECT * FROM information_schema.INNODB_TRX\G

2、kibana 4 添加图表，以及如何在dashboard【仪表板】上展示所有的图表或者分开展示图表

添加图表的流程一定要清楚，先要有visualization【可视化视图】，然后才能在dashboard【仪表板】上面添加图表，事实上图表就是所谓的

visualization【可视化视图】；

这里的操作关键比较难的是如何添加visualization【可视化视图】，并且在添加visualization【可视化视图】过程中的Filter的操作。

Filter说起来也很简单就是搜索出你要展示的数据数量的值，比如访问链接地址的时长，某个链接的请求次数的值。

关键是在添加visualization【可视化视图】过程中，先要选择视图的类型，然后就要对metrics和buckets的操作。

这里有一篇关于kibana4的图表入门：请点击这里

3、curl 指定用户以及密码访问

很简单：

curl -u user:password -XGET http://www.xxx.net/study/

就可以了.

4、通过python的线程实现异步发送邮件

from threading import Thread
def send_async_email(app, msg):
 with app.app_context():
 mail.send(msg)
def send_email(to, subject, template, **kwargs):
 msg = Message(app.config['FLASKY_MAIL_SUBJECT_PREFIX'] + subject,
 sender=app.config['FLASKY_MAIL_SENDER'], recipients=[to])
 msg.body = render_template(template + '.txt', **kwargs)
 msg.html = render_template(template + '.html', **kwargs)
 thr = Thread(target=send_async_email, args=[app, msg])
 thr.start()
 return thr

5、针对Flask项目初始化数据库

>>> from walkerfree import config
>>> from walkerfree import app
>>> app.config.from_object(config['development'])
>>> from walkerfree import db
>>> db.init_app(app)
>>> db
<SQLAlchemy engine='mysql+mysqldb://root:@127.0.0.1/walkerfree?charset=utf8'>
>>> db.create_all()

Flask + uwsgi 在Nginx服务器上部署

Mon, 30 Jun 2025 14:30:51 +0000

Nginx配置如下：

server {
 listen 80; ## listen for ipv4; this line is default and implied
 #listen [::]:80 default ipv6only=on; ## listen for ipv6

 server_name flask.blog.gowhich.dev;

 location / {
 include uwsgi_params;
 uwsgi_pass 0.0.0.0:3032;
 }
}

uwsgi 【uwsgi.xml】配置如下：

<uwsgi>
 <chdir>/xxx/xxx/python/python_project/flask_blog_small_1</chdir>
 <module>flask_blog</module>
 <callable>app</callable>
 <socket>0.0.0.0:3032</socket> 
 <daemonize>/var/log/uwsgi.flask.blog.log</daemonize>
 <master/>
 <processes>4</processes>
 <memory-report/>
</uwsgi>

启动uwsgi和nginx便可完成部署;

这里的端口号只要保证与uwsgi的端口号一直就可以，不用考虑flask自己运行的脚本

Flask中实现使用Mongodb分页的程序逻辑

Mon, 30 Jun 2025 14:09:00 +0000

实现的逻辑如下：

page = int(request.args.get('page')) if request.args.get('page') else 1
 pagesize = 20
 prev_page = page - 1 if page - 1 else 1
 next_page = page + 1
 
 # 关键字查询
 keywords = request.args.get('keywords')
 start_date = request.args.get('start_date') 
 end_date = request.args.get('end_date')
 
 params = []
 params_query = {}
 if keywords:
 params.append({'title':{'$regex':'^%s' %keywords }})
 params_query['keywords'] = keywords
 
 if start_date and end_date:
 start = '%s 00:00:00' % start_date
 end = '%s 23:59:59' % end_date
 start = int(time.mktime(time.strptime(start,'%Y-%m-%d %H:%M:%S')))
 end = int(time.mktime(time.strptime(end,'%Y-%m-%d %H:%M:%S')))
 params.append({'create_time':{'$gt':start}})
 params.append({'create_time':{'$lte':end}})
 
 params_query['start_date'] = start_date
 params_query['end_date'] = end_date
 
 if params:
 # if len(params) == 1:
 # where = params
 # else:
 where = {'$and':params} 
 itunes_sum = mongo.db.itunes.find(where).count()
 itunes = mongo.db.itunes.find(where).skip((page - 1) * pagesize).sort('create_time',-1).limit(pagesize)
 else:
 itunes_sum = mongo.db.itunes.count()
 itunes = mongo.db.itunes.find().skip((page - 1) * pagesize).sort('create_time',-1).limit(pagesize)
 
 return render_template(
 'front/spider_itunes.html',
 itunes=itunes,
 itunes_sum=itunes_sum,
 title=u"iTunes爬虫",
 prev_page=prev_page,
 next_page=next_page,
 params=params_query
 )

mongodb还是别扭点，常用就好了。

Flask中实现使用SQLAlchemy MySQLdb分页的程序逻辑

Mon, 30 Jun 2025 14:08:58 +0000

逻辑的话还是蛮简单的，多查看一个文档就可以了。代码如下

page = int(request.args.get('page')) if request.args.get('page') else 1
 pagesize = 20
 prev_page = page - 1 if page - 1 else 1
 next_page = page + 1
 
 # 关键字查询
 keywords = request.args.get('keywords')
 start_date = request.args.get('start_date') 
 end_date = request.args.get('end_date')
 
 params_query = {}
 query = Itunes.query
 if keywords:
 query = query.filter(Itunes.title.startswith(keywords))
 params_query['keywords'] = keywords
 
 if start_date and end_date:
 start = '%s 00:00:00' % start_date
 end = '%s 23:59:59' % end_date
 start = int(time.mktime(time.strptime(start,'%Y-%m-%d %H:%M:%S')))
 end = int(time.mktime(time.strptime(end,'%Y-%m-%d %H:%M:%S')))
 
 query = query.filter(Itunes.create_time > start)
 query = query.filter(Itunes.create_time <= end)
 
 params_query['start_date'] = start_date
 params_query['end_date'] = end_date
 
 if params_query: 
 itunes_sum = query.count()
 itunes = query.offset((page-1)*pagesize).limit(pagesize).all()
 else:
 itunes_sum = Itunes.query.count()
 itunes = Itunes.query.offset((page-1)*pagesize).limit(pagesize).all()
 
 
 
 return render_template(
 'front/spider_apple.html',
 itunes=itunes,
 itunes_sum=itunes_sum,
 title=u"Apple爬虫",
 prev_page=prev_page,
 next_page=next_page,
 params=params_query
 )