Python全栈开发：web框架们

nixingguo

Python的WEB框架

Bottle

Bottle是一个快速、简洁、轻量级的基于WSIG的微型Web框架，此框架只由一个 .py 文件，除了Python的标准库外，其不依赖任何其他模块。

1
2
3
4
pip install bottle
easy_install bottle
apt-get install python-bottle
wget http://bottlepy.org/bottle.py

Bottle框架大致可以分为以下部分：

  • 路由系统，将不同请求交由指定函数处理
  • 模板系统，将模板中的特殊语法渲染成字符串，值得一说的是Bottle的模板引擎可以任意指定：Bottle内置模板、mako、jinja2、cheetah
  • 公共组件，用于提供处理请求相关的信息，如：表单数据、cookies、请求头等
  • 服务，Bottle默认支持多种基于WSGI的服务，如：

 

server_names = {
    \'cgi\': CGIServer,
    \'flup\': FlupFCGIServer,
    \'wsgiref\': WSGIRefServer,
    \'waitress\': WaitressServer,
    \'cherrypy\': CherryPyServer,
    \'paste\': PasteServer,
    \'fapws3\': FapwsServer,
    \'tornado\': TornadoServer,
    \'gae\': AppEngineServer,
    \'twisted\': TwistedServer,
    \'diesel\': DieselServer,
    \'meinheld\': MeinheldServer,
    \'gunicorn\': GunicornServer,
    \'eventlet\': EventletServer,
    \'gevent\': GeventServer,
    \'geventSocketIO\':GeventSocketIOServer,
    \'rocket\': RocketServer,
    \'bjoern\' : BjoernServer,
    \'auto\': AutoServer,
}

 

框架的基本使用

1
2
3
4
5
6
7
8
9
10
11
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from bottle import template, Bottle
root = Bottle()
 
