Flask开发系列之快速入门

文档

• 一个最小的应用
• 调试模式
• 路由
  • 变量规则
  • 构造 URL
  • HTTP 方法
• 静态文件
• 模板渲染
• 访问请求数据
  • 环境局部变量
  • 请求对象
  • 文件上传
  • Cookies
• 重定向和错误
• 关于响应
• 会话
• 消息闪现
• 日志记录
• 整合 WSGI 中间件
• 部署到 Web 服务器

一个最小的应用

from flask import Flask

app = Flask(__name__)

@app.route('/')

def index():

    return '<h1>Hello World!</h1>'

if __name__ == '__main__':

    app.run(host='127.0.0.1',port=8080,debug=True)

分析

导入模块

from flask import Flask

所有Flask程序都需要进行创建一个实例。Web服务器会使用WSGI协议，将接受到的客户端请求转交给这个对象处理，可以理解为代码中的app

第2行：Flask需要一个参数，这个参数通常是主模块或是包的名字。所以通常会传入 __name__

app = Flask(__name__)

第3行：

MVC理念

M：Model ==> 数据库模型

V：Views ==> 可以理解为定义网页的地址，以及渲染网页等

C：Controller ==> 可以理解为 网页功能的逻辑，实现

这里就是其中V，就是路由。这里的代码的目的就是为我们来指定一个路由，也就是页面的地址。

@app.route('/')

第4-5行: 使用app.route()装饰器会将URL和执行的视图函数(函数 index )的关系保存在app.url_map属性上。当你访问指定的URL时，就会调用这个函数。当遇到第一个return时，就会结束。其中的return就是你的response

def index():

    return '<h1>Hello World!</h1>'

第6-7行： 执行app.run来启动服务器。默认的Flask会监听的地址是127.0.0.1:5000。我们指定host和port参数，就修改了监听地址。 服务启动后，会先判断参数host以及port是否为None，如果为None，就会将host和port修改为默认值。然后会判断debug。然后就会调用werkzeug.serving.run_simple来启动Web服务，默认会使用单进程的werkzeug.serving_BaseWSGIServer来处理客户端的请求。

注意：1.这里的Werkzeug其实就是WSGI的实现和应用，从中可以发现，Flask是基于Werkzeug开发的。你或许可以去查查Werkzeug的文档，来自己实现一个Web服务框架

　　　2.关闭服务器：Ctrl+C

if __name__ == '__main__':

    app.run(host='127.0.0.1',port=8080,debug=True)

外部可访问的服务器：

如果你运行了这个服务器，你会发现它只能从你自己的计算机*问，网络中其它任何的地方都不能访问。在调试模式下，用户可以在你的计算机上执行任意 Python 代码。因此，这个行为是默认的。

如果你禁用了 debug 或信任你所在网络的用户，你可以简单修改调用 run() 的方法使你的服务器公开可用，如下:

app.run(host='0.0.0.0')

这会让操作系统监听所有公网 IP。

调试模式

虽然 run() 方法适用于启动本地的开发服务器，但是你每次修改代码后都要手动重启它。这样并不够优雅，而且 Flask 可以做到更好。如果你启用了调试支持，服务器会在代码修改后自动重新载入，并在发生错误时提供一个相当有用的调试器。

有两种途径来启用调试模式。一种是直接在应用对象上设置:

app.debug = True

app.run()

另一种是作为 run 方法的一个参数传入:

app.run(debug=True)

两种方法的效果完全相同。

@app.route('/')

def index():

    return 'Index Page'

@app.route('/hello')

def hello():

    return 'Hello World'

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

def show_user_profile(username):

    # show the user profile for that user

    return 'User %s' % username

@app.route('/post/<int:post_id>')

def show_post(post_id):

    # show the post with the given id, the id is an integer

    return 'Post %d' % post_id

@app.route('/projects/')

def projects():

    return 'The project page'

@app.route('/about')

def about():

    return 'The about page'

构造 URL

如果 Flask 能匹配 URL，那么 Flask 可以生成它们吗？当然可以。你可以用 url_for()来给指定的函数构造 URL。它接受函数名作为第一个参数，也接受对应 URL 规则的变量部分的命名参数。未知变量部分会添加到 URL 末尾作为查询参数。这里有一些例子:

