flask成长记（一）增强版

flask成长记（一）增强版

所有 Flask 程序都必须创建一个程序实例。 Web 服务器使用一种名为 Web 服务器网关接口
（ Web Server Gateway Interface， WSGI）的协议，把接收自客户端的所有请求都转交给这
个对象处理。程序实例是 Flask 类的对象，经常使用下述代码创建：

from flask import Flask
app = Flask(__name__)

Flask 类的构造函数只有一个必须指定的参数，即程序主模块或包的名字。在大多数程序
中， Python 的 name 变量就是所需的值。

路由和视图函数

客户端（例如 Web 浏览器）把请求发送给 Web 服务器， Web 服务器再把请求发送给
程序实例。程序实例需要知道对每个 URL 请求运行哪些代码，所以保存了一个 URL 到
Python 函数的映射关系。处理 URL 和函数之间关系的程序称为路由。

在 Flask 程序中定义路由的最简便方式，是使用程序实例提供的 app.route 修饰器，把修
饰的函数注册为路由。下面的例子说明了如何使用这个修饰器声明路由：

@app.route('/')
def index():
return '<h1>Hello World!</h1>'

这里把 index() 函数注册为程序根地址的处理程序。

这个函数的返回值称为响应，是客户端接收到的内容。

什么是修饰器呢？

修饰器是 Python 语言的标准特性，可以使用不同的方式修改函数的行为。惯
常用法是使用修饰器把函数注册为事件的处理程序。

像 index() 这样的函数称为视图函数（ view function）。
视图函数返回的响应可以是包含HTML 的简单字符串，也可以是复杂的表单。

注意：在 Python 代码中嵌入响应字符串会导致代码难以维护，此处这么做只是为了
介绍响应的概念。

定义含有动态部分的路由

@app.route('/user/<name>')
def user(name):
    return '<h1>Hello, %s!</h1>' % name


尖括号中的内容就是动态部分，任何能匹配静态部分的 URL 都会映射到这个路由上。调
用视图函数时， Flask 会将动态部分作为参数传入函数。

路由中的动态部分默认使用字符串，不过也可使用类型定义。

例如，路由/user/<int:id>
只会匹配动态片段 id 为整数的 URL。 Flask 支持在路由中使用 int、 float 和 path 类型。
path 类型也是字符串，但不把斜线视作分隔符，而将其当作动态片段的一部分。

启动服务器

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


__name__=='__main__' 是 Python 的惯常用法，在这里确保直接执行这个脚本时才启动开发
Web 服务器。 如果这个脚本由其他脚本引入，程序假定父级脚本会启动不同的服务器，因
此不会执行 app.run()。

启动之后，就会进入轮询。

里面的debug==True是个什么情况？

有一些选项参数可被 app.run() 函数接受用于设置 Web 服务器的操作模式。在开发过程中
启用调试模式会带来一些便利， 比如说激活调试器和重载程序。要想启用调试模式， 我们
可以把 debug 参数设为 True。

其实蜗牛没用过这样的debug模式。

完整的程序

来来来我们看一个完整的能运行的程序。

from flask import Flask, render_template
app = Flask(__name__)
# ...
@app.route('/')
def index():
    return '<h1>Hello World!</h1>'
@app.route('/user/<name>')
def user(name):
    return '<h1>Hello, %s!</h1>' % name

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

现在你已经开发了一个简单的 Flask 程序，或许希望进一步了解 Flask 的工作方式。下面将介绍这个框架的一些设计理念。

程序和请求上下文

Flask 从客户端收到请求时，要让视图函数能访问一些对象，这样才能处理请求。 请求对
象就是一个很好的例子，它封装了客户端发送的 HTTP 请求。

要想让视图函数能够访问请求对象， 一个显而易见的方式是将其作为参数传入视图函数，
不过这会导致程序中的每个视图函数都增加一个参数。 除了访问请求对象，如果视图函数
在处理请求时还要访问其他对象，情况会变得更糟。