@root.route(\'/hello/\')
def index():
    return "Hello World"
    # return template(\'<b>Hello {{name}}</b>!\', name="Alex")
 
root.run(host=\'localhost\', port=8080)

一、路由系统

路由系统是的url对应指定函数，当用户请求某个url时，就由指定函数处理当前请求，对于Bottle的路由系统可以分为一下几类：

  • 静态路由
  • 动态路由
  • 请求方法路由
  • 二级路由

1、静态路由

1
2
3
@root.route(\'/hello/\')
def index():
    return template(\'<b>Hello {{name}}</b>!\', name="Alex")

2、动态路由

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@root.route(\'/wiki/<pagename>\')
def callback(pagename):
    ...
 
@root.route(\'/object/<id:int>\')
def callback(id):
    ...
 
@root.route(\'/show/<name:re:[a-z]+>\')
def callback(name):
    ...
 
@root.route(\'/static/<path:path>\')
def callback(path):
    return static_file(path, root=\'static\')

3、请求方法路由

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
@root.route(\'/hello/\', method=\'POST\')
def index():
    ...
 
@root.get(\'/hello/\')
def index():
    ...
 
@root.post(\'/hello/\')
def index():
    ...
 
@root.put(\'/hello/\')
def index():
    ...
 
@root.delete(\'/hello/\')
def index():
    ...

4、二级路由

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from bottle import template, Bottle

app01 = Bottle()

@app01.route(\'/hello/\', method=\'GET\')
def index():
    return template(\'<b>App01</b>!\')

app01.py
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from bottle import template, Bottle

app02 = Bottle()


@app02.route(\'/hello/\', method=\'GET\')
def index():
    return template(\'<b>App02</b>!\')

app02.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from bottle import template, Bottle
from bottle import static_file
root = Bottle()
 
@root.route(\'/hello/\')
def index():
    return template(\'<b>Root {{name}}</b>!\', name="Alex")
 
from framwork_bottle import app01
from framwork_bottle import app02
 
root.mount(\'app01\', app01.app01)
root.mount(\'app02\', app02.app02)
 
root.run(host=\'localhost\', port=8080)

二、模板系统

模板系统用于将Html和自定的值两者进行渲染，从而得到字符串，然后将该字符串返回给客户端。我们知道在Bottle中可以使用 内置模板系统、mako、jinja2、cheetah等，以内置模板系统为例：

<!DOCTYPE html>
<html>
<head lang="en">
    <meta charset="UTF-8">
    <title></title>
</head>
<body>
    <h1>{{name}}</h1>
</body>
</html>

hello_template.tpl
1
2
3
4
5
6
7
8
9
10
11
12
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from bottle import template, Bottle
root = Bottle()
 
@root.route(\'/hello/\')
def index():
    # 默认情况下去目录：[\'./\', \'./views/\']中寻找模板文件 hello_template.html
    # 配置在 bottle.TEMPLATE_PATH 中
    return template(\'hello_template.tpl\', name=\'alex\')
 
root.run(host=\'localhost\', port=8080)

1、语法

  • 单值
  • 单行Python代码
  • Python代码快
  • Python、Html混合

 

<h1>1、单值</h1>
{{name}}
 
<h1>2、单行Python代码</h1>
% s1 = "hello"
 
 
<h1>3、Python代码块</h1>
<%
    # A block of python code
    name = name.title().strip()
    if name == "Alex":
        name="seven"
%>
 
 
<h1>4、Python、Html混合</h1>
 
% if True:
    <span>{{name}}</span>
% end
<ul>
  % for item in name:
    <li>{{item}}</li>
  % end
</ul>

 

2、函数 

include(sub_template, **variables)

1
2
3
4
5
# 导入其他模板文件
 
% include(\'header.tpl\', title=\'Page Title\')
Page Content
% include(\'footer.tpl\')

rebase(name, **variables)

<html>
<head>
  <title>{{title or \'No title\'}}</title>
</head>
<body>
  {{!base}}
</body>
</html>

base.tpl
1
2
3
4
# 导入母版
 
% rebase(\'base.tpl\', title=\'Page Title\')
<p>Page Content ...</p>

defined(name)

1
# 检查当前变量是否已经被定义，已定义True，未定义False

get(name, default=None)

1
# 获取某个变量的值，不存在时可设置默认值

setdefault(name, default)

1
# 如果变量不存在时，为变量设置默认值

扩展：自定义函数

<!DOCTYPE html>
<html>
<head lang="en">
    <meta charset="UTF-8">
    <title></title>
</head>
<body>
    <h1>自定义函数</h1>
    {{ wupeiqi() }}

</body>
</html>

hello_template.tpl
 hello_template.tpl
 main.py 
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from bottle import template, Bottle,SimpleTemplate
root = Bottle()


def custom():
    return \'123123\'


@root.route(\'/hello/\')
def index():
    # 默认情况下去目录：[\'./\', \'./views/\']中寻找模板文件 hello_template.html
    # 配置在 bottle.TEMPLATE_PATH 中
    return template(\'hello_template.html\', name=\'alex\', wupeiqi=custom)

root.run(host=\'localhost\', port=8080)

main.py

注：变量或函数前添加 【 ! 】，则会关闭转义的功能

三、公共组件

由于Web框架就是用来【接收用户请求】-> 【处理用户请求】-> 【响应相关内容】，对于具体如何处理用户请求，开发人员根据用户请求来进行处理，而对于接收用户请求和相应相关的内容均交给框架本身来处理，其处理完成之后将产出交给开发人员和用户。

【接收用户请求】

当框架接收到用户请求之后，将请求信息封装在Bottle的request中，以供开发人员使用

【响应相关内容】

当开发人员的代码处理完用户请求之后，会将其执行内容相应给用户，相应的内容会封装在Bottle的response中，然后再由框架将内容返回给用户

所以，公共组件本质其实就是为开发人员提供接口，使其能够获取用户信息并配置响应内容。

1、request

Bottle中的request其实是一个LocalReqeust对象，其中封装了用户请求的相关信息：

request.headers
    请求头信息
 
request.query
    get请求信息
 
request.forms
    post请求信息
 
request.files
    上传文件信息
 
request.params
    get和post请求信息
 
request.GET
    get请求信息
 
request.POST
    post和上传信息
 
request.cookies
    cookie信息
     
request.environ
    环境相关相关

2、response

Bottle中的request其实是一个LocalResponse对象，其中框架即将返回给用户的相关信息：

response
    response.status_line
        状态行
 
    response.status_code
        状态码
 
    response.headers
        响应头
 
    response.charset
        编码
 
    response.set_cookie
        在浏览器上设置cookie
         
    response.delete_cookie
        在浏览器上删除cookie

实例：

from bottle import route, request

@route(\'/login\')
def login():
    return \'\'\'
        <form action="/login" method="post">
            Username: <input name="username" type="text" />
            Password: <input name="password" type="password" />
            <input value="Login" type="submit" />
        </form>
    \'\'\'

@route(\'/login\', method=\'POST\')
def do_login():
    username = request.forms.get(\'username\')
    password = request.forms.get(\'password\')
    if check_login(username, password):
        return "<p>Your login information was correct.</p>"
    else:
        return "<p>Login failed.</p>"

基本Form请求
 基本Form请求
 上传文件  
<form action="/upload" method="post" enctype="multipart/form-data">
  Category:      <input type="text" name="category" />
  Select a file: <input type="file" name="upload" />
  <input type="submit" value="Start upload" />
</form>


@route(\'/upload\', method=\'POST\')
def do_upload():
    category   = request.forms.get(\'category\')
    upload     = request.files.get(\'upload\')
    name, ext = os.path.splitext(upload.filename)
    if ext not in (\'.png\',\'.jpg\',\'.jpeg\'):
        return \'File extension not allowed.\'

    save_path = get_save_path_for_category(category)
    upload.save(save_path) # appends upload.filename automatically
    return \'OK\'

上传文件

四、服务

对于Bottle框架其本身未实现类似于Tornado自己基于socket实现Web服务，所以必须依赖WSGI，默认Bottle已经实现并且支持的WSGI有：

 WSGI 
server_names = {
    \'cgi\': CGIServer,
    \'flup\': FlupFCGIServer,
    \'wsgiref\': WSGIRefServer,
    \'waitress\': WaitressServer,
    \'cherrypy\': CherryPyServer,
    \'paste\': PasteServer,
    \'fapws3\': FapwsServer,
    \'tornado\': TornadoServer,
    \'gae\': AppEngineServer,
    \'twisted\': TwistedServer,
    \'diesel\': DieselServer,
    \'meinheld\': MeinheldServer,
    \'gunicorn\': GunicornServer,
    \'eventlet\': EventletServer,
    \'gevent\': GeventServer,
    \'geventSocketIO\':GeventSocketIOServer,
    \'rocket\': RocketServer,
    \'bjoern\' : BjoernServer,
    \'auto\': AutoServer,
}

WSGI

使用时，只需在主app执行run方法时指定参数即可：

1
2
3
4
5
6
7
8
9
10
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from bottle import Bottle
root = Bottle()
 
@root.route(\'/hello/\')
def index():
    return "Hello World"
# 默认server ＝\'wsgiref\'
root.run(host=\'localhost\', port=8080, server=\'wsgiref\')

默认server＝"wsgiref"，即：使用Python内置模块wsgiref，如果想要使用其他时，则需要首先安装相关类库，然后才能使用。如：

 bottle.py源码 
# 如果使用Tornado的服务，则需要首先安装tornado才能使用

class TornadoServer(ServerAdapter):
    """ The super hyped asynchronous server by facebook. Untested. """
    def run(self, handler): # pragma: no cover
        # 导入Tornado相关模块
        import tornado.wsgi, tornado.httpserver, tornado.ioloop
        container = tornado.wsgi.WSGIContainer(handler)
        server = tornado.httpserver.HTTPServer(container)
        server.listen(port=self.port,address=self.host)
        tornado.ioloop.IOLoop.instance().start()

bottle.py源码

PS：以上WSGI中提供了19种，如果想要使期支持其他服务，则需要扩展Bottle源码来自定义一个ServerAdapter

更多参见：http://www.bottlepy.org/docs/dev/index.html

Flask 

Flask是一个基于Python开发并且依赖jinja2模板和Werkzeug WSGI服务的一个微型框架，对于Werkzeug本质是Socket服务端，其用于接收http请求并对请求进行预处理，然后触发Flask框架，开发人员基于Flask框架提供的功能对请求进行相应的处理，并返回给用户，如果要返回给用户复杂的内容时，需要借助jinja2模板来实现对模板的处理，即：将模板和数据进行渲染，将渲染后的字符串返回给用户浏览器。

“微”(micro) 并不表示你需要把整个 Web 应用塞进单个 Python 文件（虽然确实可以 ），也不意味着 Flask 在功能上有所欠缺。微框架中的“微”意味着 Flask 旨在保持核心简单而易于扩展。Flask 不会替你做出太多决策——比如使用何种数据库。而那些 Flask 所选择的——比如使用何种模板引擎——则很容易替换。除此之外的一切都由可由你掌握。如此，Flask 可以与您珠联璧合。

默认情况下，Flask 不包含数据库抽象层、表单验证，或是其它任何已有多种库可以胜任的功能。然而，Flask 支持用扩展来给应用添加这些功能，如同是 Flask 本身实现的一样。众多的扩展提供了数据库集成、表单验证、上传处理、各种各样的开放认证技术等功能。Flask 也许是“微小”的，但它已准备好在需求繁杂的生产环境中投入使用。

安装

1
pip install Flask
 werkzeug 
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from werkzeug.wrappers import Request, Response

@Request.application
def hello(request):
    return Response(\'Hello World!\')

if __name__ == \'__main__\':
    from werkzeug.serving import run_simple
    run_simple(\'localhost\', 4000, hello)

werkzeug

一、第一次

1
2
3
4
5
6
7
8
9
from flask import Flask
app = Flask(__name__)
 
@app.route("/")
def hello():
    return "Hello World!"
 
if __name__ == "__main__":
    app.run()

二、路由系统

  • @app.route(\'/user/<username>\')
  • @app.route(\'/post/<int:post_id>\')
  • @app.route(\'/post/<float:post_id>\')
  • @app.route(\'/post/<path:path>\')
  • @app.route(\'/login\', methods=[\'GET\', \'POST\'])

常用路由系统有以上五种，所有的路由系统都是基于一下对应关系来处理：

1
2
3
4
5
6
7
8
9
DEFAULT_CONVERTERS = {
    \'default\':          UnicodeConverter,
    \'string\':           UnicodeConverter,
    \'any\':              AnyConverter,
    \'path\':             PathConverter,
    \'int\':              IntegerConverter,
    \'float\':            FloatConverter,
    \'uuid\':             UUIDConverter,
}

注：对于Flask默认不支持直接写正则表达式的路由，不过可以通过自定义来实现，见：https://segmentfault.com/q/1010000000125259

三、模板

1、模板的使用

Flask使用的是Jinja2模板，所以其语法和Django无差别

2、自定义模板方法

Flask中自定义模板方法的方式和Bottle相似，创建一个函数并通过参数的形式传入render_template，如：

<!DOCTYPE html>
<html>
<head lang="en">
    <meta charset="UTF-8">
    <title></title>
</head>
<body>
    <h1>自定义函数</h1>
    {{ww()|safe}}

</body>
</html>

index.html
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from flask import Flask,render_template
app = Flask(__name__)
 
 
def wupeiqi():
    return \'<h1>Wupeiqi</h1>\'
 
@app.route(\'/login\', methods=[\'GET\', \'POST\'])
def login():
    return render_template(\'login.html\', ww=wupeiqi)
 
app.run()

四、公共组件

1、请求

对于Http请求，Flask会讲请求信息封装在request中(werkzeug.wrappers.BaseRequest)，提供的如下常用方法和字段以供使用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
request.method
request.args
request.form
request.values
request.files
request.cookies
request.headers
request.path
request.full_path
request.script_root
request.url
request.base_url
request.url_root
request.host_url
request.host
 表单处理Demo
 上传文件Demo
 Cookie操作 
@app.route(\'/login\', methods=[\'POST\', \'GET\'])
def login():
    error = None
    if request.method == \'POST\':
        if valid_login(request.form[\'username\'],
                       request.form[\'password\']):
            return log_the_user_in(request.form[\'username\'])
        else:
            error = \'Invalid username/password\'
    # the code below is executed if the request method
    # was GET or the credentials were invalid
    return render_template(\'login.html\', error=error)

表单处理Demo
from flask import request
from werkzeug import secure_filename

@app.route(\'/upload\', methods=[\'GET\', \'POST\'])
def upload_file():
    if request.method == \'POST\':
        f = request.files[\'the_file\']
        f.save(\'/var/www/uploads/\' + secure_filename(f.filename))
    ...

上传文件Demo
from flask import request

@app.route(\'/setcookie/\')
def index():
    username = request.cookies.get(\'username\')
    # use cookies.get(key) instead of cookies[key] to not get a
    # KeyError if the cookie is missing.




from flask import make_response

@app.route(\'/getcookie\')
def index():
    resp = make_response(render_template(...))
    resp.set_cookie(\'username\', \'the username\')
    return resp

Cookie操作

2、响应

当用户请求被开发人员的逻辑处理完成之后，会将结果发送给用户浏览器，那么就需要对请求做出相应的响应。

a.字符串

1
2
3
@app.route(\'/index/\', methods=[\'GET\', \'POST\'])
def index():
    return "index"

b.模板引擎

1
2
3
4
5
6
7
8
from flask import Flask,render_template,request
app = Flask(__name__)
 
@app.route(\'/index/\', methods=[\'GET\', \'POST\'])
def index():
    return render_template("index.html")
 
app.run()

c.重定向

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from flask import Flask, redirect, url_for
app = Flask(__name__)
 
@app.route(\'/index/\', methods=[\'GET\', \'POST\'])
def index():
    # return redirect(\'/login/\')
    return redirect(url_for(\'login\'))
 
@app.route(\'/login/\', methods=[\'GET\', \'POST\'])
def login():
    return "LOGIN"
 
app.run()

d.错误页面

from flask import Flask, abort, render_template
app = Flask(__name__)

@app.route(\'/e1/\', methods=[\'GET\', \'POST\'])
def index():
    abort(404, \'Nothing\')
app.run()

指定URL，简单错误
1
2
3
4
5
6
7
8
9
10
11
12
from flask import Flask, abort, render_template
app = Flask(__name__)
 
@app.route(\'/index/\', methods=[\'GET\', \'POST\'])
def index():
    return "OK"
 
@app.errorhandler(404)
def page_not_found(error):
    return render_template(\'page_not_found.html\'), 404
 
app.run()

e.设置相应信息

使用make_response可以对相应的内容进行操作

1
2
3
4
5
6
7
8
9
10
11
12
13
from flask import Flask, abort, render_template,make_response
app = Flask(__name__)
 
@app.route(\'/index/\', methods=[\'GET\', \'POST\'])
def index():
    response = make_response(render_template(\'index.html\'))
    # response是flask.wrappers.Response类型
    # response.delete_cookie
    # response.set_cookie
    # response.headers[\'X-Something\'] = \'A value\'
    return response
 
app.run()

3、Session

除请求对象之外，还有一个 session 对象。它允许你在不同请求间存储特定用户的信息。它是在 Cookies 的基础上实现的，并且对 Cookies 进行密钥签名要使用会话，你需要设置一个密钥。

  • 设置：session[\'username\'] ＝ \'xxx\'

  • 删除：session.pop(\'username\', None)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
from flask import Flask, session, redirect, url_for, escape, request
 
app = Flask(__name__)
 
@app.route(\'/\')
def index():
    if \'username\' in session:
        return \'Logged in as %s\' % escape(session[\'username\'])
    return \'You are not logged in\'
 
@app.route(\'/login\', methods=[\'GET\', \'POST\'])
def login():
    if request.method == \'POST\':
        session[\'username\'] = request.form[\'username\']
        return redirect(url_for(\'index\'))
    return \'\'\'
        <form action="" method="post">
            <p><input type=text name=username>
            <p><input type=submit value=Login>
        </form>
    \'\'\'
 
@app.route(\'/logout\')
def logout():
    # remove the username from the session if it\'s there
    session.pop(\'username\', None)
    return redirect(url_for(\'index\'))
 
# set the secret key.  keep this really secret:
app.secret_key = \'A0Zr98j/3yX R~XHH!jmN]LWX/,?RT\'

4.message

message是一个基于Session实现的用于保存数据的集合，其特点是：使用一次就删除

 index.html
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
from flask import Flask, flash, redirect, render_template, request
 
app = Flask(__name__)
app.secret_key = \'some_secret\'
 
@app.route(\'/\')
def index1():
    return render_template(\'index.html\')
 
@app.route(\'/set\')
def index2():
    v = request.args.get(\'p\')
    flash(v)
    return \'ok\'
 
if __name__ == "__main__":
    app.run()

5.中间件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
from flask import Flask, flash, redirect, render_template, request
 
app = Flask(__name__)
app.secret_key = \'some_secret\'
 
@app.route(\'/\')
def index1():
    return render_template(\'index.html\')
 
@app.route(\'/set\')
def index2():
    v = request.args.get(\'p\')
    flash(v)
    return \'ok\'
 
class MiddleWare:
    def __init__(self,wsgi_app):
        self.wsgi_app = wsgi_app
 
    def __call__(self, *args, **kwargs):
 
        return self.wsgi_app(*args, **kwargs)
 
if __name__ == "__main__":
    app.wsgi_app = MiddleWare(app.wsgi_app)
    app.run(port=9999)

Flask还有众多其他功能，更多参见：
    http://docs.jinkan.org/docs/flask/
    http://flask.pocoo.org/

分类：

技术点：

相关文章：

猜你喜欢
相关资源
相似解决方案
热门标签
Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode