本文主要借鑒 letiantian 的文章 http://www.letiantian.me/learn-flask/
一、簡介
1、Flask 是一個輕量級的基於 Python 的 Web 框架，支持 Python 2 和 Python 3，簡單易用，適合快速開發。封裝功能不及Django完善，性能不及Tornado，但是Flask的第三方開源組件比豐富（http://flask.pocoo.org/extensions/），其 WSGI工具箱采用 Werkzeug ，模板引擎則使用 Jinja2 。Flask也被稱為 “microframework” ，因為它使用簡單的核心，用 extension 增加其他功能。Flask沒有默認使用的數據庫、窗體驗證工具。
本文章中的代碼使用 Python 3 運行，建議安裝最新版本，本文使用的是Python 3.6.4。
2、其他web框架
（1）Django：比較“重”的框架，同時也是最出名的Python框架。包含了web開發中常用的功能、組件的框架（ORM、Session、Form、Admin、分頁、中間件、信號、緩存、ContenType....），Django是走大而全的方向，最出名的是其全自動化的管理后台：只需要使用起ORM，做簡單的對象定義，它就能自動生成數據庫結構、以及全功能的管理后台。
（2）Tornado：大特性就是異步非阻塞、原生支持WebSocket協議；
（3）Flask：如上
（4）Bottle：是一個簡單高效的遵循WSGI的微型python Web框架。說微型，是因為它只有一個文件，除Python標准庫外，它不依賴於任何第三方模塊。
二、安裝
$ sudo pip3 install Flask
進入python交互模式看下Flask的介紹和版本：
1 $ python3 2 3 >>> import flask 4 >>> print(flask.__doc__) 5 6 flask 7 ~~~~~ 8 9 A microframework based on Werkzeug. It's extensively documented 10 and follows best practice patterns. 11 12 :copyright: © 2010 by the Pallets team. 13 :license: BSD, see LICENSE for more details. 14 15 >>> print(flask.__version__) 16 1.0.2
三、初始化Flask
使用Flask寫一個顯示“Hello World!”的web程序，如何配置、調試Flask。
1、輸出 Hello World
（1）按照以下命令建立Flask項目：HelloWorld，后面每一個示例會多次使用到
1 mkdir HelloWorld 2 mkdir HelloWorld/static 3 mkdir HelloWorld/templates 4 touch HelloWorld/server.py
（2）static和templates目錄是默認配置，其中static用來存放靜態資源，例如圖片、js、css文件等。templates存放模板文件。
我們的網站邏輯基本在server.py文件中，當然，也可以給這個文件起其他的名字。
（3）在server.py中加入以下內容：
1 from flask import Flask
2
3 app = Flask(__name__)
4
5 @app.route('/')
6 def hello_world():
7 return 'Hello World!'
8
9 if __name__ == '__main__':
10 app.run()
（4）運行server.py
$ python3 server.py * Running on http://127.0.0.1:5000/
（5）打開瀏覽器訪問http://127.0.0.1:5000/，瀏覽頁面上將出現Hello World!。終端里會顯示下面的信息：
127.0.0.1 - - [16/May/2014 10:29:08] "GET / HTTP/1.1" 200 -
（6）變量app是一個Flask實例，通過下面的方式：
1 @app.route('/')
2 def hello_world():
3 return 'Hello World!'
當客戶端訪問/時，將響應hello_world()函數返回的內容。注意，這不是返回Hello World!這么簡單，Hello World!只是HTTP響應報文的實體部分，狀態碼等信息既可以由Flask自動處理，也可以通過編程來制定。
2、修改Flask的配置
（1）程序名稱
app = Flask(__name__)
上面的代碼中，python內置變量__name__的值是字符串__main__ 。Flask類將這個參數作為程序名稱。當然這個是可以自定義的，比如app = Flask("my-app")。
（2）靜態資源、模板、參考文檔
app = Flask("my-app", static_folder="path1", template_folder="path2")
更多參數請參考__doc__：
1 from flask import Flask 2 print(Flask.__doc__)
（3）調試模式
上面的server.py中以app.run()方式運行，這種方式下，如果服務器端出現錯誤是不會在客戶端顯示的。但是在開發環境中，顯示錯誤信息是很有必要的，要顯示錯誤信息，應該以下面的方式運行Flask：
app.run(debug=True)
將debug設置為True的另一個好處是，程序啟動后，會自動檢測源碼是否發生變化，若有變化則自動重啟程序。這可以幫我們省下很多時間。
（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網站服務的默認端口。
由於綁定了80端口，需要使用root權限運行server.py（會報錯）。也就是：
$ sudo python3 server.py
四、獲取URL參數 （GET請求）
URL參數是出現在url中的鍵值對，例如http://127.0.0.1:5000/?disp=3中的url參數是{'disp':3}
1、同上，創建項目
1 mkdir HelloWorld 2 mkdir HelloWorld/static 3 mkdir HelloWorld/templates 4 touch HelloWorld/server.py
2、列出所有的url參數
（1）修改server.py 內容：
1 from flask import Flask, request
2
3 app = Flask(__name__)
4
5
6 @app.route('/')
7 def hello_world():
8 return request.args.__str__()
9
10
11 if __name__ == '__main__':
12 app.run(port=5000, debug=True)
（2）運行看效果，在瀏覽器中訪問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', '這是愛，')])
（3）獲取瀏覽器傳給Flask服務的數據。可以通過request.full_path和request.path來看一下：
1 from flask import Flask, request
2
3 app = Flask(__name__)
4
5
6 @app.route('/')
7 def hello_world():
8 print(request.path)
9 print(request.full_path)
10 return request.args.__str__()
11
12
13 if __name__ == '__main__':
14 app.run(port=5000, debug=True)
瀏覽器訪問http://127.0.0.1:5000/?info=這是愛，，運行server.py的終端會輸出：
1 / 2 /?info=%E8%BF%99%E6%98%AF%E7%88%B1%EF%BC%8C
3、獲取某個指定的參數
（1）獲取指定參數。 例如，要獲取鍵info對應的值，如下修改server.py：
1 from flask import Flask, request
2
3 app = Flask(__name__)
4
5 @app.route('/')
6 def hello_world():
7 return request.args.get('info')
8
9 if __name__ == '__main__':
10 app.run(port=5000)
運行server.py，在瀏覽器中訪問http://127.0.0.1:5000/?info=hello，瀏覽器將顯示：
hello
（2）異常和錯誤。當我們訪問http://127.0.0.1:5000/時候卻出現了500錯誤，瀏覽器顯示：
如果開啟了Debug模式，會顯示：
這是因為沒有在URL參數中找到info。所以request.args.get('info')返回Python內置的None，而Flask不允許返回None。
解決方法很簡單，先判斷下它是不是None：
1 from flask import Flask, request
2
3 app = Flask(__name__)
4
5 @app.route('/')
6 def hello_world():
7 r = request.args.get('info')
8 if r==None:
9 # do something
10 return ''
11 return r
12
13 if __name__ == '__main__':
14 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)
4、如何處理多值
（1）出現多值。例如， http://127.0.0.1:5000/?user=Flask&time&p=7&p=8，仔細看下，p有兩個值。
如果我們的代碼是如下，則在瀏覽器中請求時，我們只會看到7：
1 from flask import Flask, request
2
3 app = Flask(__name__)
4
5 @app.route('/')
6 def hello_world():
7 r = request.args.get('p')
8 return r
9
10 if __name__ == '__main__':
11 app.run(port=5000, debug=True)
（2）使用getlist 來獲取多值 ，瀏覽器輸入 http://127.0.0.1:5000/?user=Flask&time&p=7&p=8，我們會看到['7', '8'] ：
1 from flask import Flask, request
2
3 app = Flask(__name__)
4
5
6 @app.route('/')
7 def hello_world():
8 r = request.args.getlist('p') # 返回一個list
9 return str(r)
10
11
12 if __name__ == '__main__':
13 app.run(port=5000, debug=True)
五、獲取POST方法傳送的數據
作為一種HTTP請求方法，POST用於向指定的資源提交要被處理的數據。我們在某網站注冊用戶、寫文章等時候，需要將數據傳遞到網站服務器中。並不適合將數據放到URL參數中，密碼放到URL參數中容易被看到，文章數據又太多，瀏覽器不一定支持太長長度的URL。這時，一般使用POST方法。
1、同上，創建項目
1 mkdir HelloWorld 2 mkdir HelloWorld/static 3 mkdir HelloWorld/templates 4 touch HelloWorld/server.py
這里使用瀏覽器模擬工具：requests庫
$ sudo pip3 install requests
2、查看POST數據內容
（1）編寫server.py
以用戶注冊為例子，我們需要向服務器/register傳送用戶名name和密碼password。如下編寫HelloWorld/server.py：
1 from flask import Flask, request
2
3 app = Flask(__name__)
4
5
6 @app.route('/')
7 def hello_world():
8 return 'hello world'
9
10
11 @app.route('/register', methods=['POST'])
12 def register():
13 print(request.headers)
14 print(request.stream.read())
15 return 'welcome'
16
17
18 if __name__ == '__main__':
19 app.run(port=5000, debug=True)
@app.route(‘/register’, methods=[‘POST’])是指url/register只接受POST方法。可以根據需要修改methods`參數，例如如果想要讓它同時支持GET和POST，這樣寫：
@app.route('/register', methods=['GET', 'POST'])
（2）瀏覽器模擬工具client.py內容如下：
1 import requests
2
3 user_info = {'name': 'letian', 'password': '123'}
4 r = requests.post("http://127.0.0.1:5000/register", data=user_info)
5
6 print(r.text)
（3）運行HelloWorld/server.py，然后運行client.py
client.py將輸出：
welcome
而HelloWorld/server.py在終端中輸出以下調試信息（通過print輸出）：
1 Host: 127.0.0.1:5000 2 User-Agent: python-requests/2.19.1 3 Accept-Encoding: gzip, deflate 4 Accept: */* 5 Connection: keep-alive 6 Content-Length: 24 7 Content-Type: application/x-www-form-urlencoded 8 9 10 b'name=letian&password=123'
前7行是client.py生成的HTTP請求頭，由print(request.headers)輸出。
請求體的數據，我們通過print(request.stream.read())輸出，結果是：
b'name=letian&password=123'
3、解析POST數據
（1）修改server.py
上面，我們看到post的數據內容是：b'name=letian&password=123'，我們要把name、password提取出來，使用Flask內置的解析器request.form：
1 from flask import Flask, request
2
3 app = Flask(__name__)
4
5 @app.route('/')
6 def hello_world():
7 return 'hello world'
8
9
10 @app.route('/register', methods=['POST'])
11 def register():
12 print(request.headers)
13 # print(request.stream.read()) # 不要用，否則下面的form取不到數據
14 print(request.form)
15 print(request.form['name'])
16 print(request.form.get('name'))
17 print(request.form.getlist('name'))
18 print(request.form.get('nickname', default='little apple'))
19 return 'welcome'
20
21
22 if __name__ == '__main__':
23 app.run(port=5000, debug=True)
request.form會自動解析數據。request.form['name']和request.form.get('name')都可以獲取name對應的值。對於request.form.get()可以為參數default指定值以作為默認值。
（2）客戶端效果 ，執行client.py請求數據，服務器代碼會在終端輸出：
1 Host: 127.0.0.1:5000
2 User-Agent: python-requests/2.19.1
3 Accept-Encoding: gzip, deflate
4 Accept: */*
5 Connection: keep-alive
6 Content-Length: 24
7 Content-Type: application/x-www-form-urlencoded
8
9
10 ImmutableMultiDict([('name', 'letian'), ('password', '123')])
11 letian
12 letian
13 ['letian']
14 little apple
（3）多個值的情況。如果name有多個值，可以使用request.form.getlist('name')，該方法將返回一個列表。將client.py改一下：
1 import requests
2
3 user_info = {'name': ['letian', 'letian2'], 'password': '123'}
4 r = requests.post("http://127.0.0.1:5000/register", data=user_info)
5
6 print(r.text)
此時運行client.py，print(request.form.getlist('name'))將輸出：
[u'letian', u'letian2']
六、處理和響應JSON數據
使用 HTTP POST 方法傳到網站服務器的數據格式可以有很多種，比如“獲取POST方法傳送的數據”講到的name=letian&password=123這種用過&符號分割的key-value鍵值對格式。我們也可以用JSON格式、XML格式。相比XML的重量、規范繁瑣，JSON顯得非常小巧和易用。
1、同上，創建項目
1 mkdir HelloWorld 2 mkdir HelloWorld/static 3 mkdir HelloWorld/templates 4 touch HelloWorld/server.py
2、處理JSON格式的請求數據。如果POST的數據是JSON格式，request.json會自動將json數據轉換成Python類型（字典或者列表）。
（1）編寫server.py
1 from flask import Flask, request
2
3 app = Flask("my-app")
4
5
6 @app.route('/')
7 def hello_world():
8 return 'Hello World!'
9
10
11 @app.route('/add', methods=['POST'])
12 def add():
13 print(request.headers)
14 print(type(request.json))
15 print(request.json)
16 result = request.json['a'] + request.json['b']
17 return str(result)
18
19
20 if __name__ == '__main__':
21 app.run(host='127.0.0.1', port=5000, debug=True)
（2）編寫client.py模擬瀏覽器請求：
1 import requests
2
3 json_data = {'a': 1, 'b': 2}
4
5 r = requests.post("http://127.0.0.1:5000/add", json=json_data)
6
7 print(r.text)
（3）執行效果，運行server.py，然后運行client.py
client.py 會在終端輸出：3
server.py 會在終端輸出：（注意，請求頭中Content-Type的值是application/json）
1 Host: 127.0.0.1:5000
2 User-Agent: python-requests/2.19.1
3 Accept-Encoding: gzip, deflate
4 Accept: */*
5 Connection: keep-alive
6 Content-Length: 16
7 Content-Type: application/json
8
9
10 <class 'dict'>
11 {'a': 1, 'b': 2}
3、響應JSON - 方案1 ：json.dumps()
響應JSON時，除了要把響應體改成JSON格式，響應頭的Content-Type也要設置為application/json。
（1）編寫server2.py
1 from flask import Flask, request, Response
2 import json
3
4 app = Flask("my-app")
5
6
7 @app.route('/')
8 def hello_world():
9 return 'Hello World!'
10
11
12 @app.route('/add', methods=['POST'])
13 def add():
14 result = {'sum': request.json['a'] + request.json['b']}
15 return Response(json.dumps(result), mimetype='application/json')
16
17
18 if __name__ == '__main__':
19 app.run(host='127.0.0.1', port=5000, debug=True)
（2）編寫client2.py
1 import requests
2
3 json_data = {'a': 1, 'b': 2}
4
5 r = requests.post("http://127.0.0.1:5000/add", json=json_data)
6
7 print(r.headers)
8 print(r.text)
（3）執行效果
運行client.py，將顯示：
1 {'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'}
2 {"sum": 3}
上面第一段內容是服務器的響應頭，第二段內容是響應體，也就是服務器返回的JSON格式數據。
（4）定制HTTP響應頭，比如自定義Server，可以如下修改add()函數：
1 @app.route('/add', methods=['POST'])
2 def add():
3 result = {'sum': request.json['a'] + request.json['b']}
4 resp = Response(json.dumps(result), mimetype='application/json')
5 resp.headers.add('Server', 'python flask')
6 return resp
client2.py運行后會輸出：
1 {'Content-Type': 'application/json', 'Content-Length': '10', 'Server': 'python flask', 'Date': 'Sat, 07 Jul 2018 05:26:40 GMT'}
2 {"sum": 3}
4、響應JSON - 方案2：使用 jsonify 工具函數
1 from flask import Flask, request, jsonify
2
3 app = Flask("my-app")
4
5
6 @app.route('/')
7 def hello_world():
8 return 'Hello World!'
9
10
11 @app.route('/add', methods=['POST'])
12 def add():
13 result = {'sum': request.json['a'] + request.json['b']}
14 return jsonify(result)
15
16
17 if __name__ == '__main__':
18 app.run(host='127.0.0.1', port=5000, debug=True)
七、上傳文件
一般也是POST方法
1、同上，創建項目
1 mkdir HelloWorld 2 mkdir HelloWorld/static 3 mkdir HelloWorld/templates 4 touch HelloWorld/server.py
2、上傳文件
以上傳圖片為例：假設將上傳的圖片只允許’png’、’jpg’、’jpeg’、’gif’這四種格式，通過url/upload使用POST上傳，上傳的圖片存放在服務器端的static/uploads目錄下。
（1）首先在項目HelloWorld中創建目錄static/uploads：
mkdir HelloWorld/static/uploads
（2）使用werkzeug庫，判斷文件名是否安全，例如防止文件名是../../../a.png：
sudo pip3 install werkzeug
（3）編寫server.py:
1 from flask import Flask, request
2
3 from werkzeug.utils import secure_filename
4 import os
5
6 app = Flask(__name__)
7
8 # 文件上傳目錄
9 app.config['UPLOAD_FOLDER'] = 'static/uploads/'
10 # 支持的文件格式
11 app.config['ALLOWED_EXTENSIONS'] = {'png', 'jpg', 'jpeg', 'gif'} # 集合類型
12
13
14 # 判斷文件名是否是我們支持的格式
15 def allowed_file(filename):
16 return '.' in filename and \
17 filename.rsplit('.', 1)[1] in app.config['ALLOWED_EXTENSIONS']
18
19
20 @app.route('/')
21 def hello_world():
22 return 'hello world'
23
24
25 @app.route('/upload', methods=['POST'])
26 def upload():
27 upload_file = request.files['image']
28 if upload_file and allowed_file(upload_file.filename):
29 filename = secure_filename(upload_file.filename)
30 # 將文件保存到 static/uploads 目錄，文件名同上傳時使用的文件名
31 upload_file.save(os.path.join(app.root_path, app.config['UPLOAD_FOLDER'], filename))
32 return 'info is '+request.form.get('info', '')+'. success'
33 else:
34 return 'failed'
35
36
37 if __name__ == '__main__':
38 app.run(port=5000, debug=True)
解析：
<1> app.config中的config是字典的子類，可以用來設置自有的配置信息，也可以設置自己的配置信息。
<2> 函數allowed_file(filename)用來判斷filename是否有后綴以及后綴是否在app.config['ALLOWED_EXTENSIONS']中。
<3> 客戶端上傳的圖片必須以image標識。
<4> upload_file是上傳文件對應的對象。
<5> app.root_path獲取server.py所在目錄在文件系統中的絕對路徑。
<6> upload_file.save(path)用來將upload_file保存在服務器的文件系統中，參數最好是絕對路徑，否則會報錯（網上很多代碼都是使用相對路徑，但是筆者在使用相對路徑時總是報錯，說找不到路徑）。
<7> 函數os.path.join()用來將使用合適的路徑分隔符將路徑組合起來。
（4）定制客戶端client.py
1 import requests
2
3 file_data = {'image': open('Lenna.jpg', 'rb')}
4
5 user_info = {'info': 'Lenna'}
6
7 r = requests.post("http://127.0.0.1:5000/upload", data=user_info, files=file_data)
8
9 print(r.text)
（5）執行效果。
<1> 運行client.py，當前目錄下的Lenna.jpg將上傳到服務器。然后，我們可以在static/uploads中看到文件Lenna.jpg。
<2> 要控制上產文件的大小，可以設置請求實體的大小，例如：(不過，在處理上傳文件時候，需要使用try:...except:...)
app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024 #16MB
<3> 獲取上傳文件的內容可以：
file_content = request.files['image'].stream.read()
八、Restful URL
簡單來說，Restful URL可以看做是對 URL 參數的替代
推薦閱讀：阮一峰 理解RESTful架構 http://www.ruanyifeng.com/blog/2011/09/restful.html
1、同上，創建項目
1 mkdir HelloWorld 2 mkdir HelloWorld/static 3 mkdir HelloWorld/templates 4 touch HelloWorld/server.py
2、寫代碼
（1）編寫server.py:
1 from flask import Flask
2
3 app = Flask(__name__)
4
5
6 @app.route('/')
7 def hello_world():
8 return 'hello world'
9
10
11 @app.route('/user/<username>')
12 def user(username):
13 print(username)
14 print(type(username))
15 return 'hello ' + username
16
17
18 @app.route('/user/<username>/friends')
19 def user_friends(username):
20 print(username)
21 print(type(username))
22 return 'hello ' + username + 'They are your friends.'
23
24
25 if __name__ == '__main__':
26 app.run(port=5000, debug=True)
（2）執行。運行HelloWorld/server.py。
<1> 使用瀏覽器訪問http://127.0.0.1:5000/user/letian，HelloWorld/server.py將輸出：
1 letian 2 <class 'str'>
<2> 訪問http://127.0.0.1:5000/user/letian/，響應為404 Not Found
<3> 瀏覽器訪問http://127.0.0.1:5000/user/letian/friends，可以看到：
Hello letian. They are your friends.
HelloWorld/server.py輸出：
1 letian 2 <class 'str'>
3、轉換類型
由上面的示例可以看出，使用 Restful URL 得到的變量默認為str對象。如果我們需要通過分頁顯示查詢結果，那么需要在url中有數字來指定頁數。按照上面方法，可以在獲取str類型頁數變量后，將其轉換為int類型。不過，還有更方便的方法，就是用flask內置的轉換機制，即在route中指定該如何轉換。
（1）修改server ：@app.route(‘/page/int:num‘)`會將num變量自動轉換成int類型。
1 from flask import Flask
2
3 app = Flask(__name__)
4
5
6 @app.route('/')
7 def hello_world():
8 return 'hello world'
9
10
11 @app.route('/page/<int:num>')
12 def page(num):
13 print(num)
14 print(type(num))
15 return 'hello world'
16
17
18 if __name__ == '__main__':
19 app.run(port=5000, debug=True)
（2）執行。在瀏覽器中訪問http://127.0.0.1:5000/page/1，HelloWorld/server.py將輸出如下內容：
1 1 2 <class 'int'>
如果訪問的是http://127.0.0.1:5000/page/asd，我們會得到404響應。
（3）在官方資料中，說是有3個默認的轉換器（看上去夠用）：
1 int accepts integers 2 float like int but for floating point values 3 path like the default but also accepts slashes
（4）一個特殊用法，修改server：
1 from flask import Flask
2
3 app = Flask(__name__)
4
5
6 @app.route('/')
7 def hello_world():
8 return 'hello world'
9
10
11 @app.route('/page/<int:num1>-<int:num2>')
12 def page(num1, num2):
13 print(num1)
14 print(num2)
15 return 'hello world'
16
17
18 if __name__ == '__main__':
19 app.run(port=5000, debug=True)
在瀏覽器中訪問http://127.0.0.1:5000/page/11-22，HelloWorld/server.py會輸出：
1 11 2 22
4、編寫轉換器（自定義）
自定義的轉換器是一個繼承werkzeug.routing.BaseConverter的類，修改to_python和to_url方法即可。to_python方法用於將url中的變量轉換后供被@app.route包裝的函數使用，to_url方法用於flask.url_for中的參數轉換。
下面是一個示例，將HelloWorld/server.py修改如下：
1 from flask import Flask, url_for
2
3 from werkzeug.routing import BaseConverter
4
5
6 class MyIntConverter(BaseConverter):
7
8 def __init__(self, url_map):
9 super(MyIntConverter, self).__init__(url_map)
10
11 def to_python(self, value):
12 return int(value)
13
14 def to_url(self, value):
15 return value * 2
16
17
18 app = Flask(__name__)
19 app.url_map.converters['my_int'] = MyIntConverter
20
21
22 @app.route('/')
23 def hello_world():
24 return 'hello world'
25
26
27 @app.route('/page/<my_int:num>')
28 def page(num):
29 print(num)
30 print(url_for('page', num=123)) # page 對應的是 page函數 ，num 對應對應`/page/<my_int:num>`中的num，必須是str
31 return 'hello world'
32
33
34 if __name__ == '__main__':
35 app.run(port=5000, debug=True)
瀏覽器訪問http://127.0.0.1:5000/page/123后，HelloWorld/server.py的輸出信息是：
1 123 2 /page/123123
九、使用url_for生成鏈接
工具函數url_for可以讓你以軟編碼的形式生成url，提供開發效率
1、同上，創建項目
1 mkdir HelloWorld 2 mkdir HelloWorld/static 3 mkdir HelloWorld/templates 4 touch HelloWorld/server.py
2、寫代碼
（1）編寫server.py:
1 from flask import Flask, url_for
2
3 app = Flask(__name__)
4
5 @app.route('/')
6 def hello_world():
7 pass
8
9 @app.route('/user/<name>')
10 def user(name):
11 pass
12
13 @app.route('/page/<int:num>')
14 def page(num):
15 pass
16
17 @app.route('/test')
18 def test():
19 print(url_for('hello_world'))
20 print(url_for('user', name='letian'))
21 print(url_for('page', num=1, q='hadoop mapreduce 10%3'))
22 print(url_for('static', filename='uploads/01.jpg'))
23 return 'Hello'
24
25 if __name__ == '__main__':
26 app.run(debug=True)
（2）執行結果。運行HelloWorld/server.py，然后在瀏覽器中訪問http://127.0.0.1:5000/test，HelloWorld/server.py將輸出以下信息：
1 / 2 /user/letian 3 /page/1?q=hadoop+mapreduce+10%253 4 /static/uploads/01.jpg
十、使用redirect重定向網址
redirect函數用於重定向，實現機制很簡單，就是向客戶端（瀏覽器）發送一個重定向的HTTP報文，瀏覽器會去訪問報文中指定的url。
1、同上，創建項目
1 mkdir HelloWorld 2 mkdir HelloWorld/static 3 mkdir HelloWorld/templates 4 touch HelloWorld/server.py
2、編寫代碼。使用redirect時，給它一個字符串類型的參數就行了。
（1）編寫server
1 from flask import Flask, url_for, redirect
2
3 app = Flask(__name__)
4
5 @app.route('/')
6 def hello_world():
7 return 'hello world'
8
9 @app.route('/test1')
10 def test1():
11 print('this is test1')
12 return redirect(url_for('test2'))
13
14 @app.route('/test2')
15 def test2():
16 print('this is test2')
17 return 'this is test2'
18
19 if __name__ == '__main__':
20 app.run(debug=True)
（2）運行HelloWorld/server.py，在瀏覽器中訪問http://127.0.0.1:5000/test1，瀏覽器的url會變成http://127.0.0.1:5000/test2，並顯示：
this is test2
十一、使用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循環。
1、同上，創建項目
1 mkdir HelloWorld 2 mkdir HelloWorld/static 3 mkdir HelloWorld/templates 4 touch HelloWorld/server.py
2、創建並編輯 HelloWorld/templates/default.html
1 <html>
2 <head>
3 <title>
4 {% if page_title %}
5 {{ page_title }}
6 {% endif %}
7 </title>
8 </head>
9
10 <body>
11 {% block body %}{% endblock %}
12
13
14 ```
15 可以看到，在``標簽中使用了if判斷，如果給模板傳遞了`page_title`變量，顯示之，否則，不顯示。
16 ``標簽中定義了一個名為`body`的block，用來被其他模板文件繼承。
17 ### 11.3 創建並編輯HelloWorld/templates/user_info.html
18 內容如下：
19 ```
20 {% extends "default.html" %}
21
22 {% block body %}
23 {% for key in user_info %}
24
25 {{ key }}: {{ user_info[key] }}
26
27
28 {% endfor %}
29 {% endblock %}
變量user_info應該是一個字典，for循環用來循環輸出鍵值對。
3、編輯 server.py
1 from flask import Flask, render_template
2
3 app = Flask(__name__)
4
5
6 @app.route('/')
7 def hello_world():
8 return 'hello world'
9
10
11 @app.route('/user')
12 def user():
13 user_info = {
14 'name': 'letian',
15 'email': '123@aa.com',
16 'age':0,
17 'github': 'https://github.com/letiantian'
18 }
19 return render_template('user_info.html', page_title='letian\'s info', user_info=user_info)
20
21
22 if __name__ == '__main__':
23 app.run(port=5000, debug=True)
render_template()函數的第一個參數指定模板文件，后面的參數是要傳遞的數據。
4、運行與測試
運行HelloWorld/server.py，在瀏覽器中訪問http://127.0.0.1:5000/user，效果圖如下：
查看網頁源碼：
1 <html> 2 <head> 3 <title> 4 letian's info 5 </title> 6 </head> 7 <body> 8 name: letian <br/> 9 email: 123@aa.com <br/> 10 age: 0 <br/> 11 github: https://github.com/letiantian <br/> 12 </body> 13 </html>
十二、自定義404等錯誤的響應
要處理HTTP錯誤，可以使用flask.abort函數。
1、示例1：簡單入門
（1）創建項目
1 mkdir HelloWorld 2 mkdir HelloWorld/static 3 mkdir HelloWorld/templates 4 touch HelloWorld/server.py
（2）編輯 server.py
1 from flask import Flask, render_template_string, abort
2
3 app = Flask(__name__)
4
5
6 @app.route('/')
7 def hello_world():
8 return 'hello world'
9
10
11 @app.route('/user')
12 def user():
13 abort(401) # Unauthorized 未授權
14 print('Unauthorized, 請先登錄')
15
16
17 if __name__ == '__main__':
18 app.run(port=5000, debug=True)
（3）效果。運行HelloWorld/server.py，瀏覽器訪問http://127.0.0.1:5000/user，效果如下：
要注意的是，HelloWorld/server.py中abort(401)后的print並沒有執行。
2、示例2 ：自定義錯誤頁面
（1）修改server
1 from flask import Flask, render_template_string, abort
2
3 app = Flask(__name__)
4
5
6 @app.route('/')
7 def hello_world():
8 return 'hello world'
9
10
11 @app.route('/user')
12 def user():
13 abort(401) # Unauthorized
14
15
16 @app.errorhandler(401)
17 def page_unauthorized(error):
18 return render_template_string('<h1> Unauthorized </h1><h2>{{ error_info }}</h2>', error_info=error), 401
19
20
21 if __name__ == '__main__':
22 app.run(port=5000, debug=True)
page_unauthorized函數返回的是一個元組，401 代表HTTP 響應狀態碼。如果省略401，則響應狀態碼會變成默認的 200。
（2）效果，運行HelloWorld/server.py，瀏覽器訪問http://127.0.0.1:5000/user，效果如下：
十三、用戶會話
session用來記錄用戶的登錄狀態，一般基於cookie實現
1、創建項目
1 mkdir HelloWorld 2 mkdir HelloWorld/static 3 mkdir HelloWorld/templates 4 touch HelloWorld/server.py
2、編輯 server.py
1 from flask import Flask, render_template_string, \
2 session, request, redirect, url_for
3
4 app = Flask(__name__)
5
6 app.secret_key = 'F12Zr47j\3yX R~X@H!jLwf/T'
7
8
9 @app.route('/')
10 def hello_world():
11 return 'hello world'
12
13
14 @app.route('/login')
15 def login():
16 page = '''
17 <form action="{{ url_for('do_login') }}" method="post">
18 <p>name: <input type="text" name="user_name" /></p>
19 <input type="submit" value="Submit" />
20 </form>
21 '''
22 return render_template_string(page)
23
24
25 @app.route('/do_login', methods=['POST'])
26 def do_login():
27 name = request.form.get('user_name')
28 session['user_name'] = name
29 return 'success'
30
31
32 @app.route('/show')
33 def show():
34 return session['user_name']
35
36
37 @app.route('/logout')
38 def logout():
39 session.pop('user_name', None)
40 return redirect(url_for('login'))
41
42
43 if __name__ == '__main__':
44 app.run(port=5000, debug=True)
代碼含義與解析：
（1）app.secret_key用於給session加密。
（2）在/login中將向用戶展示一個表單，要求輸入一個名字，submit后將數據以post的方式傳遞給/do_login，/do_login將名字存放在session中。
（3）如果用戶成功登錄，訪問/show時會顯示用戶的名字。此時，打開firebug等調試工具，選擇session面板，會看到有一個cookie的名稱為session。
（4）/logout用於登出，通過將session中的user_name字段pop即可。Flask中的session基於字典類型實現，調用pop方法時會返回pop的鍵對應的值；如果要pop的鍵並不存在，那么返回值是pop()的第二個參數。
（5）使用redirect()重定向時，一定要在前面加上return。
3、效果
（1）進入http://127.0.0.1:5000/login，輸入name，點擊submit：
進入http://127.0.0.1:5000/show查看session中存儲的name：
4、設置session的有效時間，將session的有效時間設置為5分鍾。
1 from datetime import timedelta 2 from flask import session, app 3 4 session.permanent = True 5 app.permanent_session_lifetime = timedelta(minutes=5)
十四、使用Cookie
Cookie是存儲在客戶端的記錄訪問者狀態的數據。 常用的用於記錄用戶登錄狀態的session大多是基於cookie實現的。cookie可以借助flask.Response來實現。
推薦閱讀：具體原理 http://zh.wikipedia.org/wiki/Cookie
1、創建項目
1 mkdir HelloWorld 2 mkdir HelloWorld/static 3 mkdir HelloWorld/templates 4 touch HelloWorld/server.py
2、代碼
（1）修改server.py
1 from flask import Flask, request, Response, make_response
2 import time
3
4 app = Flask(__name__)
5
6
7 @app.route('/')
8 def hello_world():
9 return 'hello world'
10
11
12 @app.route('/add')
13 def login():
14 res = Response('add cookies')
15 res.set_cookie(key='name', value='letian', expires=time.time()+6*60)
16 return res
17
18
19 @app.route('/show')
20 def show():
21 return request.cookies.__str__()
22
23
24 @app.route('/del')
25 def del_cookie():
26 res = Response('delete cookies')
27 res.set_cookie('name', '', expires=0)
28 return res
29
30
31 if __name__ == '__main__':
32 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.
（2）運行與測試
<1> 運行server.py,使用瀏覽器打開http://127.0.0.1:5000/add，瀏覽器界面會顯示:
add cookies
<2> 查看cookie，如果使用firefox瀏覽器，可以用firebug插件查看。打開firebug，選擇Cookies選項，刷新頁面，可以看到名為name的cookie，其值為letian。
在“網絡”選項中，可以查看響應頭中類似下面內容的設置cookie的HTTP「指令」：
Set-Cookie: name=letian; Expires=Sun, 29-Jun-2014 05:16:27 GMT; Path=/
<3> 在cookie有效期間，使用瀏覽器訪問http://127.0.0.1:5000/show，可以看到：
{'name': 'letian'}
十五、閃存系統 flashing system
Flask的閃存系統（flashing system）用於向用戶提供反饋信息，這些反饋信息一般是對用戶上一次操作的反饋。反饋信息是存儲在服務器端的，當服務器向客戶端返回反饋信息后，這些反饋信息會被服務器端刪除。
1、創建項目
1 mkdir HelloWorld 2 mkdir HelloWorld/static 3 mkdir HelloWorld/templates 4 touch HelloWorld/server.py
2、編寫server.py
1 from flask import Flask, flash, get_flashed_messages
2 import time
3
4 app = Flask(__name__)
5 app.secret_key = 'some_secret'
6
7
8 @app.route('/')
9 def index():
10 return 'hi'
11
12
13 @app.route('/gen')
14 def gen():
15 info = 'access at '+ time.time().__str__()
16 flash(info)
17 return info
18
19
20 @app.route('/show1')
21 def show1():
22 return get_flashed_messages().__str__()
23
24
25 @app.route('/show2')
26 def show2():
27 return get_flashed_messages().__str__()
28
29
30 if __name__ == "__main__":
31 app.run(port=5000, debug=True)
3、效果
（1）打開瀏覽器，訪問http://127.0.0.1:5000/gen，瀏覽器界面顯示（注意，時間戳是動態生成的，每次都會不一樣，除非並行訪問）：
access at 1404020982.83
（2）查看瀏覽器的cookie，可以看到session，其對應的內容是：
.eJyrVopPy0kszkgtVrKKrlZSKIFQSUpWSknhYVXJRm55UYG2tkq1OlDRyHC_rKgIvypPdzcDTxdXA1-XwHLfLEdTfxfPUn8XX6DKWCAEAJKBGq8.BpE6dg.F1VURZa7VqU9bvbC4XIBO9-3Y4Y
（3）再一次訪問http://127.0.0.1:5000/gen，瀏覽器界面顯示：
access at 1404021130.32
cookie中session發生了變化，新的內容是：
.eJyrVopPy0kszkgtVrKKrlZSKIFQSUpWSknhYVXJRm55UYG2tkq1OlDRyHC_rKgIvypPdzcDTxdXA1-XwHLfLEdTfxfPUn8XX6DKWLBaMg1yrfCtciz1rfIEGxRbCwAhGjC5.BpE7Cg.Cb_B_k2otqczhknGnpNjQ5u4dqw
（4）然后使用瀏覽器訪問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，只會得到：[ ]
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，得到的內容為空：[ ]
5、在模板文件中獲取flash的內容
在Flask中，get_flashed_messages()默認已經集成到Jinja2模板引擎中，易用性很強。下面是來自官方的一個示例：