>>> from flask import Flask, url_for

>>> app = Flask(__name__)

>>> @app.route('/')

... def index(): pass

...

>>> @app.route('/login')

... def login(): pass

...

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

... def profile(username): pass

...

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

（这里也用到了 test_request_context() 方法，下面会解释。即使我们正在通过 Python 的 shell 进行交互，它依然会告诉 Flask 要表现为正在处理一个请求。请看下面的解释。 环境局部变量 ）

为什么你要构建 URL 而非在模板中硬编码？这里有三个绝妙的理由：

1. 反向构建通常比硬编码的描述性更好。更重要的是，它允许你一次性修改 URL， 而不是到处边找边改。
2. URL 构建会转义特殊字符和 Unicode 数据，免去你很多麻烦。
3. 如果你的应用不位于 URL 的根路径（比如，在 /myapplication 下，而不是 / ）， url_for() 会妥善处理这个问题。

HTTP 方法

HTTP （与 Web 应用会话的协议）有许多不同的访问 URL 方法。默认情况下，路由只回应 GET 请求，但是通过 route() 装饰器传递 methods 参数可以改变这个行为。这里有一些例子:

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

def login():

    if request.method == 'POST':

        do_the_login()

    else:

        show_the_login_form()

如果存在 GET ，那么也会替你自动地添加 HEAD，无需干预。它会确保遵照 HTTP RFC（描述 HTTP 协议的文档）处理 HEAD 请求，所以你可以完全忽略这部分的 HTTP 规范。同样，自从 Flask 0.6 起， 也实现了 OPTIONS 的自动处理。

你不知道一个 HTTP 方法是什么？不必担心，这里会简要介绍 HTTP 方法和它们为什么重要：

HTTP 方法（也经常被叫做“谓词”）告知服务器，客户端想对请求的页面 做 些什么。下面的都是非常常见的方法：

GET

浏览器告知服务器：只 获取 页面上的信息并发给我。这是最常用的方法。

HEAD

浏览器告诉服务器：欲获取信息，但是只关心 消息头 。应用应像处理 GET 请求一样来处理它，但是不分发实际内容。在 Flask 中你完全无需 人工 干预，底层的 Werkzeug 库已经替你打点好了。

POST

浏览器告诉服务器：想在 URL 上 发布 新信息。并且，服务器必须确保 数据已存储且仅存储一次。这是 HTML 表单通常发送数据到服务器的方法。

PUT

类似 POST 但是服务器可能触发了存储过程多次，多次覆盖掉旧值。你可 能会问这有什么用，当然这是有原因的。考虑到传输中连接可能会丢失，在 这种 情况下浏览器和服务器之间的系统可能安全地第二次接收请求，而 不破坏其它东西。因为 POST 它只触发一次，所以用 POST 是不可能的。

DELETE

删除给定位置的信息。

OPTIONS

给客户端提供一个敏捷的途径来弄清这个 URL 支持哪些 HTTP 方法。 从 Flask 0.6 开始，实现了自动处理。

有趣的是，在 HTML4 和 XHTML1 中，表单只能以 GET 和 POST 方法提交到服务器。但是 JavaScript 和未来的 HTML 标准允许你使用其它所有的方法。此外，HTTP 最近变得相当流行，浏览器不再是唯一的 HTTP 客户端。比如，许多版本控制系统就在使用 HTTP。

静态文件

动态 web 应用也会需要静态文件，通常是 CSS 和 JavaScript 文件。理想状况下， 你已经配置好 Web 服务器来提供静态文件，但是在开发中，Flask 也可以做到。 只要在你的包中或是模块的所在目录中创建一个名为 static 的文件夹，在应用中使用 /static 即可访问。

给静态文件生成 URL ，使用特殊的 'static' 端点名:

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

这个文件应该存储在文件系统上的 static/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_flashed_messages() 函数。

模板继承让模板用起来相当顺手。如欲了解继承的工作机理，请跳转到 模板继承 模式的文档。最起码，模板继承能使特定元素 （比如页眉、导航栏和页脚）可以出现在所有的页面。

