Flask 1.1.x官方文档：快速入门与高级特性详解

需积分: 10 126 浏览量更新于2024-07-15 收藏 1.25MB PDF 举报

Flask是Python编程语言中一个轻量级的Web开发框架，由Pallets团队维护。该文档（版本1.1.x）提供了详尽的用户指南、API参考以及额外的技术细节，适合初学者和经验丰富的开发者。以下是文档内容的详细概述： 1. **用户指南**：这部分从介绍Flask的基本概念开始，包括对Flask框架的简介，对有经验的程序员的额外建议，以及安装步骤。快速入门部分教会读者如何创建和运行第一个Flask应用。 2. **教程**：教程部分深入浅出地介绍了如何设计和实现Web应用，涉及模板系统、路由、请求处理、数据绑定等核心功能。 3. **模板系统**：讲解了如何使用Flask的模板引擎进行动态网页渲染，包括变量、控制结构、循环和条件语句的使用。 4. **测试Flask应用**：文档指导开发者如何编写单元测试和集成测试，确保应用的稳定性和可靠性。 5. **错误处理与调试**：讨论了如何识别和处理应用中的错误，以及如何使用调试工具进行问题排查。 6. **配置管理**：讲解了如何管理和加载应用程序的配置选项，以及如何处理环境切换。 7. **信号系统**：介绍Flask的信号机制，允许开发者在特定事件发生时执行自定义操作。 8. **插件视图**：阐述如何利用插件机制扩展Flask应用的功能，提供模块化开发的方法。 9. **上下文管理**：区分了应用上下文（ApplicationContext）和请求上下文（RequestContext），解释它们的作用和用法。 10. **蓝本（Blueprints）**：蓝本是Flask中实现模块化应用的一种方式，有助于组织大型项目的结构。 11. **扩展与插件**：讨论了如何使用第三方库扩展Flask框架，以及开发自己的Flask扩展的指南。 12. **命令行接口（CLI）**：介绍了Flask提供的命令行工具，用于方便开发过程中的各种任务。 13. **开发服务器与Shell**：讲解了如何使用Flask的开发服务器进行本地开发，并介绍了shell模式，用于交互式执行代码。 14. **模式与最佳实践**：列举了一些开发Flask应用的常见模式和最佳实践，帮助开发者优化他们的工作流程。 15. **部署选项**：探讨了不同类型的生产环境部署策略，如WSGI服务器、容器化部署等。 16. **应用扩展**：对于面临性能或规模增长的应用，文档讨论了如何保持代码简洁和可维护性。 17. **API参考**：详细列出Flask框架的所有API，包括类、函数和装饰器，供开发者查阅。 18. **额外注意事项**：涵盖了设计决策、HTML/XHTML常见问题、安全考虑、Unicode支持、Flask扩展开发指南、升级指南、变更日志以及贡献方式等内容。这份官方文档提供了丰富的资源，无论你是Flask的初学者还是高级开发者，都能从中找到所需的信息，以便更好地理解和构建基于Flask的Web应用。

Flask Documentation (1.1.x), Release 1.1.2

URL Building

To build a URL to a speciﬁc function, use the url_for() function. It accepts the name of the function as its ﬁrst

argument and any number of keyword arguments, each corresponding to a variable part of the URL rule. Unknown

variable parts are appended to the URL as query parameters.

Why would you want to build URLs using the URL reversing function url_for() instead of hard-coding them into

your templates?

1. Reversing is often more descriptive than hard-coding the URLs.

2. You can change your URLs in one go instead of needing to remember to manually change hard-coded URLs.

3. URL building handles escaping of special characters and Unicode data transparently.

4. The generated paths are always absolute, avoiding unexpected behavior of relative paths in browsers.

5. If your application is placed outside the URL root, for example, in /myapplication instead of /,

url_for() properly handles that for you.

For example, here we use the test_request_context() method to try out url_for().

