Python Flask Web 框架入門

Flask是一個輕量級的基於Python的web框架。

1. 簡介

這份文檔中的代碼使用 Python 3 運行。
是的，所以讀者需要自己在電腦上安裝Python 3 和 pip3。建議安裝最新版本，我使用的是Python 3.6.4。
安裝方法，可以自行谷歌或者百度。
建議在 linux 下實踐本教程中命令行操作、執行代碼。

2. 安裝

通過pip3安裝Flask即可：

$ sudo pip3 install Flask

進入python交互模式看下Flask的介紹和版本：

$ python3
>>> import flask
>>> print(flask.__doc__)
flask
~~~~~
A microframework based on Werkzeug. It's extensively documented
and follows best practice patterns.
:copyright: 2010 by the Pallets team.
:license: BSD, see LICENSE for more details.
>>> print(flask.__version__)
1.0.2

3. 從 Hello World 開始

本節主要內容：使用Flask寫一個顯示”Hello World!”的web程序，如何配置、調試Flask。

3.1 Hello World

按照以下命令建立Flask項目HelloWorld:

mkdir HelloWorld
mkdir HelloWorld/static
mkdir HelloWorld/templates
touch HelloWorld/server.py

static和templates目錄是默認配置，其中static用來存放靜態資源，例如圖片、js、css文件等。templates存放模板文件。
我們的網站邏輯基本在server.py文件中，當然，也可以給這個文件起其他的名字。

在server.py中加入以下內容：

from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello_world():
return 'Hello World!'
if __name__ == '__main__':
app.run()

運行server.py：

$ python3 server.py
* Running on http://127.0.0.1:5000/

打開浏覽器訪問http://127.0.0.1:5000/，浏覽頁面上將出現Hello World!。
終端裡會顯示下面的信息：

127.0.0.1 - - [16/May/2014 10:29:08] "GET / HTTP/1.1" 200 -

變量app是一個Flask實例，通過下面的方式：

@app.route('/')
def hello_world():
return 'Hello World!'

當客戶端訪問/時，將響應hello_world()函數返回的內容。注意，這不是返回Hello World!這麼簡單，Hello World!只是HTTP響應報文的實體部分，狀態碼等信息既可以由Flask自動處理，也可以通過編程來制定。

3.2 修改Flask的配置

app = Flask(__name__)

上面的代碼中，python內置變量__name__的值是字符串__main__ 。Flask類將這個參數作為程序名稱。當然這個是可以自定義的，比如app = Flask("my-app")。

Flask默認使用static目錄存放靜態資源，templates目錄存放模板，這是可以通過設置參數更改的：

app = Flask("my-app", static_folder="path1", template_folder="path2")

更多參數請參考__doc__：

from flask import Flask
print(Flask.__doc__)

3.3 調試模式

上面的server.py中以app.run()方式運行，這種方式下，如果服務器端出現錯誤是不會在客戶端顯示的。但是在開發環境中，顯示錯誤信息是很有必要的，要顯示錯誤信息，應該以下面的方式運行Flask：

app.run(debug=True)

將debug設置為True的另一個好處是，程序啟動後，會自動檢測源碼是否發生變化，若有變化則自動重啟程序。這可以幫我們省下很多時間。

3.4 綁定IP和端口

默認情況下，Flask綁定IP為127.0.0.1，端口為5000。我們也可以通過下面的方式自定義：

app.run(host='0.0.0.0', port=80, debug=True)

0.0.0.0代表電腦所有的IP。80是HTTP網站服務的默認端口。什麼是默認？比如，我們訪問網站http://www.example.com，其實是訪問的http://www.example.com:80，只不過:80可以省略不寫。

由於綁定了80端口，需要使用root權限運行server.py。也就是：

$ sudo python3 server.py

4. 獲取 URL 參數

URL參數是出現在url中的鍵值對，例如http://127.0.0.1:5000/?disp=3中的url參數是{'disp':3}。

4.1 建立Flask項目

按照以下命令建立Flask項目HelloWorld:

mkdir HelloWorld
mkdir HelloWorld/static
mkdir HelloWorld/templates
touch HelloWorld/server.py

4.2 列出所有的url參數

在server.py中添加以下內容：

from flask import Flask, request
app = Flask(__name__)
@app.route('/')
def hello_world():
return request.args.__str__()
if __name__ == '__main__':
app.run(port=5000, debug=True)

在浏覽器中訪問http://127.0.0.1:5000/?user=Flask&time&p=7&p=8，將顯示：

ImmutableMultiDict([('user', 'Flask'), ('time', ''), ('p', '7'), ('p', '8')])

較新的浏覽器也支持直接在url中輸入中文（最新的火狐浏覽器內部會幫忙將中文轉換成符合URL規范的數據），在浏覽器中訪問http://127.0.0.1:5000/?info=這是愛，，將顯示：

ImmutableMultiDict([('info', '這是愛，')])