自动转义功能默认是开启的，所以如果 name 包含 HTML ，它将会被自动转义。如果你能信任一个变量，并且你知道它是安全的（例如一个模块把 Wiki 标记转换为 HTML），你可以用 Markup 类或 |safe 过滤器在模板中把它标记为安全的。在 Jinja 2 文档中，你会看到更多的例子。

这里是一个 Markup 类如何使用的简单介绍:

>>> from flask import Markup

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

Markup(u'<strong>Hello &lt;blink&gt;hacker&lt;/blink&gt;!</strong>')

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

Markup(u'&lt;blink&gt;hacker&lt;/blink&gt;')

>>> Markup('<em>Marked up</em> &raquo; HTML').striptags()

u'Marked up \xbb HTML'

访问请求数据

对于 Web 应用，与客户端发送给服务器的数据交互至关重要。在 Flask 中由全局的 request 对象来提供这些信息。如果你有一定的 Python 经验，你会好奇，为什么这个对象是全局的，为什么 Flask 还能保证线程安全。答案是环境作用域：

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'

from flask import request

with app.request_context(environ):

    assert request.method == 'POST'

from flask import request

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

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

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

    ...

from flask import request

from werkzeug 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))

    ...

from flask import request

@app.route('/')

def index():

    username = request.cookies.get('username')

    # use cookies.get(key) instead of cookies[key] to not get a

    # KeyError if the cookie is missing.

from flask import make_response

@app.route('/')

def index():

    resp = make_response(render_template(...))

    resp.set_cookie('username', 'the username')

    return resp

重定向和错误

你可以用 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()

这是一个相当无意义的例子因为用户会从主页重定向到一个不能访问的页面 （401 意味着禁止访问），但是它展示了重定向是如何工作的。

默认情况下，错误代码会显示一个黑白的错误页面。如果你要定制错误页面， 可以使用 errorhandler() 装饰器:

from flask import render_template

@app.errorhandler(404)

def page_not_found(error):

    return render_template('page_not_found.html'), 404

注意 render_template() 调用之后的 404 。这告诉 Flask，该页的错误代码是 404 ，即没有找到。默认为 200，也就是一切正常。

关于响应

视图函数的返回值会被自动转换为一个响应对象。如果返回值是一个字符串， 它被转换为该字符串为主体的、状态码为 200 OK``的 、 MIME 类型是 ``text/html 的响应对象。Flask 把返回值转换为响应对象的逻辑是这样：

1. 如果返回的是一个合法的响应对象，它会从视图直接返回。
2. 如果返回的是一个字符串，响应对象会用字符串数据和默认参数创建。
3. 如果返回的是一个元组，且元组中的元素可以提供额外的信息。这样的元组必须是 (response, status, headers) 的形式，且至少包含一个元素。 status 值会覆盖状态代码， headers 可以是一个列表或字典，作为额外的消息标头值。
4. 如果上述条件均不满足， 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

from flask import Flask, session, redirect, url_for, escape, request

app = Flask(__name__)

@app.route('/')

def index():

    if 'username' in session:

        return 'Logged in as %s' % escape(session['username'])

    return 'You are not logged in'

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

def login():

    if request.method == 'POST':

        session['username'] = request.form['username']

        return redirect(url_for('index'))

    return '''

        <form action="" method="post">

            <p><input type=text name=username>

            <p><input type=submit value=Login>

        </form>

    '''

@app.route('/logout')

def logout():

    # remove the username from the session if it's there

    session.pop('username', None)

    return redirect(url_for('index'))

# set the secret key.  keep this really secret:

app.secret_key = 'A0Zr98j/3yX R~XHH!jmN]LWX/,?RT'

>>> import os

>>> os.urandom(24)

'\xfd{H\xe5<\x95\xf9\xe3\x96.5\xd1\x01O<!\xd5\xa2\xa0\x9fR"\xa1\xa8'

app.logger.debug('A value for debugging')

app.logger.warning('A warning occurred (%d apples)', 42)

app.logger.error('An error occurred')

from werkzeug.contrib.fixers import LighttpdCGIRootFix

app.wsgi_app = LighttpdCGIRootFix(app.wsgi_app)