test_request_context() tells Flask to behave as though it’s handling a request even while we use a

Python shell. See Context Locals.

from flask import Flask, url_for

from markupsafe import escape

app = Flask(__name__)

@app.route('/')

def index():

return 'index'

@app.route('/login')

def login():

return 'login'

@app.route('/user/<username>')

def profile(username):

return '{}\'s profile'.format(escape(username))

with app.test_request_context():

print(url_for('index'))

print(url_for('login'))

print(url_for('login', next='/'))

print(url_for('profile', username='John Doe'))

/login

/login?next=/

/user/John%20Doe

HTTP Methods

Web applications use different HTTP methods when accessing URLs. You should familiarize yourself with the HTTP

methods as you work with Flask. By default, a route only answers to GET requests. You can use the methods

argument of the route() decorator to handle different HTTP methods.

12 Chapter 1. User’s Guide

Flask Documentation (1.1.x), Release 1.1.2

/application

/__init__.py

/templates

/hello.html

For templates you can use the full power of Jinja2 templates. Head over to the ofﬁcial Jinja2 Template Documentation

for more information.

Here is an example template:

<!doctype html>

<title>Hello from Flask</title>

{% if name %}

<h1>Hello {{ name }}!</h1>

{% else %}

<h1>Hello, World!</h1>

{% endif %}

Inside templates you also have access to the request, session and g

objects as well as the

get_flashed_messages() function.

Templates are especially useful if inheritance is used. If you want to know how that works, head over to the Template

Inheritance pattern documentation. Basically template inheritance makes it possible to keep certain elements on each

page (like header, navigation and footer).

Automatic escaping is enabled, so if name contains HTML it will be escaped automatically. If you can trust a variable

and you know that it will be safe HTML (for example because it came from a module that converts wiki markup to

HTML) you can mark it as safe by using the Markup class or by using the |safe ﬁlter in the template. Head over to

the Jinja 2 documentation for more examples.

Here is a basic introduction to how the Markup class works:

>>> from markupsafe import Markup

>>> Markup('<strong>Hello %s!</strong>') % '<blink>hacker</blink>'

Markup(u'<strong>Hello <blink>hacker</blink>!</strong>')

>>> Markup.escape('<blink>hacker</blink>')

Markup(u'<blink>hacker</blink>')

>>> Markup('<em>Marked up</em> » HTML').striptags()

u'Marked up \xbb HTML'

Changed in version 0.5: Autoescaping is no longer enabled for all templates. The following extensions for tem-

plates trigger autoescaping: .html, .htm, .xml, .xhtml. Templates loaded from a string will have autoescaping

disabled.

1.4.7 Accessing Request Data

For web applications it’s crucial to react to the data a client sends to the server. In Flask this information is provided

by the global request object. If you have some experience with Python you might be wondering how that object

can be global and how Flask manages to still be threadsafe. The answer is context locals:

Context Locals

Insider Information

Unsure what that g object is? It’s something in which you can store information for your own needs, check the documentation of that object

(g) and the Using SQLite 3 with Flask for more information.

14 Chapter 1. User’s Guide

Flask Documentation (1.1.x), Release 1.1.2

If you want to understand how that works and how you can implement tests with context locals, read this section,

otherwise just skip it.

Certain objects in Flask are global objects, but not of the usual kind. These objects are actually proxies to objects that

are local to a speciﬁc context. What a mouthful. But that is actually quite easy to understand.

Imagine the context being the handling thread. A request comes in and the web server decides to spawn a new

thread (or something else, the underlying object is capable of dealing with concurrency systems other than threads).

When Flask starts its internal request handling it ﬁgures out that the current thread is the active context and binds the

current application and the WSGI environments to that context (thread). It does that in an intelligent way so that one

application can invoke another application without breaking.

So what does this mean to you? Basically you can completely ignore that this is the case unless you are doing

something like unit testing. You will notice that code which depends on a request object will suddenly break because

