Python Flask Web 框架入門

一、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。

二、其餘web框架

（1）Django：比較「重」的框架，同時也是最出名的Python框架。包含了web開發中經常使用的功能、組件的框架（ORM、Session、Form、Admin、分頁、中間件、信號、緩存、ContenType....），Django是走大而全的方向，最出名的是其全自動化的管理後臺：只須要使用起ORM，作簡單的對象定義，它就能自動生成數據庫結構、以及全功能的管理後臺。

（2）Tornado：大特性就是異步非阻塞、原生支持WebSocket協議；

（3）Flask：如上

（4）Bottle：是一個簡單高效的遵循WSGI的微型python Web框架。說微型，是由於它只有一個文件，除Python標準庫外，它不依賴於任何第三方模塊。

2、安裝

$ 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

3、初始化Flask

使用Flask寫一個顯示「Hello World!」的web程序，如何配置、調試Flask。

一、輸出 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自動處理，也能夠經過編程來制定。

二、修改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

4、獲取URL參數（GET請求）

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

一、同上，建立項目

1 mkdir HelloWorld
2 mkdir HelloWorld/static
3 mkdir HelloWorld/templates
4 touch HelloWorld/server.py

二、列出全部的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

三、獲取某個指定的參數

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

四、如何處理多值

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

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

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

一、同上，建立項目

1 mkdir HelloWorld
2 mkdir HelloWorld/static
3 mkdir HelloWorld/templates
4 touch HelloWorld/server.py

這裏使用瀏覽器模擬工具：requests庫

$ sudo pip3 install requests

二、查看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'

三、解析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']

6、處理和響應JSON數據

使用 HTTP POST 方法傳到網站服務器的數據格式能夠有不少種，好比「獲取POST方法傳送的數據」講到的name=letian&password=123這種用過&符號分割的key-value鍵值對格式。咱們也能夠用JSON格式、XML格式。相比XML的重量、規範繁瑣，JSON顯得很是小巧和易用。

一、同上，建立項目

1 mkdir HelloWorld
2 mkdir HelloWorld/static
3 mkdir HelloWorld/templates
4 touch HelloWorld/server.py

二、處理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}

三、響應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}

四、響應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)

7、上傳文件

通常也是POST方法

一、同上，建立項目

1 mkdir HelloWorld
2 mkdir HelloWorld/static
3 mkdir HelloWorld/templates
4 touch HelloWorld/server.py

二、上傳文件

以上傳圖片爲例：假設將上傳的圖片只容許’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()

8、Restful URL

簡單來講，Restful URL能夠看作是對 URL 參數的替代

推薦閱讀：阮一峯理解RESTful架構 http://www.ruanyifeng.com/blog/2011/09/restful.html

一、同上，建立項目

1 mkdir HelloWorld
2 mkdir HelloWorld/static
3 mkdir HelloWorld/templates
4 touch HelloWorld/server.py

二、寫代碼

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

三、轉換類型

由上面的示例能夠看出，使用 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

四、編寫轉換器（自定義）

自定義的轉換器是一個繼承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

9、使用url_for生成連接

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

一、同上，建立項目

1 mkdir HelloWorld
2 mkdir HelloWorld/static
3 mkdir HelloWorld/templates
4 touch HelloWorld/server.py

二、寫代碼

（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

10、使用redirect重定向網址

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

一、同上，建立項目

1 mkdir HelloWorld
2 mkdir HelloWorld/static
3 mkdir HelloWorld/templates
4 touch HelloWorld/server.py

二、編寫代碼。使用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

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循環。

一、同上，建立項目

1 mkdir HelloWorld
2 mkdir HelloWorld/static
3 mkdir HelloWorld/templates
4 touch HelloWorld/server.py

二、建立並編輯 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循環用來循環輸出鍵值對。

三、編輯 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()函數的第一個參數指定模板文件，後面的參數是要傳遞的數據。

四、運行與測試

運行HelloWorld/server.py，在瀏覽器中訪問http://127.0.0.1:5000/user，效果圖以下：

查看網頁源碼：

 1 <html>
 2 <head>
 3     <title>
 4             letian&#39;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>

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

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

一、示例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 ：自定義錯誤頁面

（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，效果以下：

十3、用戶會話

session用來記錄用戶的登陸狀態，通常基於cookie實現

一、建立項目

1 mkdir HelloWorld
2 mkdir HelloWorld/static
3 mkdir HelloWorld/templates
4 touch HelloWorld/server.py

二、編輯 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。

三、效果

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

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

四、設置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)

十4、使用Cookie

Cookie是存儲在客戶端的記錄訪問者狀態的數據。經常使用的用於記錄用戶登陸狀態的session大可能是基於cookie實現的。cookie能夠藉助flask.Response來實現。

推薦閱讀：具體原理 http://zh.wikipedia.org/wiki/Cookie

一、建立項目

1 mkdir HelloWorld
2 mkdir HelloWorld/static
3 mkdir HelloWorld/templates
4 touch HelloWorld/server.py

二、代碼

（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'}

十5、閃存系統 flashing system

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

一、建立項目

1 mkdir HelloWorld
2 mkdir HelloWorld/static
3 mkdir HelloWorld/templates
4 touch HelloWorld/server.py

二、編寫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)

三、效果

（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，只會獲得：[ ]

四、高級用法

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)