为了避免大量可有可无的参数把视图函数弄得一团糟， Flask 使用上下文临时把某些对象
变为全局可访问。有了上下文，就可以写出下面的视图函数：

from flask import request

@app.route('/')
def index():
    user_agent = request.headers.get('User-Agent')
    return '<p>Your browser is %s</p>' % user_agent

然后我美丽的控制台就打印出了这样的东西：

Your browser is Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/50.0.2661.102 Safari/537.36

看不懂吧？蜗牛也看不懂，摩斯拉（浏览器名），64位，chrome内核？
差不多。刚百度了一下：
360极速浏览器主要是使用了Chrome和IE双内核，并能自由切换，比较快。

注意：
在这个视图函数中我们如何把 request 当作全局变量使用。事实上， request 不可能是
全局变量。试想，在多线程服务器中，多个线程同时处理不同客户端发送的不同请求时，
每个线程看到的 request 对象必然不同。 Falsk 使用上下文让特定的变量在一个线程中全局
可访问，与此同时却不会干扰其他线程。

在 Flask 中有两种上下文： 程序上下文和请求上下文。表 2-1 列出了这两种上下文提供的
变量。

urrent_app 程序上下文 当前激活程序的程序实例
g 程序上下文 处理请求时用作临时存储的对象。每次请求都会重设这个变量
request 请求上下文 请求对象，封装了客户端发出的 HTTP 请求中的内容
session 请求上下文 用户会话，用于存储请求之间需要“记住”的值的词典

你也许会问这些个对象是什么时候起作用的呢？

客官别急。

Flask 在分发请求之前激活（或推送）程序和请求上下文，请求处理完成后再将其删除。

程序上下文被推送后， 就可以在线程中使用 current_app 和 g 变量。类似地，请求上下文被推送后，就可以使用 request 和 session 变量。

>>> from hello import app
>>> from flask import current_app
>>> current_app.name
>Traceback (most recent call last):
...
RuntimeError: working outside of application context
>>> app_ctx = app.app_context()
>>> app_ctx.push()
>>> current_app.name
'hello'
>>> app_ctx.pop()
在这个例子中，没激活程序上下文之前就调用 current_app.name 会导致错误，但推送完上
下文之后就可以调用了。 注意，在程序实例上调用 app.app_context() 可获得一个程序上
下文。

请求调度

程序收到客户端发来的请求时，要找到处理该请求的视图函数。为了完成这个任务， Flask
会在程序的 URL 映射中查找请求的 URL。 URL 映射是 URL 和视图函数之间的对应关系。
Flask 使用 app.route 修饰器或者非修饰器形式的 app.add_url_rule() 生成映射。

查看你的app程序中的URL映射

>>> from hello import app
>>> app.url_map
Map([<Rule '/' (HEAD, OPTIONS, GET) -> index>,
<Rule '/static/<filename>' (HEAD, OPTIONS, GET) -> static>,
<Rule '/user/<name>' (HEAD, OPTIONS, GET) -> user>])

其实看的也挺明白，/根目录对应到index函数了么，
之后一个/user/<name>也是自己定义的，
只是中间有一个/static目录是静态文件的目录。

/static/<filename> 路由是Flask 添加的特殊路由，用于访问静态文件。
这个文件夹static在哪里呢？
你的可执行的py文件在哪里，这个文件夹就在哪里。

URL 映射中的 HEAD、 Options、 GET 是请求方法，由路由进行处理。 
Flask 为每个路由都指
定了请求方法， 这样不同的请求方法发送到相同的 URL 上时，会使用不同的视图函数进
行处理。 

HEAD 和 OPTIONS 方法由 Flask 自动处理，因此可以这么说，在这个程序中， URL
映射中的 3 个路由都使用 GET 方法。

请求钩子

有时在处理请求之前或之后执行代码会很有用。例如，在请求开始时，我们可能需要创
建数据库连接或者认证发起请求的用户。

