Flask 1.1.x 用户指南与API详解

需积分: 9 53 浏览量更新于2024-07-16 收藏 1.25MB PDF 举报

Flask-PalletsProjects-Com-EN-1.1.x文档是关于Python轻量级Web应用框架Flask的全面指南，适用于初学者和经验丰富的程序员。该版本发布于2020年4月4日，涵盖了从安装、快速入门到高级主题的详细内容。 1. **用户手册**：文档首先提供了用户指南，包括一个简短的前言，解释了Flask作为现代Web开发的基础，强调其简洁易用的特点。对于新手，有安装步骤，帮助用户在不同环境（如Python 3）下配置和启动项目。 2. **快速入门**：这部分指导读者如何快速创建一个简单的应用程序，通过实际示例展示Flask的基本概念，如路由、视图函数、模板渲染等。 3. **教程**：详尽的教程部分深入讲解如何构建一个功能完整的应用，涉及模板引擎Jinja2的使用、数据处理、表单处理等核心技能。 4. **模板系统**：介绍Flask如何与Jinja2配合，以及如何设计和定制模板，以便优雅地呈现动态内容。 5. **测试和错误处理**：文档介绍了如何编写单元测试和集成测试，以及处理和调试应用程序中的错误，确保代码质量和用户体验。 6. **配置和信号系统**：讲解如何管理应用配置，以及如何利用Flask的信号系统进行事件驱动编程。 7. **插件与扩展**：讨论如何使用Flask扩展来增强功能，如数据库操作、身份验证、缓存等，以及开发自己的扩展的方法。 8. **命令行工具**：介绍了Flask的命令行工具，如用于开发服务器、Shell环境以及部署选项的实用命令。 9. **部署和成长**：针对不同阶段的项目，讨论了从本地开发到部署的选项，以及应对应用规模增长时的最佳实践。 10. **API参考**：最后，提供了一个详细的API参考，方便开发者查找和理解Flask及其依赖库——Werkzeug的各个组件的功能和使用方法。 11. **附加笔记**：这部分包括设计决策、常见问题解答、安全注意事项、Unicode支持、扩展开发规范，以及如何升级到新版本和贡献指南，为高级用户和贡献者提供了深入理解和参与项目的更多资源。 Flask-PalletsProjects-Com-EN-1.1.x文档是一本非常实用的资源，无论你是初次接触Flask还是希望深入学习和优化已有的Flask项目，都能从中找到所需的知识点。

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页未读，继续阅读

fklk

粉丝: 55
资源: 3

Flask 1.1.x 用户指南与API详解

financeager_flask-*.*.*.*-py3-none-any.whl - Python后端开发库

Flask-MetaRoute 1.1：Python后端开发库新版本发布

掌握Flask开发：使用flask-restplus-marshmallow-0.2.1.tar.gz

flask-palletsprojects-com-en-1.1.x.pdf Flask 官方文档

FlaskDocs-Tutorial：基于https：flask.palletsprojects.comen1.1.xtutorial＃tutorial用Flask编写的Flask Web应用程序

Building-Web-Applications-with-Flask-Use-Python-and-Flask-to-build-amazing-web-applications-just-the-way-you-want-them-. ....pdf

Python库 | Flask-MetaRoute-1.1.tar.gz

Python库 | odinweb.flask-0.5.2-py2.py3-none-any.whl

最新资源

financeager_flask-...-py3-none-any.whl - Python后端开发库