flask——web框架入门

原文：https://blog.csdn.net/sinat_38682860/article/details/82354342

 

Flask是一个轻量级的基于Python的web框架。

本文适合有一定HTML、Python、网络基础的同学阅读。

1. 简介

这份文档中的代码使用 Python 3 运行。
是的，所以读者需要自己在电脑上安装Python 3 和 pip3。建议安装最新版本，我使用的是Python 3.6.4。
安装方法，可以自行谷歌或者百度。
建议在 linux 下实践本教程中命令行操作、执行代码。

2. 安装

通过pip3安装Flask即可：





1 $ sudo pip3 install Flask




进入python交互模式看下Flask的介绍和版本：


 








 1 $ python3
 2  
 3  
 4  
 5 >>> import flask
 6  
 7 >>> print(flask.__doc__)
 8  
 9  
10  
11 flask
12  
13 ~~~~~
14  
15  
16  
17 A microframework based on Werkzeug. It's extensively documented
18  
19 and follows best practice patterns.
20 :copyright: © 2010 by the Pallets team.
24  
25 :license: BSD, see LICENSE for more details.
26  
27  
28  
29 >>> print(flask.__version__)
30  
31 1.0.2








 


3. 从 Hello World 开始


本节主要内容：使用Flask写一个显示”Hello World!”的web程序，如何配置、调试Flask。


3.1 Hello World


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


 








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








 


static和templates目录是默认配置，其中static用来存放静态资源，例如图片、js、css文件等。templates存放模板文件。

我们的网站逻辑基本在server.py文件中，当然，也可以给这个文件起其他的名字。


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


 








 1 from flask import Flask
 2  
 3  
 4  
 5 app = Flask(__name__)
 6  
 7  
 8  
 9 @app.route('/')
10  
11 def hello_world():
12  
13 return 'Hello World!'
14  
15  
16  
17 if __name__ == '__main__':
18  
19 app.run()








 


运行server.py：








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








打开浏览器访问http://127.0.0.1:5000/，浏览页面上将出现Hello World!。

终端里会显示下面的信息：






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




变量app是一个Flask实例，通过下面的方式：








1 @app.route('/')
2  
3 def hello_world():
4  
5 return 'Hello World!'








当客户端访问/时，将响应hello_world()函数返回的内容。注意，这不是返回Hello World!这么简单，Hello World!只是HTTP响应报文的实体部分，状态码等信息既可以由Flask自动处理，也可以通过编程来制定。


3.2 修改Flask的配置




1 app = Flask(__name__)




上面的代码中，python内置变量__name__的值是字符串__main__ 。Flask类将这个参数作为程序名称。当然这个是可以自定义的，比如app = Flask("my-app")。


Flask默认使用static目录存放静态资源，templates目录存放模板，这是可以通过设置参数更改的：




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




更多参数请参考__doc__：








1 from flask import Flask
2  
3 print(Flask.__doc__)








3.3 调试模式


上面的server.py中以app.run()方式运行，这种方式下，如果服务器端出现错误是不会在客户端显示的。但是在开发环境中，显示错误信息是很有必要的，要显示错误信息，应该以下面的方式运行Flask：




1 app.run(debug=True)




将debug设置为True的另一个好处是，程序启动后，会自动检测源码是否发生变化，若有变化则自动重启程序。这可以帮我们省下很多时间。


3.4 绑定IP和端口


默认情况下，Flask绑定IP为127.0.0.1，端口为5000。我们也可以通过下面的方式自定义：




1 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。也就是：




1 $ sudo python3 server.py




3.5 本节源码


https://github.com/letiantian/Learn-Flask/tree/master/flask-demo-001


4. 获取 URL 参数


URL参数是出现在url中的键值对，例如http://127.0.0.1:5000/?disp=3中的url参数是{'disp':3}。


4.1 建立Flask项目


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








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








4.2 列出所有的url参数


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








 1 from flask import Flask, request
 2  
 3  
 4 app = Flask(__name__)
 5  
 6 @app.route('/')
 7  
 8 def hello_world():
 9  
10 return request.args.__str__()
11  
12  
13 if __name__ == '__main__':
14  
15 app.run(port=5000, debug=True)








在浏览器中访问http://127.0.0.1:5000/?user=Flask&time&p=7&p=8，将显示：




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




较新的浏览器也支持直接在url中输入中文（最新的火狐浏览器内部会帮忙将中文转换成符合URL规范的数据），在浏览器中访问http://127.0.0.1:5000/?info=这是爱，，将显示：




1 ImmutableMultiDict([('info', '这是爱，')])




浏览器传给我们的Flask服务的数据长什么样子呢？可以通过request.full_path和request.path来看一下：


 








 1 from flask import Flask, request
 2  
 3  
 4  
 5 app = Flask(__name__)
 6  
 7  
 8  
 9  
10  
11 @app.route('/')
12  
13 def hello_world():
14  
15 print(request.path)
16  
17 print(request.full_path)
18  
19 return request.args.__str__()
20  
21  
22  
23  
24  
25 if __name__ == '__main__':
26  
27 app.run(port=5000, debug=True)




 






 


浏览器访问http://127.0.0.1:5000/?info=这是爱，，运行server.py的终端会输出：








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