浏覽器傳給我們的Flask服務的數據長什麼樣子呢？可以通過request.full_path和request.path來看一下：

from flask import Flask, request
app = Flask(__name__)
@app.route('/')
def hello_world():
print(request.path)
print(request.full_path)
return request.args.__str__()
if __name__ == '__main__':
app.run(port=5000, debug=True)

浏覽器訪問http://127.0.0.1:5000/?info=這是愛，，運行server.py的終端會輸出：

//?info=%E8%BF%99%E6%98%AF%E7%88%B1%EF%BC%8C

4.3 獲取某個指定的參數

例如，要獲取鍵info對應的值，如下修改server.py：

from flask import Flask, request
app = Flask(__name__)
@app.route('/')
def hello_world():
return request.args.get('info')
if __name__ == '__main__':
app.run(port=5000)

運行server.py，在浏覽器中訪問http://127.0.0.1:5000/?info=hello，浏覽器將顯示：

hello

不過，當我們訪問http://127.0.0.1:5000/時候卻出現了500錯誤，浏覽器顯示：

如果開啟了Debug模式，會顯示：

為什麼為這樣？

這是因為沒有在URL參數中找到info。所以request.args.get('info')返回Python內置的None，而Flask不允許返回None。

解決方法很簡單，我們先判斷下它是不是None：

from flask import Flask, request
app = Flask(__name__)
@app.route('/')
def hello_world():
r = request.args.get('info')
if r==None:
# do something
return ''
return r
if __name__ == '__main__':
app.run(port=5000, debug=True)

另外一個方法是，設置默認值，也就是取不到數據時用這個值：

from flask import Flask, request
app = Flask(__name__)
@app.route('/')
def hello_world():
r = request.args.get('info', 'hi')
return r
if __name__ == '__main__':
app.run(port=5000, debug=True)

函數request.args.get的第二個參數用來設置默認值。此時在浏覽器訪問http://127.0.0.1:5000/，將顯示：

hi

4.4 如何處理多值

還記得上面有一次請求是這樣的嗎？ http://127.0.0.1:5000/?user=Flask&time&p=7&p=8，仔細看下，p有兩個值。

如果我們的代碼是：

from flask import Flask, request
app = Flask(__name__)
@app.route('/')
def hello_world():
r = request.args.get('p')
return r
if __name__ == '__main__':
app.run(port=5000, debug=True)

在浏覽器中請求時，我們只會看到7。如果我們需要把p的所有值都獲取到，該怎麼辦？

不用get，用getlist：

from flask import Flask, request
app = Flask(__name__)
@app.route('/')
def hello_world():
r = request.args.getlist('p') # 返回一個list
return str(r)
if __name__ == '__main__':
app.run(port=5000, debug=True)

浏覽器輸入 http://127.0.0.1:5000/?user=Flask&time&p=7&p=8，我們會看到['7', '8']。

5. 獲取POST方法傳送的數據

作為一種HTTP請求方法，POST用於向指定的資源提交要被處理的數據。我們在某網站注冊用戶、寫文章等時候，需要將數據傳遞到網站服務器中。並不適合將數據放到URL參數中，密碼放到URL參數中容易被看到，文章數據又太多，浏覽器不一定支持太長長度的URL。這時，一般使用POST方法。

本文使用python的requests庫模擬浏覽器。

安裝方法：

$ sudo pip3 install requests

5.1 建立Flask項目

按照以下命令建立Flask項目HelloWorld:

mkdir HelloWorld
mkdir HelloWorld/static
mkdir HelloWorld/templates
touch HelloWorld/server.py

5.2 查看POST數據內容

以用戶注冊為例子，我們需要向服務器/register傳送用戶名name和密碼password。如下編寫HelloWorld/server.py。

from flask import Flask, request
app = Flask(__name__)
@app.route('/')
def hello_world():
return 'hello world'
@app.route('/register', methods=['POST'])
def register():
print(request.headers)
print(request.stream.read())
return 'welcome'
if __name__ == '__main__':
app.run(port=5000, debug=True)

