本文目录一览：
- 1、如何理解Nginx，uWSGI和Flask之间的关系
- 2、使用flask开发的网站有哪些
- 3、flask 比 php 好在哪里
- 4、如何用 flask 优雅的实现 restful api
- 5、python轻量框架--Flask(入门教程）
如何理解Nginx，uWSGI和Flask之间的关系
总括来说，客户端从发送一个 HTTP 请求到 Flask 处理请求，分别经过了 web 服务器层，WSGI层，web框架层，这三个层次。不同的层次其作用也不同，下面简要介绍各层的作用。
图1：web服务器，web框架与 WSGI 的三层关系
Web服务器层
对于传统的客户端 – 服务器架构，其请求的处理过程是，客户端向服务器发送请求，服务器接收请求并处理请求，然后给客户端返回响应。在这个过程中，服务器的作用是：
接收请求
处理请求
返回响应
Web服务器是一类特殊的服务器，其作用是主要是接收 HTTP 请求并返回响应。提起 web服务器大家都不会陌生，常见的 web服务器有 Nginx，Apache，IIS等。在上图1的三层结构中，web服务器是最先接收用户请求的，并将响应结果返回给用户。
Web框架层
Web框架的作用主要是方便我们开发 web应用程序，HTTP请求的动态数据就是由 web框架层来提供的。常见的 web框架有Flask，Django等，我们以 Flask 框架为例子，展示 web框架的作用：
Python
from flask import Flask
app = Flask(__name__)
@app.route('/hello')
def hello_world():
return 'Hello World!'
if __name__ == '__main__':
app.run(host='0.0.0.0', port=8080)
1
2
3
4
5
6
7
from flask import Flask
app = Flask(__name__)
@app.route('/hello')
def hello_world():
return 'Hello World!'
if __name__ == '__main__':
app.run(host='0.0.0.0', port=8080)
以上简单的几行代码，就创建了一个 web应用程序对象 app。 app 监听机器所有 ip 的 8080
端口，接受用户的请求连接。我们知道，HTTP 协议使用 URL 来定位资源，上面的程序会将路径 /hello 的请求交由 hello_world
方法处理， hello_world 返回 ‘Hello World!’ 字符串。对于 web框架的使用者来说，他们并不关心如何接收 HTTP
请求，也不关心如何将请求路由到具体方法处理并将响应结果返回给用户。Web框架的使用者在大部分情况下，只需要关心如何实现业务的逻辑即可。
WSGI层
WSGI 不是服务器，也不是用于与程序交互的API，更不是真实的代码，WSGI 只是一种接口,它只适用于 Python 语言，其全称为
Web Server Gateway Interface，定义了 web服务器和 web应用之间的接口规范。也就是说，只要 web服务器和
web应用都遵守WSGI协议，那么 web服务器和 web应用就可以随意的组合。
下面的代码展示了 web服务器是如何与 web应用组合在一起的
Python
def application(env, start_response):
start_response('200 OK', [('Content-Type', 'text/html')])
return [b"Hello World"]
1
2
3
def application(env, start_response):
start_response('200 OK', [('Content-Type', 'text/html')])
return [b"Hello World"]
方法 application由 web服务器调用，参数 env， start_response 由 web服务器实现并传入。其中，
env是一个字典，包含了类似 HTTPHOST，HOSTUSERAGENT，SERVERPROTOCO 等环境变量。
start_response则是一个方法，该方法接受两个参数，分别是 status， response_headers。
application方法的主要作用是，设置 http 响应的状态码和 Content-Type 等头部信息，并返回响应的具体结果。
上述代码就是一个完整的 WSGI 应用，当一个支持 WSGI 的 web服务器接收到客户端的请求后，便会调用这个 application
方法。WSGI 层并不需要关心 env， start_response 这两个变量是如何实现的，就像在 application
里面所做的，直接使用这两个变量即可。
值得指出的是，WSGI 是一种协议，需要区分几个相近的名词：
uwsgi：同 wsgi 一样也是一种协议，uWSGI服务器正是使用了 uwsgi 协议
uWSGI：实现了 uwsgi 和 WSGI 两种协议的web服务器。注意 uWSGI 本质上也是一种 web服务器，处于上面描述的三层结构中的 web服务器层。
CGI：通用网关接口，并不限于 Python 语言，定义了 web服务器是如何向客户端提供动态的内容。例如，规定了客户端如何将参数传递给 web服务器，web服务器如何将参数传递给 web应用，web应用如何将它的输出如何发送给客户端，等等。
生产环境下的 web应用都不使用 CGI 了，CGI进程（类似 Python 解释器）针对每个请求创建，用完就抛弃，效率低下。WSGI 正是为了替代 CGI 而出现的。
说到这，我们基本理清了 WSGI 在 web服务器与 web框架之间作用：WSGI 就像一条纽带，将 web服务器与
web框架连接起来。回到本文的题目，Nginx 属于一种 web服务器，Flask属于一种 web框架，因此，WSGI 与
Nginx、Flask 的作用就不明而喻了。
Nginx，WSGI，Flask 之间的对话
Nginx：Hey，WSGI，我刚收到了一个请求，我需要你作些准备，然后由Flask来处理这个请求。
WSGI：OK，Nginx。我会设置好环境变量，然后将这个请求传递给Flask处理。
Flask：Thanks WSGI！给我一些时间，我将会把请求的响应返回给你。
WSGI：Alright，那我等你。
Flask：Okay，我完成了，这里是请求的响应结果，请求把结果传递给Nginx。 WSGI：Good job！
Nginx，这里是响应结果，已经按照要求给你传递回来了。
Nginx：Cool，我收到了，我把响应结果返回给客户端。大家合作愉快~
使用flask开发的网站有哪些
Python 生态圈有两个现象级的 Web 框架 Flask, Django.
两个框架风格迥异, 但是都各自带动了庞大的生态圈, 这得益于二者灵活的扩展能力.
本书讲述的是基于 Flask 开发 Web 项目.
在对 Flask 框架的各个部分简要分析后, 本书介绍了
* 表单处理(Flask-WTF)
* 持久化(Flask-SQLAlchemy, 这货作者就是 Flask 的作者哟)
* 邮件
* 配置
* 一个真实案例: 模型, 用户验证, 角色, 关注, 写template, 写API
# 特点
* 线程局部变量
我不知道该把这个称作特点还是缺点.
至少在Flask的文档中作者明确给出这样的解释: 作为一个码农, 你也许会感到不适, 但我就想这样设计.
大部分的 Web 框架, 请求对象是外部注入的, 唯独 Flask 选择了全局 (flask.request, flask.g).
这个特点存在意味着你要小心使用这个特性, 否则很容易遇上需要调试大半天的Bug.
另外, request 不是那么容易造出来的.
不过, 这不是什么大不了的事情.
这个顺便波及到测试, 测试的setup 与 teardown, 你必须去营造一个上下文, 关于这点, 书中有讲解如何操作.
* Route/Template
框架的路由使用的是Werkzeug.
Template使用的是Jinja2, 当然不喜欢的话, 用别的也很简单.
* 足够小
Flask 只封装了请求, 路由, 模板这么几个功能.
用起来容易, 要写好也得费点脑子涨点经验才行.
说穿了也就是一句话:
The idea of Flask is to build a good foundation for all applications.
Everything else is up to you or extensions.
[Ref: What Flask is, What Flask is Not]()
# 工作流
常规的三板斧: 开发, 测试, 部署.
书里面的部署和配置这两章节讲的很出色, 值得一读, 我给打五星.
# 插件
借用 @死鱼眼28号 常说的一句话, 很多 Flask 插件都写得很渣.
我表示 +1.
挑选插件时记得看下插件源码, 给作者的码力打个分再决定要不要用.
# 后记
关于 Web 开发, 我们的选择有很多:
* PHP(Laravel, CodeIgniter, Yii, Symfony, CakePHP, etc.)
* Ruby(RoR, Sinatra, etc.)
* Python(Flask, Django, Quixote, Web.py, Bottle, etc.)
* Java/Scala(Spring, Play!, etc.)
殊途同归, 他们也给出了几乎一样的解决方案.
我们可以看到大部分的 Web 项目都有着类似的目录分类, 类似的架构.
Flask 也不外乎如此: 帮你包装好请求对象, 剩下的路由, 路由逻辑, 响应内容你来填.
上面大部分框架从大学到工作或多或少使用过, 其实真正写到业务层面时, 框架那些都不是事儿.
你想要的东西, 或框架自己造, 或怂恿队友帮你造, 或你自己造, 总之基本上你总能拿到你要的信息.
不要被框架局限了视野哟.
flask 比 php 好在哪里
flask 是python的一个框架
而php是一种编辑语言
你来告诉我：怎么比？
如何用 flask 优雅的实现 restful api
首先，安装Flask
pip install flask
阅读这篇文章之前我假设你已经了解RESTful API的相关概念，如果不清楚，可以阅读我之前写的这篇博客[Designing a RESTful Web API
Flask是一个使用Python开发的基于Werkzeug的Web框架。
Flask非常适合于开发RESTful API，因为它具有以下特点：
?使用Python进行开发，Python简洁易懂
?容易上手
?灵活
?可以部署到不同的环境
?支持RESTful请求分发
我一般是用curl命令进行测试，除此之外，还可以使用Chrome浏览器的postman扩展。
资源
首先，我创建一个完整的应用，支持响应/, /articles以及/article/:id。
from flask import Flask, url_for
app = Flask(__name__)
@app.route('/')
def api_root():
return 'Welcome'
@app.route('/articles')
def api_articles():
return 'List of ' + url_for('api_articles')
@app.route('/articles/articleid')
def api_article(articleid):
return 'You are reading ' + articleid
if __name__ == '__main__':
app.run()
可以使用curl命令发送请求：
响应结果分别如下所示：
GET /
Welcome
GET /articles
List of /articles
GET /articles/123
You are reading 123
路由中还可以使用类型定义:
@app.route('/articles/articleid')
上面的路由可以替换成下面的例子：
@app.route('/articles/int:articleid')
@app.route('/articles/float:articleid')
@app.route('/articles/path:articleid')
默认的类型为字符串。
请求
请求参数
假设需要响应一个/hello请求，使用get方法，并传递参数name
from flask import request
@app.route('/hello')
def api_hello():
if 'name' in request.args:
return 'Hello ' + request.args['name']
else:
return 'Hello John Doe'
服务器会返回如下响应信息：
GET /hello
Hello John Doe
GET /hello?name=Luis
Hello Luis
请求方法
Flask支持不同的请求方法：
@app.route('/echo', methods = ['GET', 'POST', 'PATCH', 'PUT', 'DELETE'])
def api_echo():
if request.method == 'GET':
return "ECHO: GET\n"
elif request.method == 'POST':
return "ECHO: POST\n"
elif request.method == 'PATCH':
return "ECHO: PACTH\n"
elif request.method == 'PUT':
return "ECHO: PUT\n"
elif request.method == 'DELETE':
return "ECHO: DELETE"
可以使用如下命令进行测试:
curl -X PATCH :5000/echo
不同请求方法的响应如下：
GET /echo
ECHO: GET
POST /ECHO
ECHO: POST
...
请求数据和请求头
通常使用POST方法和PATCH方法的时候，都会发送附加的数据，这些数据的格式可能如下：普通文本(plain text)， JSON，XML，二进制文件或者用户自定义格式。
Flask中使用request.headers类字典对象来获取请求头信息，使用request.data 获取请求数据，如果发送类型是application/json，则可以使用request.get_json()来获取JSON数据。
from flask import json
@app.route('/messages', methods = ['POST'])
def api_message():
if request.headers['Content-Type'] == 'text/plain':
return "Text Message: " + request.data
elif request.headers['Content-Type'] == 'application/json':
return "JSON Message: " + json.dumps(request.json)
elif request.headers['Content-Type'] == 'application/octet-stream':
f = open('./binary', 'wb')
f.write(request.data)
f.close()
return "Binary message written!"
else:
return "415 Unsupported Media Type ;)"
使用如下命令指定请求数据类型进行测试：
curl -H "Content-type: application/json" \
-X POST :5000/messages -d '{"message":"Hello Data"}'
使用下面的curl命令来发送一个文件:
curl -H "Content-type: application/octet-stream" \
-X POST :5000/messages --data-binary @message.bin
不同数据类型的响应结果如下所示：
POST /messages {"message": "Hello Data"}
Content-type: application/json
JSON Message: {"message": "Hello Data"}
POST /message message.bin
Content-type: application/octet-stream
Binary message written!
注意Flask可以通过request.files获取上传的文件，curl可以使用-F选项模拟上传文件的过程。
响应
Flask使用Response类处理响应。
from flask import Response
@app.route('/hello', methods = ['GET'])
def api_hello():
data = {
'hello' : 'world',
'number' : 3
}
js = json.dumps(data)
resp = Response(js, status=200, mimetype='application/json')
resp.headers['Link'] = ''
return resp
使用-i选项可以获取响应信息：
curl -i :5000/hello
返回的响应信息如下所示：
GET /hello
HTTP/1.0 200 OK
Content-Type: application/json
Content-Length: 31
Link:
Server: Werkzeug/0.8.2 Python/2.7.1
Date: Wed, 25 Apr 2012 16:40:27 GMT
{"hello": "world", "number": 3}
mimetype指定了响应数据的类型。
上面的过程可以使用Flask提供的一个简便方法实现：
from flask import jsonify
...
# 将下面的代码替换成
resp = Response(js, status=200, mimetype='application/json')
# 这里的代码
resp = jsonify(data)
resp.status_code = 200
状态码和错误处理
如果成功响应的话，状态码为200。对于404错误我们可以这样处理：
@app.errorhandler(404)
def not_found(error=None):
message = {
'status': 404,
'message': 'Not Found: ' + request.url,
}
resp = jsonify(message)
resp.status_code = 404
return resp
@app.route('/users/userid', methods = ['GET'])
def api_users(userid):
users = {'1':'john', '2':'steve', '3':'bill'}
if userid in users:
return jsonify({userid:users[userid]})
else:
return not_found()
测试上面的两个URL，结果如下：
GET /users/2
HTTP/1.0 200 OK
{
"2": "steve"
}
GET /users/4
HTTP/1.0 404 NOT FOUND
{
"status": 404,
"message": "Not Found: :5000/users/4"
}
默认的Flask错误处理可以使用@error_handler修饰器进行覆盖或者使用下面的方法：
app.error_handler_spec[None][404] = not_found
即使API不需要自定义错误信息，最好还是像上面这样做，因为Flask默认返回的错误信息是HTML格式的。
认证
使用下面的代码可以处理 HTTP Basic Authentication。
from functools import wraps
def check_auth(username, password):
return username == 'admin' and password == 'secret'
def authenticate():
message = {'message': "Authenticate."}
resp = jsonify(message)
resp.status_code = 401
resp.headers['WWW-Authenticate'] = 'Basic realm="Example"'
return resp
def requires_auth(f):
@wraps(f)
def decorated(*args, **kwargs):
auth = request.authorization
if not auth:
return authenticate()
elif not check_auth(auth.username, auth.password):
return authenticate()
return f(*args, **kwargs)
return decorated
接下来只需要给路由增加@require_auth修饰器就可以在请求之前进行认证了：
@app.route('/secrets')
@requires_auth
def api_hello():
return "Shhh this is top secret spy stuff!"
现在，如果没有通过认证的话，响应如下所示：
GET /secrets
HTTP/1.0 401 UNAUTHORIZED
WWW-Authenticate: Basic realm="Example"
{
"message": "Authenticate."
}
curl通过-u选项来指定HTTP basic authentication，使用-v选项打印请求头：
curl -v -u "admin:secret"
响应结果如下：
GET /secrets Authorization: Basic YWRtaW46c2VjcmV0
Shhh this is top secret spy stuff!
Flask使用MultiDict来存储头部信息，为了给客户端展示不同的认证机制，可以给header添加更多的WWW-Autheticate。
resp.headers['WWW-Authenticate'] = 'Basic realm="Example"'resp.headers.add('WWW-Authenticate', 'Bearer realm="Example"')
调试与日志
通过设置debug=True来开启调试信息：
app.run(debug=True)
使用Python的logging模块可以设置日志信息：
import logging
file_handle('app.log')
app.logger.addHandler(file_handler)
app.logger.setLevel(logging.INFO)
@app.route('/hello', methods = ['GET'])
def api_hello():
app.logger.info('informing')
app.logger.warning('warning')
app.logger.error('screaming bloody murder!')
return "check your logs\n"
CURL 命令参考
选项
作用
-X 指定HTTP请求方法，如POST，GET
-H 指定请求头，例如Content-type:application/json
-d 指定请求数据
--data-binary 指定发送的文件
-i 显示响应头部信息
-u 指定认证用户名与密码
-v 输出请求头部信息
python轻量框架--Flask(入门教程）
1.建立： F:\Python\flask文件夹路径
2.安装virtualenv,在此路径下打开命令行窗口输入：
3.新建一个目录，并在里边创建virtualenv环境，在DOS下
如图：
这时你创建的myproject文件夹里面就多了一个venv文件夹：
4.激活虚拟环境
现在命令行前面多了个(venv)表示你在venv环境内
5.在virtualenv里安装Flask
完成。如图：
6.验证是否安装，你可以进入 Python 解释器，尝试导入 Flask：
如果没有报错，那么就安装成功了~如图：
1.在myproject文件夹下打开命令行：
cd app #进入app文件夹
mkdir static
mkdir templates
我们的应用程序包是放置于 app 文件夹中。子文件夹 static 是我们存放静态文件像图片，JS文件以及样式文件。子文件夹 templates 显然是存放模板文件。
2.为我们的 app 包(文件 app/ init .py )创建一个简单的初始化脚本:
上面的脚本简单地创建应用对象，接着导入视图模块，该模块我们暂未编写。
视图是响应来自网页浏览器的请求的处理器。在 Flask 中，视图是编写成 Python 函数。每一个视图函数是映射到一个或多个请求的 URL。
3.让我们编写第一个视图函数(文件 app/views.py ):
其实这个视图是非常简单，它只是返回一个字符串，在客户端的网页浏览器上显示。两个 route 装饰器创建了从网址 / 以及 /index 到这个函数的映射。
4.能够完整工作的 Web 应用程序的最后一步是创建一个脚本，启动我们的应用程序的开发 Web 服务器。让我们称这个脚本为 run.py，并把它置于根目录:
这个脚本简单地从我们的 app 包中导入 app 变量并且调用它的 run 方法来启动服务器。请记住 app 变量中含有我们在之前创建的 Flask 实例。
5.要启动应用程序，您只需运行此脚本（run.py）
如图：
6.在服务器初始化后，它将会监听 5000 端口等待着连接。现在打开你的网页浏览器输入如下 URL:
另外你也可以使用这个 URL:
你看清楚了路由映射是如何工作的吗？第一个 URL 映射到 /，而第二个 URL 映射到 /index。这两个路由都关联到我们的视图函数，因此它们的作用是一样的。如果你输入其它的网址，你将会获得一个错误，因为只有这两个 URL 映射到视图函数。
你可以通过 Ctrl-C 来终止服务器
入门就到这里，比较简单的。
下一章：
python轻量框架--Flask(模板详细版）