4.3 获取某个指定的参数


例如，要获取键info对应的值，如下修改server.py：








 1 from flask import Flask, request
 2  
 3  
 4  
 5 app = Flask(__name__)
 6  
 7  
 8  
 9 @app.route('/')
10  
11 def hello_world():
12  
13 return request.args.get('info')
14  
15  
16  
17 if __name__ == '__main__':
18  
19 app.run(port=5000)








运行server.py，在浏览器中访问http://127.0.0.1:5000/?info=hello，浏览器将显示：




1 hello




不过，当我们访问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  
 4  
 5 app = Flask(__name__)
 6  
 7  
 8  
 9 @app.route('/')
10  
11 def hello_world():
12  
13 r = request.args.get('info')
14  
15 if r==None:
16  
17 # do something
18  
19 return ''
20  
21 return r
22  
23  
24  
25 if __name__ == '__main__':
26  
27 app.run(port=5000, debug=True)








另外一个方法是，设置默认值，也就是取不到数据时用这个值：








 1 from flask import Flask, request
 2  
 3  
 4  
 5 app = Flask(__name__)
 6  
 7  
 8  
 9 @app.route('/')
10  
11 def hello_world():
12  
13 r = request.args.get('info', 'hi')
14  
15 return r
16  
17  
18  
19 if __name__ == '__main__':
20  
21 app.run(port=5000, debug=True)








函数request.args.get的第二个参数用来设置默认值。此时在浏览器访问http://127.0.0.1:5000/，将显示：






1 hi




4.4 如何处理多值


还记得上面有一次请求是这样的吗？ http://127.0.0.1:5000/?user=Flask&time&p=7&p=8，仔细看下，p有两个值。


如果我们的代码是：








 1 from flask import Flask, request
 2  
 3  
 4  
 5 app = Flask(__name__)
 6  
 7  
 8  
 9 @app.route('/')
10  
11 def hello_world():
12  
13 r = request.args.get('p')
14  
15 return r
16  
17  
18  
19 if __name__ == '__main__':
20  
21 app.run(port=5000, debug=True)








在浏览器中请求时，我们只会看到7。如果我们需要把p的所有值都获取到，该怎么办？


不用get，用getlist：








 1 from flask import Flask, request
 2  
 3  
 4  
 5 app = Flask(__name__)
 6  
 7  
 8  
 9  
10  
11 @app.route('/')
12  
13 def hello_world():
14  
15 r = request.args.getlist('p') # 返回一个list
16  
17 return str(r)
18  
19  
20  
21  
22  
23 if __name__ == '__main__':
24  
25 app.run(port=5000, debug=True)








浏览器输入 http://127.0.0.1:5000/?user=Flask&time&p=7&p=8，我们会看到['7', '8']。


4.5 本节源码


https://github.com/letiantian/Learn-Flask/tree/master/flask-demo-002


5. 获取POST方法传送的数据


作为一种HTTP请求方法，POST用于向指定的资源提交要被处理的数据。我们在某网站注册用户、写文章等时候，需要将数据传递到网站服务器中。并不适合将数据放到URL参数中，密码放到URL参数中容易被看到，文章数据又太多，浏览器不一定支持太长长度的URL。这时，一般使用POST方法。


本文使用python的requests库模拟浏览器。


安装方法：




1 $ sudo pip3 install requests




5.1 建立Flask项目


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








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








5.2 查看POST数据内容


以用户注册为例子，我们需要向服务器/register传送用户名name和密码password。如下编写HelloWorld/server.py。








 1 from flask import Flask, request
 2  
 3  
 4  
 5 app = Flask(__name__)
 6  
 7  
 8  
 9  
10  
11 @app.route('/')
12  
13 def hello_world():
14  
15 return 'hello world'
16  
17  
18  
19  
20  
21 @app.route('/register', methods=['POST'])
22  
23 def register():
24  
25 print(request.headers)
26  
27 print(request.stream.read())
28  
29 return 'welcome'
30  
31  
32  
33  
34  
35 if __name__ == '__main__':
36  
37 app.run(port=5000, debug=True)