[`@app.route](mailto:`@app.route)(‘/register’, methods=[‘POST’])`是指url`/register`只接受POST方法。可以根據需要修改`methods`參數，例如如果想要讓它同時支持GET和POST，這樣寫：

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

浏覽器模擬工具client.py內容如下：

import requests
user_info = {
'name': 'letian', 'password': '123'}
r = requests.post("http://127.0.0.1:5000/register", data=user_info)
print(r.text)

運行HelloWorld/server.py，然後運行client.py。client.py將輸出：

welcome

而HelloWorld/server.py在終端中輸出以下調試信息（通過print輸出）：

Host: 127.0.0.1:5000
User-Agent: python-requests/2.19.1
Accept-Encoding: gzip, deflate
Accept: */*
Connection: keep-alive
Content-Length: 24
Content-Type: application/x-www-form-urlencoded
b'name=letian&password=123'

前6行是client.py生成的HTTP請求頭，由print(request.headers)輸出。

請求體的數據，我們通過print(request.stream.read())輸出，結果是：

b'name=letian&password=123'

5.3 解析POST數據

上面，我們看到post的數據內容是：

b'name=letian&password=123'

我們要想辦法把我們要的name、password提取出來，怎麼做呢？自己寫？不用，Flask已經內置了解析器request.form。

我們將服務代碼改成：

from flask import Flask, request
app = Flask(__name__)
@app.route('/')
def hello_world():
return 'hello world'
@app.route('/register', methods=['POST'])
def register():
print(request.headers)
# print(request.stream.read()) # 不要用，否則下面的form取不到數據
print(request.form)
print(request.form['name'])
print(request.form.get('name'))
print(request.form.getlist('name'))
print(request.form.get('nickname', default='little apple'))
return 'welcome'
if __name__ == '__main__':
app.run(port=5000, debug=True)

執行client.py請求數據，服務器代碼會在終端輸出：

Host: 127.0.0.1:5000
User-Agent: python-requests/2.19.1
Accept-Encoding: gzip, deflate
Accept: */*
Connection: keep-alive
Content-Length: 24
Content-Type: application/x-www-form-urlencoded
ImmutableMultiDict([('name', 'letian'), ('password', '123')])
letian
letian
['letian']
little apple

request.form會自動解析數據。

request.form['name']和request.form.get('name')都可以獲取name對應的值。對於request.form.get()可以為參數default指定值以作為默認值。所以：

print(request.form.get('nickname', default='little apple'))

輸出的是默認值

little apple

如果name有多個值，可以使用request.form.getlist('name')，該方法將返回一個列表。我們將client.py改一下：

import requests
user_info = {
'name': ['letian', 'letian2'], 'password': '123'}
r = requests.post("http://127.0.0.1:5000/register", data=user_info)
print(r.text)

此時運行client.py，print(request.form.getlist('name'))將輸出：

[u'letian', u'letian2']

6. 處理和響應JSON數據

使用 HTTP POST 方法傳到網站服務器的數據格式可以有很多種，比如「5. 獲取POST方法傳送的數據」講到的name=letian&password=123這種用過&符號分割的key-value鍵值對格式。我們也可以用JSON格式、XML格式。相比XML的重量、規范繁瑣，JSON顯得非常小巧和易用。

6.1 建立Flask項目

按照以下命令建立Flask項目HelloWorld:

mkdir HelloWorld
mkdir HelloWorld/static
mkdir HelloWorld/templates
touch HelloWorld/server.py

6.2 處理JSON格式的請求數據

如果POST的數據是JSON格式，request.json會自動將json數據轉換成Python類型（字典或者列表）。

編寫server.py:

from flask import Flask, request
app = Flask("my-app")
@app.route('/')
def hello_world():
return 'Hello World!'
@app.route('/add', methods=['POST'])
def add():
print(request.headers)
print(type(request.json))
print(request.json)
result = request.json['a'] + request.json['b']
return str(result)
if __name__ == '__main__':
app.run(host='127.0.0.1', port=5000, debug=True)

編寫client.py模擬浏覽器請求：

import requests
json_data = {
'a': 1, 'b': 2}
r = requests.post("http://127.0.0.1:5000/add", json=json_data)
print(r.text)

運行server.py，然後運行client.py，client.py 會在終端輸出：

3

server.py 會在終端輸出：

Host: 127.0.0.1:5000
User-Agent: python-requests/2.19.1
Accept-Encoding: gzip, deflate
Accept: */*
Connection: keep-alive
Content-Length: 16
Content-Type: application/json
<class 'dict'>
{
'a': 1, 'b': 2}

注意，請求頭中Content-Type的值是application/json。

6.3 響應JSON-方案1

響應JSON時，除了要把響應體改成JSON格式，響應頭的Content-Type也要設置為application/json。

編寫server2.py：

from flask import Flask, request, Response
import json
app = Flask("my-app")
@app.route('/')
def hello_world():
return 'Hello World!'
@app.route('/add', methods=['POST'])
def add():
result = {
'sum': request.json['a'] + request.json['b']}
return Response(json.dumps(result), mimetype='application/json')
if __name__ == '__main__':
app.run(host='127.0.0.1', port=5000, debug=True)

修改後運行。

編寫client2.py：

import requests
json_data = {
'a': 1, 'b': 2}
r = requests.post("http://127.0.0.1:5000/add", json=json_data)
print(r.headers)
print(r.text)

運行client.py，將顯示：

{
'Content-Type': 'application/json', 'Content-Length': '10', 'Server': 'Werkzeug/0.14.1 Python/3.6.4', 'Date': 'Sat, 07 Jul 2018 05:23:00 GMT'}
{
"sum": 3}

上面第一段內容是服務器的響應頭，第二段內容是響應體，也就是服務器返回的JSON格式數據。

另外，如果需要服務器的HTTP響應頭具有更好的可定制性，比如自定義Server，可以如下修改add()函數：

@app.route('/add', methods=['POST'])
def add():
result = {
'sum': request.json['a'] + request.json['b']}
resp = Response(json.dumps(result), mimetype='application/json')
resp.headers.add('Server', 'python flask')
return resp

client2.py運行後會輸出：

{
'Content-Type': 'application/json', 'Content-Length': '10', 'Server': 'python flask', 'Date': 'Sat, 07 Jul 2018 05:26:40 GMT'}
{
"sum": 3}

6.4 響應JSON-方案2

使用 jsonify 工具函數即可。

from flask import Flask, request, jsonify
app = Flask("my-app")
@app.route('/')
def hello_world():
return 'Hello World!'
@app.route('/add', methods=['POST'])
def add():
result = {
'sum': request.json['a'] + request.json['b']}
return jsonify(result)
if __name__ == '__main__':
app.run(host='127.0.0.1', port=5000, debug=True)

7. 上傳文件

上傳文件，一般也是用POST方法。

7.1 建立Flask項目

按照以下命令建立Flask項目HelloWorld:

mkdir HelloWorld
mkdir HelloWorld/static
mkdir HelloWorld/templates
touch HelloWorld/server.py

7.2 上傳文件

這一部分的代碼參考自How to upload a file to the server in Flask。

我們以上傳圖片為例：
假設將上傳的圖片只允許’png’、’jpg’、’jpeg’、’gif’這四種格式，通過url/upload使用POST上傳，上傳的圖片存放在服務器端的static/uploads目錄下。

首先在項目HelloWorld中創建目錄static/uploads：

mkdir HelloWorld/static/uploads

werkzeug庫可以判斷文件名是否安全，例如防止文件名是../../../a.png，安裝這個庫：

$ sudo pip3 install werkzeug

server.py代碼：

from flask import Flask, request
from werkzeug.utils import secure_filename
import os
app = Flask(__name__)
# 文件上傳目錄
app.config['UPLOAD_FOLDER'] = 'static/uploads/'
# 支持的文件格式
app.config['ALLOWED_EXTENSIONS'] = {
'png', 'jpg', 'jpeg', 'gif'} # 集合類型
# 判斷文件名是否是我們支持的格式
def allowed_file(filename):
return '.' in filename and \
filename.rsplit('.', 1)[1] in app.config['ALLOWED_EXTENSIONS']
@app.route('/')
def hello_world():
return 'hello world'
@app.route('/upload', methods=['POST'])
def upload():
upload_file = request.files['image']
if upload_file and allowed_file(upload_file.filename):
filename = secure_filename(upload_file.filename)
# 將文件保存到 static/uploads 目錄，文件名同上傳時使用的文件名
upload_file.save(os.path.join(app.root_path, app.config['UPLOAD_FOLDER'], filename))
return 'info is '+request.form.get('info', '')+'. success'
else:
return 'failed'
if __name__ == '__main__':
app.run(port=5000, debug=True)

app.config中的config是字典的子類，可以用來設置自有的配置信息，也可以設置自己的配置信息。函數allowed_file(filename)用來判斷filename是否有後綴以及後綴是否在app.config['ALLOWED_EXTENSIONS']中。

客戶端上傳的圖片必須以image01標識。upload_file是上傳文件對應的對象。app.root_path獲取server.py所在目錄在文件系統中的絕對路徑。upload_file.save(path)用來將upload_file保存在服務器的文件系統中，參數最好是絕對路徑，否則會報錯（網上很多代碼都是使用相對路徑，但是筆者在使用相對路徑時總是報錯，說找不到路徑）。函數os.path.join()用來將使用合適的路徑分隔符將路徑組合起來。

好了，定制客戶端client.py：

import requests
file_data = {
'image': open('Lenna.jpg', 'rb')}
user_info = {
'info': 'Lenna'}
r = requests.post("http://127.0.0.1:5000/upload", data=user_info, files=file_data)
print(r.text)

運行client.py，當前目錄下的Lenna.jpg將上傳到服務器。

然後，我們可以在static/uploads中看到文件Lenna.jpg。

要控制上產文件的大小，可以設置請求實體的大小，例如：

app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024 #16MB

不過，在處理上傳文件時候，需要使用try:...except:...。

如果要獲取上傳文件的內容可以：

file_content = request.files['image'].stream.read()

8. Restful URL

簡單來說，Restful URL可以看做是對 URL 參數的替代。

8.1 建立Flask項目

按照以下命令建立Flask項目HelloWorld:

mkdir HelloWorld
mkdir HelloWorld/static
mkdir HelloWorld/templates
touch HelloWorld/server.py

8.2 編寫代碼

編輯server.py：

from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello_world():
return 'hello world'
@app.route('/user/<username>')
def user(username):
print(username)
print(type(username))
return 'hello ' + username
@app.route('/user/<username>/friends')
def user_friends(username):
print(username)
print(type(username))
return 'hello ' + username
if __name__ == '__main__':
app.run(port=5000, debug=True)

運行HelloWorld/server.py。使用浏覽器訪問http://127.0.0.1:5000/user/letian，HelloWorld/server.py將輸出：

letian
<class 'str'>

而訪問http://127.0.0.1:5000/user/letian/，響應為404 Not Found。

浏覽器訪問http://127.0.0.1:5000/user/letian/friends，可以看到：

Hello letian. They are your friends.

HelloWorld/server.py輸出：

letian
<class 'str'>

8.3 轉換類型

由上面的示例可以看出，使用 Restful URL 得到的變量默認為str對象。如果我們需要通過分頁顯示查詢結果，那麼需要在url中有數字來指定頁數。按照上面方法，可以在獲取str類型頁數變量後，將其轉換為int類型。不過，還有更方便的方法，就是用flask內置的轉換機制，即在route中指定該如何轉換。

新的服務器代碼：

from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello_world():
return 'hello world'
@app.route('/page/<int:num>')
def page(num):
print(num)
print(type(num))
return 'hello world'
if __name__ == '__main__':
app.run(port=5000, debug=True)

[`@app.route](mailto:`@app.route)(‘/page/int:num‘)`會將num變量自動轉換成int類型。

運行上面的程序，在浏覽器中訪問http://127.0.0.1:5000/page/1，HelloWorld/server.py將輸出如下內容：

1
<class 'int'>

如果訪問的是http://127.0.0.1:5000/page/asd，我們會得到404響應。

在官方資料中，說是有3個默認的轉換器：

int accepts integers
float like int but for floating point values
path like the default but also accepts slashes

看起來夠用了。

8.4 一個有趣的用法

如下編寫服務器代碼：

from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello_world():
return 'hello world'
@app.route('/page/<int:num1>-<int:num2>')
def page(num1, num2):
print(num1)
print(num2)
return 'hello world'
if __name__ == '__main__':
app.run(port=5000, debug=True)

在浏覽器中訪問http://127.0.0.1:5000/page/11-22，HelloWorld/server.py會輸出：

11
22

8.5 編寫轉換器

自定義的轉換器是一個繼承werkzeug.routing.BaseConverter的類，修改to_python和to_url方法即可。to_python方法用於將url中的變量轉換後供被[`@app.route](mailto:`@app.route)`包裝的函數使用，`to_url`方法用於`flask.url_for`中的參數轉換。

下面是一個示例，將HelloWorld/server.py修改如下：

from flask import Flask, url_for
from werkzeug.routing import BaseConverter
class MyIntConverter(BaseConverter):
def __init__(self, url_map):
super(MyIntConverter, self).__init__(url_map)
def to_python(self, value):
return int(value)
def to_url(self, value):
return value * 2
app = Flask(__name__)
app.url_map.converters['my_int'] = MyIntConverter
@app.route('/')
def hello_world():
return 'hello world'
@app.route('/page/<my_int:num>')
def page(num):
print(num)
print(url_for('page', num=123)) # page 對應的是 page函數 ，num 對應對應`/page/<my_int:num>`中的num，必須是str
return 'hello world'
if __name__ == '__main__':
app.run(port=5000, debug=True)

浏覽器訪問http://127.0.0.1:5000/page/123後，HelloWorld/server.py的輸出信息是：

123/page/123123

8.7 值得讀

理解RESTful架構。

9. 使用url_for生成鏈接

工具函數url_for可以讓你以軟編碼的形式生成url，提供開發效率。

9.1 建立Flask項目

按照以下命令建立Flask項目HelloWorld:

mkdir HelloWorld
mkdir HelloWorld/static
mkdir HelloWorld/templates
touch HelloWorld/server.py

9.2 編寫代碼

編輯HelloWorld/server.py：

from flask import Flask, url_for
app = Flask(__name__)
@app.route('/')
def hello_world():
pass
@app.route('/user/<name>')
def user(name):
pass
@app.route('/page/<int:num>')
def page(num):
pass
@app.route('/test')
def test():
print(url_for('hello_world'))
print(url_for('user', name='letian'))
print(url_for('page', num=1, q='hadoop mapreduce 10%3'))
print(url_for('static', filename='uploads/01.jpg'))
return 'Hello'
if __name__ == '__main__':
app.run(debug=True)

運行HelloWorld/server.py。然後在浏覽器中訪問http://127.0.0.1:5000/test，HelloWorld/server.py將輸出以下信息：

/
/user/letian
/page/1?q=hadoop+mapreduce+10%253
/static/uploads/01.jpg

10. 使用redirect重定向網址

redirect函數用於重定向，實現機制很簡單，就是向客戶端（浏覽器）發送一個重定向的HTTP報文，浏覽器會去訪問報文中指定的url。

10.1 建立Flask項目

按照以下命令建立Flask項目HelloWorld:

mkdir HelloWorld
mkdir HelloWorld/static
mkdir HelloWorld/templates
touch HelloWorld/server.py

10.2 編寫代碼

使用redirect時，給它一個字符串類型的參數就行了。

編輯HelloWorld/server.py：

from flask import Flask, url_for, redirect
app = Flask(__name__)
@app.route('/')
def hello_world():
return 'hello world'
@app.route('/test1')
def test1():
print('this is test1')
return redirect(url_for('test2'))
@app.route('/test2')
def test2():
print('this is test2')
return 'this is test2'
if __name__ == '__main__':
app.run(debug=True)

運行HelloWorld/server.py，在浏覽器中訪問http://127.0.0.1:5000/test1，浏覽器的url會變成http://127.0.0.1:5000/test2，並顯示：

this is test2

11. 使用Jinja2模板引擎

模板引擎負責MVC中的V（view，視圖）這一部分。Flask默認使用Jinja2模板引擎。

Flask與模板相關的函數有：

• flask.render_template(template_name_or_list, **context)
  Renders a template from the template folder with the given context.
• flask.render_template_string(source, **context)
  Renders a template from the given template source string with the given context.
• flask.get_template_attribute(template_name, attribute)
  Loads a macro (or variable) a template exports. This can be used to invoke a macro from within Python code.

這其中常用的就是前兩個函數。

這個實例中使用了模板繼承、if判斷、for循環。

11.1 建立Flask項目

按照以下命令建立Flask項目HelloWorld:

mkdir HelloWorld
mkdir HelloWorld/static
mkdir HelloWorld/templates
touch HelloWorld/server.py

11.2 創建並編輯HelloWorld/templates/default.html

內容如下：

<html>
<head>
<title>
{
% if page_title %}
{
{
 page_title }}
{
% endif %}
</title>
</head>
<body>
{
% block body %}{
% endblock %}

可以看到，在標簽中使用了if判斷，如果給模板傳遞了`page_title`變量，顯示之，否則，不顯示。 標簽中定義了一個名為body的block，用來被其他模板文件繼承。

11.3 創建並編輯HelloWorld/templates/user_info.html

內容如下：

{% extends "default.html" %}
{% block body %}
{% for key in user_info %}
{
{ key }}: {
{ user_info[key] }}
{% endfor %}
{% endblock %}

變量user_info應該是一個字典，for循環用來循環輸出鍵值對。

11.4 編輯HelloWorld/server.py

內容如下：

from flask import Flask, render_template
app = Flask(__name__)
@app.route('/')
def hello_world():
return 'hello world'
@app.route('/user')
def user():
user_info = {

'name': 'letian',
'email': '[email protected]',
'age':0,
'github': 'https://github.com/letiantian'
}
return render_template('user_info.html', page_title='letian\'s info', user_info=user_info)
if __name__ == '__main__':
app.run(port=5000, debug=True)

render_template()函數的第一個參數指定模板文件，後面的參數是要傳遞的數據。

11.5 運行與測試

運行HelloWorld/server.py：

$ python3 HelloWorld/server.py

在浏覽器中訪問http://127.0.0.1:5000/user，效果圖如下：

查看網頁源碼：

<html>
<head>
<title>
letian&#39;s info
</title>
</head>
<body>
name: letian <br/>
email: [email protected] <br/>
age: 0 <br/>
github: https://github.com/letiantian <br/>
</body>
</html>

12. 自定義404等錯誤的響應

要處理HTTP錯誤，可以使用flask.abort函數。

12.1 示例1：簡單入門

建立Flask項目

按照以下命令建立Flask項目HelloWorld:

mkdir HelloWorld
mkdir HelloWorld/static
mkdir HelloWorld/templates
touch HelloWorld/server.py

代碼

編輯HelloWorld/server.py：

from flask import Flask, render_template_string, abort
app = Flask(__name__)
@app.route('/')
def hello_world():
return 'hello world'
@app.route('/user')
def user():
abort(401) # Unauthorized 未授權
print('Unauthorized, 請先登錄')
if __name__ == '__main__':
app.run(port=5000, debug=True)

效果

運行HelloWorld/server.py，浏覽器訪問http://127.0.0.1:5000/user，效果如下：

要注意的是，HelloWorld/server.py中abort(401)後的print並沒有執行。

12.2 示例2：自定義錯誤頁面

代碼

將服務器代碼改為：

from flask import Flask, render_template_string, abort
app = Flask(__name__)
@app.route('/')
def hello_world():
return 'hello world'
@app.route('/user')
def user():
abort(401) # Unauthorized
@app.errorhandler(401)
def page_unauthorized(error):
return render_template_string('<h1> Unauthorized </h1><h2>{
{ error_info }}</h2>', error_info=error), 401
if __name__ == '__main__':
app.run(port=5000, debug=True)

page_unauthorized函數返回的是一個元組，401 代表HTTP 響應狀態碼。如果省略401，則響應狀態碼會變成默認的 200。

效果

運行HelloWorld/server.py，浏覽器訪問http://127.0.0.1:5000/user，效果如下：

13. 用戶會話

session用來記錄用戶的登錄狀態，一般基於cookie實現。

下面是一個簡單的示例。

13.1 建立Flask項目

按照以下命令建立Flask項目HelloWorld:

mkdir HelloWorld
mkdir HelloWorld/static
mkdir HelloWorld/templates
touch HelloWorld/server.py

13.2 編輯HelloWorld/server.py

內容如下：

from flask import Flask, render_template_string, \
session, request, redirect, url_for
app = Flask(__name__)
app.secret_key = 'F12Zr47j\3yX [email protected]!jLwf/T'
@app.route('/')
def hello_world():
return 'hello world'
@app.route('/login')
def login():
page = ''' <form action="{
{ url_for('do_login') }}" method="post"> <p>name: <input type="text" name="user_name" /></p> <input type="submit" value="Submit" /> </form> '''
return render_template_string(page)
@app.route('/do_login', methods=['POST'])
def do_login():
name = request.form.get('user_name')
session['user_name'] = name
return 'success'
@app.route('/show')
def show():
return session['user_name']
@app.route('/logout')
def logout():
session.pop('user_name', None)
return redirect(url_for('login'))
if __name__ == '__main__':
app.run(port=5000, debug=True)

13.3 代碼的含義

app.secret_key用於給session加密。

在/login中將向用戶展示一個表單，要求輸入一個名字，submit後將數據以post的方式傳遞給/do_login，/do_login將名字存放在session中。

如果用戶成功登錄，訪問/show時會顯示用戶的名字。此時，打開firebug等調試工具，選擇session面板，會看到有一個cookie的名稱為session。

/logout用於登出，通過將session中的user_name字段pop即可。Flask中的session基於字典類型實現，調用pop方法時會返回pop的鍵對應的值；如果要pop的鍵並不存在，那麼返回值是pop()的第二個參數。

另外，使用redirect()重定向時，一定要在前面加上return。

13.4 效果

進入http://127.0.0.1:5000/login，輸入name，點擊submit：

進入http://127.0.0.1:5000/show查看session中存儲的name：

13.5 設置sessin的有效時間

下面這段代碼來自Is there an easy way to make sessions timeout in flask?：

from datetime import timedelta
from flask import session, app
session.permanent = True
app.permanent_session_lifetime = timedelta(minutes=5)

這段代碼將session的有效時間設置為5分鐘。

14. 使用Cookie

Cookie是存儲在客戶端的記錄訪問者狀態的數據。具體原理，請見 http://zh.wikipedia.org/wiki/Cookie 。 常用的用於記錄用戶登錄狀態的session大多是基於cookie實現的。

cookie可以借助flask.Response來實現。下面是一個示例。

14.1 建立Flask項目

按照以下命令建立Flask項目HelloWorld:

mkdir HelloWorld
mkdir HelloWorld/static
mkdir HelloWorld/templates
touch HelloWorld/server.py

14.2 代碼

修改HelloWorld/server.py：

from flask import Flask, request, Response, make_response
import time
app = Flask(__name__)
@app.route('/')
def hello_world():
return 'hello world'
@app.route('/add')
def login():
res = Response('add cookies')
res.set_cookie(key='name', value='letian', expires=time.time()+6*60)
return res
@app.route('/show')
def show():
return request.cookies.__str__()
@app.route('/del')
def del_cookie():
res = Response('delete cookies')
res.set_cookie('name', '', expires=0)
return res
if __name__ == '__main__':
app.run(port=5000, debug=True)

由上可以看到，可以使用Response.set_cookie添加和刪除cookie。expires參數用來設置cookie有效時間，它的值可以是datetime對象或者unix時間戳，筆者使用的是unix時間戳。

res.set_cookie(key='name', value='letian', expires=time.time()+6*60)

上面的expire參數的值表示cookie在從現在開始的6分鐘內都是有效的。

要刪除cookie，將expire參數的值設為0即可：

res.set_cookie('name', '', expires=0)

set_cookie()函數的原型如下：

set_cookie(key, value=’’, max_age=None, expires=None, path=’/‘, domain=None, secure=None, httponly=False)

Sets a cookie. The parameters are the same as in the cookie Morsel object in the Python standard library but it accepts unicode data, too.
Parameters:

key – the key (name) of the cookie to be set.
value – the value of the cookie.
max_age – should be a number of seconds, or None (default) if the cookie should last only as long as the client’s browser session.

expires – should be a datetime object or UNIX timestamp.

domain – if you want to set a cross-domain cookie. For example, domain=”.example.com” will set a cookie that is readable by the domain www.example.com, foo.example.com etc. Otherwise, a cookie will only be readable by the domain that set it.

path – limits the cookie to a given path, per default it will span the whole domain.

14.3 運行與測試

運行HelloWorld/server.py：

$ python3 HelloWorld/server.py

使用浏覽器打開http://127.0.0.1:5000/add，浏覽器界面會顯示

add cookies

下面查看一下cookie，如果使用firefox浏覽器，可以用firebug插件查看。打開firebug，選擇Cookies選項，刷新頁面，可以看到名為name的cookie，其值為letian。

在“網絡”選項中，可以查看響應頭中類似下面內容的設置cookie的HTTP「指令」：

Set-Cookie: name=letian; Expires=Sun, 29-Jun-2014 05:16:27 GMT; Path=/

在cookie有效期間，使用浏覽器訪問http://127.0.0.1:5000/show，可以看到：

{
'name': 'letian'}

15. 閃存系統 flashing system

Flask的閃存系統（flashing system）用於向用戶提供反饋信息，這些反饋信息一般是對用戶上一次操作的反饋。反饋信息是存儲在服務器端的，當服務器向客戶端返回反饋信息後，這些反饋信息會被服務器端刪除。

下面是一個示例。

15.1 建立Flask項目

按照以下命令建立Flask項目HelloWorld:

mkdir HelloWorld
mkdir HelloWorld/static
mkdir HelloWorld/templates
touch HelloWorld/server.py

15.2 編寫HelloWorld/server.py

內容如下：

from flask import Flask, flash, get_flashed_messages
import time
app = Flask(__name__)
app.secret_key = 'some_secret'
@app.route('/')
def index():
return 'hi'
@app.route('/gen')
def gen():
info = 'access at '+ time.time().__str__()
flash(info)
return info
@app.route('/show1')
def show1():
return get_flashed_messages().__str__()
@app.route('/show2')
def show2():
return get_flashed_messages().__str__()
if __name__ == "__main__":
app.run(port=5000, debug=True)

15.3 效果

運行服務器：

$ python3 HelloWorld/server.py

打開浏覽器，訪問http://127.0.0.1:5000/gen，浏覽器界面顯示（注意，時間戳是動態生成的，每次都會不一樣，除非並行訪問）：

access at 1404020982.83

查看浏覽器的cookie，可以看到session，其對應的內容是：

.eJyrVopPy0kszkgtVrKKrlZSKIFQSUpWSknhYVXJRm55UYG2tkq1OlDRyHC_rKgIvypPdzcDTxdXA1-XwHLfLEdTfxfPUn8XX6DKWCAEAJKBGq8.BpE6dg.F1VURZa7VqU9bvbC4XIBO9-3Y4Y

再一次訪問http://127.0.0.1:5000/gen，浏覽器界面顯示：

access at 1404021130.32

cookie中session發生了變化，新的內容是：

.eJyrVopPy0kszkgtVrKKrlZSKIFQSUpWSknhYVXJRm55UYG2tkq1OlDRyHC_rKgIvypPdzcDTxdXA1-XwHLfLEdTfxfPUn8XX6DKWLBaMg1yrfCtciz1rfIEGxRbCwAhGjC5.BpE7Cg.Cb_B_k2otqczhknGnpNjQ5u4dqw

然後使用浏覽器訪問http://127.0.0.1:5000/show1，浏覽器界面顯示：

['access at 1404020982.83', 'access at 1404021130.32']

這個列表中的內容也就是上面的兩次訪問http://127.0.0.1:5000/gen得到的內容。此時，cookie中已經沒有session了。

如果使用浏覽器訪問http://127.0.0.1:5000/show1或者http://127.0.0.1:5000/show2，只會得到：

[]

15.4 高級用法

flash系統也支持對flash的內容進行分類。修改HelloWorld/server.py內容：

from flask import Flask, flash, get_flashed_messages
import time
app = Flask(__name__)
app.secret_key = 'some_secret'
@app.route('/')
def index():
return 'hi'
@app.route('/gen')
def gen():
info = 'access at '+ time.time().__str__()
flash('show1 '+info, category='show1')
flash('show2 '+info, category='show2')
return info
@app.route('/show1')
def show1():
return get_flashed_messages(category_filter='show1').__str__()
@app.route('/show2')
def show2():
return get_flashed_messages(category_filter='show2').__str__()
if __name__ == "__main__":
app.run(port=5000, debug=True)

某一時刻，浏覽器訪問http://127.0.0.1:5000/gen，浏覽器界面顯示：

access at 1404022326.39

不過，由上面的代碼可以知道，此時生成了兩個flash信息，但分類(category)不同。

使用浏覽器訪問http://127.0.0.1:5000/show1，得到如下內容：

['1 access at 1404022326.39']

而繼續訪問http://127.0.0.1:5000/show2，得到的內容為空：

[]

15.5 在模板文件中獲取flash的內容

在Flask中，get_flashed_messages()默認已經集成到Jinja2模板引擎中，易用性很強。下面是來自官方的一個示例：