there is no request object. The solution is creating a request object yourself and binding it to the context. The easiest

solution for unit testing is to use the test_request_context() context manager. In combination with the with

statement it will bind a test request so that you can interact with it. Here is an example:

from flask import request

with app.test_request_context('/hello', method='POST'):

# now you can do something with the request until the

# end of the with block, such as basic assertions:

assert request.path == '/hello'

assert request.method == 'POST'

The other possibility is passing a whole WSGI environment to the request_context() method:

from flask import request

with app.request_context(environ):

assert request.method == 'POST'

The Request Object

The request object is documented in the API section and we will not cover it here in detail (see Request). Here is a

broad overview of some of the most common operations. First of all you have to import it from the flask module:

from flask import request

The current request method is available by using the method attribute. To access form data (data transmitted in a

POST or PUT request) you can use the form attribute. Here is a full example of the two attributes mentioned above:

@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'

# the code below is executed if the request method

# was GET or the credentials were invalid

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

1.4. Quickstart 15

Flask Documentation (1.1.x), Release 1.1.2

What happens if the key does not exist in the form attribute? In that case a special KeyError is raised. You can

catch it like a standard KeyError but if you don’t do that, a HTTP 400 Bad Request error page is shown instead. So

for many situations you don’t have to deal with that problem.

To access parameters submitted in the URL (?key=value) you can use the args attribute:

searchword = request.args.get('key', '')

We recommend accessing URL parameters with get or by catching the KeyError because users might change the

URL and presenting them a 400 bad request page in that case is not user friendly.

For a full list of methods and attributes of the request object, head over to the Request documentation.

File Uploads

You can handle uploaded ﬁles with Flask easily. Just make sure not to forget to set the enctype="multipart/

form-data" attribute on your HTML form, otherwise the browser will not transmit your ﬁles at all.

Uploaded ﬁles are stored in memory or at a temporary location on the ﬁlesystem. You can access those ﬁles by

looking at the files attribute on the request object. Each uploaded ﬁle is stored in that dictionary. It behaves just

like a standard Python file object, but it also has a save() method that allows you to store that ﬁle on the ﬁlesystem

of the server. Here is a simple example showing how that works:

from flask import request

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

def upload_file():

if request.method == 'POST':

f = request.files['the_file']

f.save('/var/www/uploads/uploaded_file.txt')

...

If you want to know how the ﬁle was named on the client before it was uploaded to your application, you can access

the filename attribute. However please keep in mind that this value can be forged so never ever trust that value. If

you want to use the ﬁlename of the client to store the ﬁle on the server, pass it through the secure_filename()

function that Werkzeug provides for you:

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['the_file']

f.save('/var/www/uploads/' + secure_filename(f.filename))

...

For some better examples, checkout the Uploading Files pattern.

To access cookies you can use the cookies attribute. To set cookies you can use the set_cookie method of

response objects. The cookies attribute of request objects is a dictionary with all the cookies the client transmits. If

you want to use sessions, do not use the cookies directly but instead use the Sessions in Flask that add some security

on top of cookies for you.

Reading cookies:

16 Chapter 1. User’s Guide

剩余292页未读，继续阅读

迫水

粉丝: 1
资源: 1

Flask 1.1.x官方文档：快速入门与高级特性详解

flask-palletsprojects-com-en-1.1.x.pdf

flask-3.0.2-py3-none-any.whl

使用 Flask3.x就需要使用 Flask-SQLAlchemy的3.x

如果使用 Flask3.x就需要使用 Flask-SQLAlchemy的3.x 并且还要使用最新的语法

Flask-Login Flask-Security 登录与权限控制

flask2.0.3 和Flask-SQLAlchemy2.5.1 不兼容吗

安装flask-wtf

flask-apscheduler安装方法

flask-cache如何使用

Unable to create process using '"D:\python.exe" "D:\Scripts\pip.exe" install flask-bootstrap': ???????????

最新资源