@app.route(‘/register’, methods=[‘POST’])是指url/register只接受POST方法。可以根据需要修改methods`参数，例如如果想要让它同时支持GET和POST，这样写：




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




浏览器模拟工具client.py内容如下：








 1 import requests
 2  
 3  
 4  
 5 user_info = {'name': 'letian', 'password': '123'}
 6  
 7 r = requests.post("http://127.0.0.1:5000/register", data=user_info)
 8  
 9  
10  
11 print(r.text)








运行HelloWorld/server.py，然后运行client.py。client.py将输出：




1 welcome




而HelloWorld/server.py在终端中输出以下调试信息（通过print输出）：








 1 Host: 127.0.0.1:5000
 2  
 3 User-Agent: python-requests/2.19.1
 4  
 5 Accept-Encoding: gzip, deflate
 6  
 7 Accept: */*
 8  
 9 Connection: keep-alive
10  
11 Content-Length: 24
12  
13 Content-Type: application/x-www-form-urlencoded
14  
15  
16  
17  
18  
19 b'name=letian&password=123'








前6行是client.py生成的HTTP请求头，由print(request.headers)输出。


请求体的数据，我们通过print(request.stream.read())输出，结果是：




1 b'name=letian&password=123'




5.3 解析POST数据


上面，我们看到post的数据内容是：




1 b'name=letian&password=123'




我们要想办法把我们要的name、password提取出来，怎么做呢？自己写？不用，Flask已经内置了解析器request.form。


我们将服务代码改成：








 1 from flask import Flask, request
 2  
 3  
 4  
 5 app = Flask(__name__)
 6  
 7  
 8  
 9 @app.route('/')
10  
11 def hello_world():
12  
13 return 'hello world'
14  
15  
16  
17  
18  
19 @app.route('/register', methods=['POST'])
20  
21 def register():
22  
23 print(request.headers)
24  
25 # print(request.stream.read()) # 不要用，否则下面的form取不到数据
26  
27 print(request.form)
28  
29 print(request.form['name'])
30  
31 print(request.form.get('name'))
32  
33 print(request.form.getlist('name'))
34  
35 print(request.form.get('nickname', default='little apple'))
36  
37 return 'welcome'
38  
39  
40  
41  
42  
43 if __name__ == '__main__':
44  
45 app.run(port=5000, debug=True)








执行client.py请求数据，服务器代码会在终端输出：








 1 Host: 127.0.0.1:5000
 2  
 3 User-Agent: python-requests/2.19.1
 4  
 5 Accept-Encoding: gzip, deflate
 6  
 7 Accept: */*
 8  
 9 Connection: keep-alive
10  
11 Content-Length: 24
12  
13 Content-Type: application/x-www-form-urlencoded
14  
15  
16  
17  
18  
19 ImmutableMultiDict([('name', 'letian'), ('password', '123')])
20  
21 letian
22  
23 letian
24  
25 ['letian']
26  
27 little apple








request.form会自动解析数据。


request.form['name']和request.form.get('name')都可以获取name对应的值。对于request.form.get()可以为参数default指定值以作为默认值。所以：




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




输出的是默认值




1 little apple




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








 1 import requests
 2  
 3  
 4  
 5 user_info = {'name': ['letian', 'letian2'], 'password': '123'}
 6  
 7 r = requests.post("http://127.0.0.1:5000/register", data=user_info)
 8  
 9  
10  
11 print(r.text)








此时运行client.py，print(request.form.getlist('name'))将输出：




1 [u'letian', u'letian2']




5.4 本节源码


https://github.com/letiantian/Learn-Flask/tree/master/flask-demo-003


6. 处理和响应JSON数据


使用 HTTP POST 方法传到网站服务器的数据格式可以有很多种，比如「5. 获取POST方法传送的数据」讲到的name=letian&password=123这种用过&符号分割的key-value键值对格式。我们也可以用JSON格式、XML格式。相比XML的重量、规范繁琐，JSON显得非常小巧和易用。


6.1 建立Flask项目


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








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








6.2 处理JSON格式的请求数据


如果POST的数据是JSON格式，request.json会自动将json数据转换成Python类型（字典或者列表）。


编写server.py:








 1 from flask import Flask, request
 2  
 3  
 4  
 5 app = Flask("my-app")
 6  
 7  
 8  
 9  
10  
11 @app.route('/')
12  
13 def hello_world():
14  
15 return 'Hello World!'
16  
17  
18  
19  
20  
21 @app.route('/add', methods=['POST'])
22  
23 def add():
24  
25 print(request.headers)
26  
27 print(type(request.json))
28  
29 print(request.json)
30  
31 result = request.json['a'] + request.json['b']
32  
33 return str(result)
34  
35  
36  
37  
38  
39 if __name__ == '__main__':
40  
41 app.run(host='127.0.0.1', port=5000, debug=True)








编写client.py模拟浏览器请求：








 1 import requests
 2  
 3  
 4  
 5 json_data = {'a': 1, 'b': 2}
 6  
 7  
 8  
 9 r = requests.post("http://127.0.0.1:5000/add", json=json_data)
10  
11  
12  
13 print(r.text)








运行server.py，然后运行client.py，client.py 会在终端输出：






3




server.py 会在终端输出：






 1  
 2 Host: 127.0.0.1:5000
 3  
 4 User-Agent: python-requests/2.19.1
 5  
 6 Accept-Encoding: gzip, deflate
 7  
 8 Accept: */*
 9  
10 Connection: keep-alive
11  
12 Content-Length: 16
13  
14 Content-Type: application/json
15  
16  
17  
18  
19  
20 <class 'dict'>
21  
22 {'a': 1, 'b': 2}






注意，请求头中Content-Type的值是application/json。


6.3 响应JSON-方案1


响应JSON时，除了要把响应体改成JSON格式，响应头的Content-Type也要设置为application/json。


编写server2.py：








 1 from flask import Flask, request, Response
 2  
 3 import json
 4  
 5  
 6  
 7 app = Flask("my-app")
 8  
 9  
10  
11  
12  
13 @app.route('/')
14  
15 def hello_world():
16  
17 return 'Hello World!'
18  
19  
20  
21  
22  
23 @app.route('/add', methods=['POST'])
24  
25 def add():
26  
27 result = {'sum': request.json['a'] + request.json['b']}
28  
29 return Response(json.dumps(result), mimetype='application/json')
30  
31  
32  
33  
34  
35 if __name__ == '__main__':
36  
37 app.run(host='127.0.0.1', port=5000, debug=True)








修改后运行。


编写client2.py：








 1 import requests
 2  
 3  
 4  
 5 json_data = {'a': 1, 'b': 2}
 6  
 7  
 8  
 9 r = requests.post("http://127.0.0.1:5000/add", json=json_data)
10  
11  
12  
13 print(r.headers)
14  
15 print(r.text)








运行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  
3 {"sum": 3}








上面第一段内容是服务器的响应头，第二段内容是响应体，也就是服务器返回的JSON格式数据。


另外，如果需要服务器的HTTP响应头具有更好的可定制性，比如自定义Server，可以如下修改add()函数：








 1 @app.route('/add', methods=['POST'])
 2  
 3 def add():
 4  
 5 result = {'sum': request.json['a'] + request.json['b']}
 6  
 7 resp = Response(json.dumps(result), mimetype='application/json')
 8  
 9 resp.headers.add('Server', 'python flask')
10  
11 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  
3 {"sum": 3}








6.4 响应JSON-方案2


使用 jsonify 工具函数即可。








 1 from flask import Flask, request, jsonify
 2  
 3  
 4  
 5 app = Flask("my-app")
 6  
 7  
 8  
 9  
10  
11 @app.route('/')
12  
13 def hello_world():
14  
15 return 'Hello World!'
16  
17  
18  
19  
20  
21 @app.route('/add', methods=['POST'])
22  
23 def add():
24  
25 result = {'sum': request.json['a'] + request.json['b']}
26  
27 return jsonify(result)
28  
29  
30  
31  
32  
33 if __name__ == '__main__':
34  
35 app.run(host='127.0.0.1', port=5000, debug=True)








6.5 本节源码


https://github.com/letiantian/Learn-Flask/tree/master/flask-demo-004


7. 上传文件


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


7.1 建立Flask项目


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








1 mkdir HelloWorld
2  
3 mkdir HelloWorld/static
4  
5 mkdir HelloWorld/templates
6  
7 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：




1 mkdir HelloWorld/static/uploads




werkzeug库可以判断文件名是否安全，例如防止文件名是../../../a.png，安装这个库：




1 $ sudo pip3 install werkzeug




server.py代码：








 1 from flask import Flask, request
 2  
 3  
 4  
 5 from werkzeug.utils import secure_filename
 6  
 7 import os
 8  
 9  
10  
11 app = Flask(__name__)
12  
13  
14  
15 # 文件上传目录
16  
17 app.config['UPLOAD_FOLDER'] = 'static/uploads/'
18  
19 # 支持的文件格式
20  
21 app.config['ALLOWED_EXTENSIONS'] = {'png', 'jpg', 'jpeg', 'gif'} # 集合类型
22  
23  
24  
25  
26  
27 # 判断文件名是否是我们支持的格式
28  
29 def allowed_file(filename):
30  
31 return '.' in filename and \
32  
33 filename.rsplit('.', 1)[1] in app.config['ALLOWED_EXTENSIONS']
34  
35  
36  
37  
38  
39 @app.route('/')
40  
41 def hello_world():
42  
43 return 'hello world'
44  
45  
46  
47  
48  
49 @app.route('/upload', methods=['POST'])
50  
51 def upload():
52  
53 upload_file = request.files['image']
54  
55 if upload_file and allowed_file(upload_file.filename):
56  
57 filename = secure_filename(upload_file.filename)
58  
59 # 将文件保存到 static/uploads 目录，文件名同上传时使用的文件名
60  
61 upload_file.save(os.path.join(app.root_path, app.config['UPLOAD_FOLDER'], filename))
62  
63 return 'info is '+request.form.get('info', '')+'. success'
64  
65 else:
66  
67 return 'failed'
68  
69  
70  
71  
72  
73 if __name__ == '__main__':
74  
75 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：








 1 import requests
 2  
 3  
 4  
 5 file_data = {'image': open('Lenna.jpg', 'rb')}
 6  
 7  
 8  
 9 user_info = {'info': 'Lenna'}
10  
11  
12  
13 r = requests.post("http://127.0.0.1:5000/upload", data=user_info, files=file_data)
14  
15  
16  
17 print(r.text)








运行client.py，当前目录下的Lenna.jpg将上传到服务器。


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


要控制上产文件的大小，可以设置请求实体的大小，例如：




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




不过，在处理上传文件时候，需要使用try:...except:...。


如果要获取上传文件的内容可以：




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




7.3 本节源码


https://github.com/letiantian/Learn-Flask/tree/master/flask-demo-005


8. Restful URL


简单来说，Restful URL可以看做是对 URL 参数的替代。


8.1 建立Flask项目


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








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








8.2 编写代码


编辑server.py：








 1 from flask import Flask
 2  
 3  
 4  
 5 app = Flask(__name__)
 6  
 7  
 8  
 9  
10  
11 @app.route('/')
12  
13 def hello_world():
14  
15 return 'hello world'
16  
17  
18  
19  
20  
21 @app.route('/user/<username>')
22  
23 def user(username):
24  
25 print(username)
26  
27 print(type(username))
28  
29 return 'hello ' + username
30  
31  
32  
33  
34  
35 @app.route('/user/<username>/friends')
36  
37 def user_friends(username):
38  
39 print(username)
40  
41 print(type(username))
42  
43 return 'hello ' + username
44  
45  
46  
47  
48  
49 if __name__ == '__main__':
50  
51 app.run(port=5000, debug=True)








运行HelloWorld/server.py。使用浏览器访问http://127.0.0.1:5000/user/letian，HelloWorld/server.py将输出：








1 letian
2  
3 <class 'str'>








而访问http://127.0.0.1:5000/user/letian/，响应为404 Not Found。


浏览器访问http://127.0.0.1:5000/user/letian/friends，可以看到：




1 Hello letian. They are your friends.




HelloWorld/server.py输出：








1 letian
2  
3 <class 'str'>








8.3 转换类型


由上面的示例可以看出，使用 Restful URL 得到的变量默认为str对象。如果我们需要通过分页显示查询结果，那么需要在url中有数字来指定页数。按照上面方法，可以在获取str类型页数变量后，将其转换为int类型。不过，还有更方便的方法，就是用flask内置的转换机制，即在route中指定该如何转换。


新的服务器代码：








 1 from flask import Flask
 2  
 3  
 4  
 5 app = Flask(__name__)
 6  
 7  
 8  
 9  
10  
11 @app.route('/')
12  
13 def hello_world():
14  
15 return 'hello world'
16  
17  
18  
19  
20  
21 @app.route('/page/<int:num>')
22  
23 def page(num):
24  
25 print(num)
26  
27 print(type(num))
28  
29 return 'hello world'
30  
31  
32  
33  
34  
35 if __name__ == '__main__':
36  
37 app.run(port=5000, debug=True)








@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个默认的转换器：








1 int accepts integers
2  
3 float like int but for floating point values
4  
5 path like the default but also accepts slashes








看起来够用了。


8.4 一个有趣的用法


如下编写服务器代码：








 1 from flask import Flask
 2  
 3  
 4  
 5 app = Flask(__name__)
 6  
 7  
 8  
 9  
10  
11 @app.route('/')
12  
13 def hello_world():
14  
15 return 'hello world'
16  
17  
18  
19  
20  
21 @app.route('/page/<int:num1>-<int:num2>')
22  
23 def page(num1, num2):
24  
25 print(num1)
26  
27 print(num2)
28  
29 return 'hello world'
30  
31  
32  
33  
34  
35 if __name__ == '__main__':
36  
37 app.run(port=5000, debug=True)








在浏览器中访问http://127.0.0.1:5000/page/11-22，HelloWorld/server.py会输出：






1 11
2  
3 22






8.5 编写转换器


自定义的转换器是一个继承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  
 4  
 5 from werkzeug.routing import BaseConverter
 6  
 7  
 8  
 9  
10  
11 class MyIntConverter(BaseConverter):
12  
13  
14  
15 def __init__(self, url_map):
16  
17 super(MyIntConverter, self).__init__(url_map)
18  
19  
20  
21 def to_python(self, value):
22  
23 return int(value)
24  
25  
26  
27 def to_url(self, value):
28  
29 return value * 2
30  
31  
32  
33  
34  
35 app = Flask(__name__)
36  
37 app.url_map.converters['my_int'] = MyIntConverter
38  
39  
40  
41  
42  
43 @app.route('/')
44  
45 def hello_world():
46  
47 return 'hello world'
48  
49  
50  
51  
52  
53 @app.route('/page/<my_int:num>')
54  
55 def page(num):
56  
57 print(num)
58  
59 print(url_for('page', num=123)) # page 对应的是 page函数 ，num 对应对应`/page/<my_int:num>`中的num，必须是str
60  
61 return 'hello world'
62  
63  
64  
65  
66  
67 if __name__ == '__main__':
68  
69 app.run(port=5000, debug=True)








浏览器访问http://127.0.0.1:5000/page/123后，HelloWorld/server.py的输出信息是：








1 123
2  
3 /page/123123








8.6 本节源码


https://github.com/letiantian/Learn-Flask/tree/master/flask-demo-006


8.7 值得读


理解RESTful架构。


9. 使用url_for生成链接


工具函数url_for可以让你以软编码的形式生成url，提供开发效率。


9.1 建立Flask项目


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








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








9.2 编写代码


编辑HelloWorld/server.py：








 1 from flask import Flask, url_for
 2  
 3  
 4  
 5 app = Flask(__name__)
 6  
 7  
 8  
 9 @app.route('/')
10  
11 def hello_world():
12  
13 pass
14  
15  
16  
17 @app.route('/user/<name>')
18  
19 def user(name):
20  
21 pass
22  
23  
24  
25 @app.route('/page/<int:num>')
26  
27 def page(num):
28  
29 pass
30  
31  
32  
33 @app.route('/test')
34  
35 def test():
36  
37 print(url_for('hello_world'))
38  
39 print(url_for('user', name='letian'))
40  
41 print(url_for('page', num=1, q='hadoop mapreduce 10%3'))
42  
43 print(url_for('static', filename='uploads/01.jpg'))
44  
45 return 'Hello'
46  
47  
48  
49 if __name__ == '__main__':
50  
51 app.run(debug=True)








运行HelloWorld/server.py。然后在浏览器中访问http://127.0.0.1:5000/test，HelloWorld/server.py将输出以下信息：








1 /
2  
3 /user/letian
4  
5 /page/1?q=hadoop+mapreduce+10%253
6  
7 /static/uploads/01.jpg








9.3 本节源码


https://github.com/letiantian/Learn-Flask/tree/master/flask-demo-007


10. 使用redirect重定向网址


redirect函数用于重定向，实现机制很简单，就是向客户端（浏览器）发送一个重定向的HTTP报文，浏览器会去访问报文中指定的url。


10.1 建立Flask项目


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






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






10.2 编写代码


使用redirect时，给它一个字符串类型的参数就行了。


编辑HelloWorld/server.py：








 1 from flask import Flask, url_for, redirect
 2  
 3  
 4  
 5 app = Flask(__name__)
 6  
 7  
 8  
 9 @app.route('/')
10  
11 def hello_world():
12  
13 return 'hello world'
14  
15  
16  
17 @app.route('/test1')
18  
19 def test1():
20  
21 print('this is test1')
22  
23 return redirect(url_for('test2'))
24  
25  
26  
27 @app.route('/test2')
28  
29 def test2():
30  
31 print('this is test2')
32  
33 return 'this is test2'
34  
35  
36  
37 if __name__ == '__main__':
38  
39 app.run(debug=True)








运行HelloWorld/server.py，在浏览器中访问http://127.0.0.1:5000/test1，浏览器的url会变成http://127.0.0.1:5000/test2，并显示：




1 this is test2




10.3 本节源码


https://github.com/letiantian/Learn-Flask/tree/master/flask-demo-008


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:








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








11.2 创建并编辑HelloWorld/templates/default.html


内容如下：








 1 <html>
 2  
 3 <head>
 4  
 5 <title>
 6  
 7 {% if page_title %}
 8  
 9 {{ page_title }}
10  
11 {% endif %}
12  
13 </title>
14  
15 </head>
16  
17  
18  
19 <body>
20  
21 {% block body %}{% endblock %}
22  
23  
24  
25  
26  
27 ```
28  
29 可以看到，在``标签中使用了if判断，如果给模板传递了`page_title`变量，显示之，否则，不显示。
30  
31 ``标签中定义了一个名为`body`的block，用来被其他模板文件继承。
32 ### 11.3 创建并编辑HelloWorld/templates/user_info.html
33  
34 内容如下：
35  
36  
37  
38 ```
39  
40 {% extends "default.html" %}
41  
42  
43 {% block body %}
44  
45 {% for key in user_info %}
46  
47  
48 {{ key }}: {{ user_info[key] }}
49  
50  
51 {% endfor %}
52  
53 {% endblock %}








变量user_info应该是一个字典，for循环用来循环输出键值对。


11.4 编辑HelloWorld/server.py


内容如下：








 1 from flask import Flask, render_template
 2  
 3  
 4  
 5 app = Flask(__name__)
 6  
 7  
 8  
 9  
10  
11 @app.route('/')
12  
13 def hello_world():
14  
15 return 'hello world'
16  
17  
18  
19  
20  
21 @app.route('/user')
22  
23 def user():
24  
25 user_info = {
26  
27 'name': 'letian',
28  
29 'email': '123@aa.com',
30  
31 'age':0,
32  
33 'github': 'https://github.com/letiantian'
34  
35 }
36  
37 return render_template('user_info.html', page_title='letian\'s info', user_info=user_info)
38  
39  
40  
41  
42  
43 if __name__ == '__main__':
44  
45 app.run(port=5000, debug=True)








render_template()函数的第一个参数指定模板文件，后面的参数是要传递的数据。


11.5 运行与测试


运行HelloWorld/server.py：




1 $ python3 HelloWorld/server.py




在浏览器中访问http://127.0.0.1:5000/user，效果图如下：




查看网页源码：


 








 1 <html>
 2  
 3 <head>
 4  
 5 <title>
 6  
 7 letian&#39;s info
 8  
 9 </title>
10  
11 </head>
12  
13 <body>
14  
15 name: letian <br/>
16  
17 email: 123@aa.com <br/>
18  
19 age: 0 <br/>
20  
21 github: https://github.com/letiantian <br/>
22  
23 </body>
24  
25 </html>








 


11.6 本节源码


https://github.com/letiantian/Learn-Flask/tree/master/flask-demo-009


12. 自定义404等错误的响应


要处理HTTP错误，可以使用flask.abort函数。


12.1 示例1：简单入门


建立Flask项目


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


 








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








 


代码


编辑HelloWorld/server.py：


 








 1 from flask import Flask, render_template_string, abort
 2  
 3  
 4  
 5 app = Flask(__name__)
 6  
 7  
 8  
 9  
10  
11 @app.route('/')
12  
13 def hello_world():
14  
15 return 'hello world'
16  
17  
18  
19  
20  
21 @app.route('/user')
22  
23 def user():
24  
25 abort(401) # Unauthorized 未授权
26  
27 print('Unauthorized, 请先登录')
28  
29  
30  
31  
32  
33 if __name__ == '__main__':
34  
35 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：自定义错误页面


代码


将服务器代码改为：


 








 1 from flask import Flask, render_template_string, abort
 2  
 3  
 4  
 5 app = Flask(__name__)
 6  
 7  
 8  
 9  
10  
11 @app.route('/')
12  
13 def hello_world():
14  
15 return 'hello world'
16  
17  
18  
19  
20  
21 @app.route('/user')
22  
23 def user():
24  
25 abort(401) # Unauthorized
26  
27  
28  
29  
30  
31 @app.errorhandler(401)
32  
33 def page_unauthorized(error):
34  
35 return render_template_string('<h1> Unauthorized </h1><h2>{{ error_info }}</h2>', error_info=error), 401
36  
37  
38  
39  
40  
41 if __name__ == '__main__':
42  
43 app.run(port=5000, debug=True)








 


page_unauthorized函数返回的是一个元组，401 代表HTTP 响应状态码。如果省略401，则响应状态码会变成默认的 200。


效果


运行HelloWorld/server.py，浏览器访问http://127.0.0.1:5000/user，效果如下：




12.3 本节源码


https://github.com/letiantian/Learn-Flask/tree/master/flask-demo-010


13. 用户会话


session用来记录用户的登录状态，一般基于cookie实现。


下面是一个简单的示例。


13.1 建立Flask项目


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


 








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








 


13.2 编辑HelloWorld/server.py


内容如下：


 








 1 from flask import Flask, render_template_string, \
 2  
 3 session, request, redirect, url_for
 4  
 5  
 6  
 7 app = Flask(__name__)
 8  
 9  
10  
11 app.secret_key = 'F12Zr47j\3yX R~X@H!jLwf/T'
12  
13  
14  
15  
16  
17 @app.route('/')
18  
19 def hello_world():
20  
21 return 'hello world'
22  
23  
24  
25  
26  
27 @app.route('/login')
28  
29 def login():
30  
31 page = '''
32  
33 <form action="{{ url_for('do_login') }}" method="post">
34  
35 <p>name: <input type="text" name="user_name" /></p>
36  
37 <input type="submit" value="Submit" />
38  
39 </form>
40  
41 '''
42  
43 return render_template_string(page)
44  
45  
46  
47  
48  
49 @app.route('/do_login', methods=['POST'])
50  
51 def do_login():
52  
53 name = request.form.get('user_name')
54  
55 session['user_name'] = name
56  
57 return 'success'
58  
59  
60  
61  
62  
63 @app.route('/show')
64  
65 def show():
66  
67 return session['user_name']
68  
69  
70  
71  
72  
73 @app.route('/logout')
74  
75 def logout():
76  
77 session.pop('user_name', None)
78  
79 return redirect(url_for('login'))
80  
81  
82  
83  
84  
85 if __name__ == '__main__':
86  
87 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?：








1 from datetime import timedelta
2  
3 from flask import session, app
4  
5  
6  
7 session.permanent = True
8  
9 app.permanent_session_lifetime = timedelta(minutes=5)








这段代码将session的有效时间设置为5分钟。


13.6 本节源码


https://github.com/letiantian/Learn-Flask/tree/master/flask-demo-011


14. 使用Cookie


Cookie是存储在客户端的记录访问者状态的数据。具体原理，请见 http://zh.wikipedia.org/wiki/Cookie 。 常用的用于记录用户登录状态的session大多是基于cookie实现的。


cookie可以借助flask.Response来实现。下面是一个示例。


14.1 建立Flask项目


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








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








14.2 代码


修改HelloWorld/server.py：








 1 from flask import Flask, request, Response, make_response
 2  
 3 import time
 4  
 5  
 6  
 7 app = Flask(__name__)
 8  
 9  
10  
11  
12  
13 @app.route('/')
14  
15 def hello_world():
16  
17 return 'hello world'
18  
19  
20  
21  
22  
23 @app.route('/add')
24  
25 def login():
26  
27 res = Response('add cookies')
28  
29 res.set_cookie(key='name', value='letian', expires=time.time()+6*60)
30  
31 return res
32  
33  
34  
35  
36  
37 @app.route('/show')
38  
39 def show():
40  
41 return request.cookies.__str__()
42  
43  
44  
45  
46  
47 @app.route('/del')
48  
49 def del_cookie():
50  
51 res = Response('delete cookies')
52  
53 res.set_cookie('name', '', expires=0)
54  
55 return res
56  
57  
58  
59  
60  
61 if __name__ == '__main__':
62  
63 app.run(port=5000, debug=True)








由上可以看到，可以使用Response.set_cookie添加和删除cookie。expires参数用来设置cookie有效时间，它的值可以是datetime对象或者unix时间戳，笔者使用的是unix时间戳。




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




上面的expire参数的值表示cookie在从现在开始的6分钟内都是有效的。


要删除cookie，将expire参数的值设为0即可：




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




1 $ python3 HelloWorld/server.py




使用浏览器打开http://127.0.0.1:5000/add，浏览器界面会显示




1 add cookies




下面查看一下cookie，如果使用firefox浏览器，可以用firebug插件查看。打开firebug，选择Cookies选项，刷新页面，可以看到名为name的cookie，其值为letian。


在“网络”选项中，可以查看响应头中类似下面内容的设置cookie的HTTP「指令」：




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




在cookie有效期间，使用浏览器访问http://127.0.0.1:5000/show，可以看到：




1 {'name': 'letian'}




14.4 本节源码


https://github.com/letiantian/Learn-Flask/tree/master/flask-demo-012


15. 闪存系统 flashing system


Flask的闪存系统（flashing system）用于向用户提供反馈信息，这些反馈信息一般是对用户上一次操作的反馈。反馈信息是存储在服务器端的，当服务器向客户端返回反馈信息后，这些反馈信息会被服务器端删除。


下面是一个示例。


15.1 建立Flask项目


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








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








15.2 编写HelloWorld/server.py


内容如下：








 1 from flask import Flask, flash, get_flashed_messages
 2  
 3 import time
 4  
 5  
 6  
 7 app = Flask(__name__)
 8  
 9 app.secret_key = 'some_secret'
10  
11  
12  
13  
14  
15 @app.route('/')
16  
17 def index():
18  
19 return 'hi'
20  
21  
22  
23  
24  
25 @app.route('/gen')
26  
27 def gen():
28  
29 info = 'access at '+ time.time().__str__()
30  
31 flash(info)
32  
33 return info
34  
35  
36  
37  
38  
39 @app.route('/show1')
40  
41 def show1():
42  
43 return get_flashed_messages().__str__()
44  
45  
46  
47  
48  
49 @app.route('/show2')
50  
51 def show2():
52  
53 return get_flashed_messages().__str__()
54  
55  
56  
57  
58  
59 if __name__ == "__main__":
60  
61 app.run(port=5000, debug=True)








15.3 效果


运行服务器：




1 $ python3 HelloWorld/server.py




打开浏览器，访问http://127.0.0.1:5000/gen，浏览器界面显示（注意，时间戳是动态生成的，每次都会不一样，除非并行访问）：




1 access at 1404020982.83




查看浏览器的cookie，可以看到session，其对应的内容是：




1 .eJyrVopPy0kszkgtVrKKrlZSKIFQSUpWSknhYVXJRm55UYG2tkq1OlDRyHC_rKgIvypPdzcDTxdXA1-XwHLfLEdTfxfPUn8XX6DKWCAEAJKBGq8.BpE6dg.F1VURZa7VqU9bvbC4XIBO9-3Y4Y




再一次访问http://127.0.0.1:5000/gen，浏览器界面显示：




1 access at 1404021130.32




cookie中session发生了变化，新的内容是：




1 .eJyrVopPy0kszkgtVrKKrlZSKIFQSUpWSknhYVXJRm55UYG2tkq1OlDRyHC_rKgIvypPdzcDTxdXA1-XwHLfLEdTfxfPUn8XX6DKWLBaMg1yrfCtciz1rfIEGxRbCwAhGjC5.BpE7Cg.Cb_B_k2otqczhknGnpNjQ5u4dqw




然后使用浏览器访问http://127.0.0.1:5000/show1，浏览器界面显示：




1 ['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，只会得到：




1 []




15.4 高级用法


flash系统也支持对flash的内容进行分类。修改HelloWorld/server.py内容：








 1 from flask import Flask, flash, get_flashed_messages
 2  
 3 import time
 4  
 5  
 6  
 7 app = Flask(__name__)
 8  
 9 app.secret_key = 'some_secret'
10  
11  
12  
13  
14  
15 @app.route('/')
16  
17 def index():
18  
19 return 'hi'
20  
21  
22  
23  
24  
25 @app.route('/gen')
26  
27 def gen():
28  
29 info = 'access at '+ time.time().__str__()
30  
31 flash('show1 '+info, category='show1')
32  
33 flash('show2 '+info, category='show2')
34  
35 return info
36  
37  
38  
39  
40  
41 @app.route('/show1')
42  
43 def show1():
44  
45 return get_flashed_messages(category_filter='show1').__str__()
46  
47  
48  
49 @app.route('/show2')
50  
51 def show2():
52  
53 return get_flashed_messages(category_filter='show2').__str__()
54  
55  
56  
57  
58  
59 if __name__ == "__main__":
60  
61 app.run(port=5000, debug=True)








某一时刻，浏览器访问http://127.0.0.1:5000/gen，浏览器界面显示：




1 access at 1404022326.39




不过，由上面的代码可以知道，此时生成了两个flash信息，但分类(category)不同。


使用浏览器访问http://127.0.0.1:5000/show1，得到如下内容：




1 ['1 access at 1404022326.39']




而继续访问http://127.0.0.1:5000/show2，得到的内容为空：




1 []




15.5 在模板文件中获取flash的内容


在Flask中，get_flashed_messages()默认已经集成到Jinja2模板引擎中，易用性很强。下面是来自官方的一个示例：




15.6 本节源码


https://github.com/letiantian/Learn-Flask/tree/master/flask-demo-013









            

            
posted @ 
2019-11-01 16:21 
稚人 
阅读(383) 
评论(0) 
 
收藏 
举报