为了避免在每个视图函数中都使用重复的代码，
Flask 提供了注册通用函数的功能， 注册的函数可在请求被分发到视图函数之前或之后
调用。

也就是url被分发的时候调用这些函数。

请求钩子使用修饰器实现。 Flask 支持以下 4 种钩子。

• before_first_request：注册一个函数，在处理第一个请求之前运行。
• before_request：注册一个函数，在每次请求之前运行。
• after_request：注册一个函数，如果没有未处理的异常抛出，在每次请求之后运行。
• teardown_request：注册一个函数，即使有未处理的异常抛出，也在每次请求之后运行。

但是这个钩子是怎么实现的？

在请求钩子函数和视图函数之间共享数据一般使用上下文全局变量 g。例如， before_
request 处理程序可以从数据库中加载已登录用户，并将其保存到 g.user 中。随后调用视
图函数时，视图函数再使用 g.user 获取用户。

请求钩子是在请求发到视图函数之前完成的。
钩子后边会有介绍。

响应

flask的视图函数执行过后，会将其返回值作为响应的内容。
大多数情况下，相应就是一个简单的字符串。作为HTML页面送回客户端。

但 HTTP 协议需要的不仅是作为请求响应的字符串。 HTTP 响应中一个很重要的部分是状
态码， Flask 默认设为 200，这个代码表明请求已经被成功处理。

如果视图函数返回的响应需要使用不同的状态码， 那么可以把数字代码作为第二个返回
值，添加到响应文本之后。例如，下述视图函数返回一个 400 状态码，表示请求无效：

@app.route('/')
def index():
    return '<h1>Bad Request</h1>', 400

视图函数返回的响应还可接受第三个参数，虽然一般不用。

如果不想返回由 1 个、 2 个或 3 个值组成的元组， Flask 视图函数还可以返回 Response 对
象。 make_response() 函数可接受 1 个、 2 个或 3 个参数（和视图函数的返回值一样），并
返回一个 Response 对象。有时我们需要在视图函数中进行这种转换，然后在响应对象上调
用各种方法，进一步设置响应。下例创建了一个响应对象，然后设置了 cookie：

from flask import make_response
@app.route('/')
def index():
    response = make_response('<h1>This document carries a cookie!</h1>')
    response.set_cookie('answer', '42')
    return response

注意这里，上面的那个response里面的内容是可以显示的。不过cookie怎么用？
蜗牛也不知道，蜗牛也很绝望啊。我猜这种东西可以发送到手机上面？

重定向

有一种名为重定向的特殊响应类型。 这种响应没有页面文档，只告诉浏览器一个新地址用
以加载新页面。

重定向经常使用 302 状态码表示，指向的地址由 Location 首部提供。

重定向响应可以使用3 个值形式的返回值生成， 也可在 Response 对象中设定。
不过，由于使用频繁， Flask 提供了 redirect() 辅助函数，用于生成这种响应：

注意这个函数是生成响应的。

from flask import redirect
#上边真的是体现了flask的一个特点啊……真的是啥都要import啊。
@app.route('/')
def index():
    return redirect('http://www.example.com')

要找上面说的其实你直接把"http://www.example.com"返回回去其实是样的。

处理错误的函数

还有一种特殊的响应由 abort 函数生成，用于处理错误。
举个栗子：

from flask import abort
@app.route('/user/<id>')
def get_user(id):
    user = load_user(id)
    if not user:
        abort(404)
    return '<h1>Hello, %s</h1>' % user.name

Flask扩展

flask的一个很大的特点及时被设计为可扩展对的形式，故而没有设计一些重要的功能。
这一个特点，说好也好，说不好也好，可以自己选择合适的包自己去导进去。

社区成员开发了大量不同用途的扩展，如果这还不能满足需求， 你还可使用所有 Python 标
准包或代码库。 为了让你知道如何把扩展整合到程序中，接下来我们将在 hello.py 中添加
一个扩展，使用命令行参数增强程序的功能。