python系列整理---flask

目录:

  • Flask基本使用
  • Flask配置文件
  • Flask路由系统
  • Flask模版
  • Flask请求与响应
  • Flask之Session
  • Flask之蓝图
  • Flask之message
  • 中间件
  • Flask插件

一、Flask基本使用

1、flask简介

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

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

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

2、flask安装

pip3 install flask

3、flask之werkaeug

1 from werkzeug.wrappers import Request, Response
2 
3 @Request.application
4 def hello(request):
5     return Response('Hello World!')
6 
7 if __name__ == '__main__':
8     from werkzeug.serving import run_simple
9     run_simple('localhost', 4000, hello)
View Code

4、flask基本使用

复制代码
1 from flask import Flask
2 app = Flask(__name__)
3  
4 @app.route('/')
5 def hello_world():
6     return 'Hello World!'
7  
8 if __name__ == '__main__':
9     app.run()
复制代码

二、Flask配置文件

flask中的配置文件是一个flask.config.Config对象(继承字典),默认配置为:

View Code

1、调用方式

复制代码
 1 方式一:
 2     app.config['DEBUG'] = True
 3  
 4     PS: 由于Config对象本质上是字典,所以还可以使用app.config.update(...)
 5  
 6 方式二:
 7     app.config.from_pyfile("python文件名称")
 8         如:
 9             settings.py
10                 DEBUG = True
11  
12             app.config.from_pyfile("settings.py")
13  
14     app.config.from_envvar("环境变量名称")
15         环境变量的值为python文件名称名称,内部调用from_pyfile方法
16  
17  
18     app.config.from_json("json文件名称")
19         JSON文件名称,必须是json格式,因为内部会执行json.loads
20  
21     app.config.from_mapping({'DEBUG':True})
22         字典格式
23  
24     app.config.from_object("python类或类的路径")
25  
26         app.config.from_object('pro_flask.settings.TestingConfig')
27  
28         settings.py
29  
30             class Config(object):
31                 DEBUG = False
32                 TESTING = False
33                 DATABASE_URI = 'sqlite://:memory:'
34  
35             class ProductionConfig(Config):
36                 DATABASE_URI = 'mysql://user@localhost/foo'
37  
38             class DevelopmentConfig(Config):
39                 DEBUG = True
40  
41             class TestingConfig(Config):
42                 TESTING = True
复制代码

 PS: 从sys.path中已经存在路径开始写

 PS: settings.py文件默认路径要放在程序root_path目录,如果instance_relative_config为True,则就是instance_path目录

三、Flask路由系统

1、基本路由系统

  • @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'])

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

DEFAULT_CONVERTERS = {

    'default':          UnicodeConverter,
    'string':           UnicodeConverter,
    'any':              AnyConverter,
    'path':             PathConverter,
    'int':              IntegerConverter,
    'float':            FloatConverter,
    'uuid':             UUIDConverter,
}
2、注册路由原理
  1        def auth(func):
  2             def inner(*args, **kwargs):
  3                 print('before')
  4                 result = func(*args, **kwargs)
  5                 print('after')
  6                 return result
  7 
  8         return inner
  9 
 10         @app.route('/index.html',methods=['GET','POST'],endpoint='index')
 11         @auth
 12         def index():
 13             return 'Index'
 14 
 15  16         
 17         def index():
 18             return "Index"
 19 
 20         self.add_url_rule(rule='/index.html', endpoint="index", view_func=index, methods=["GET","POST"])
 21         or
 22         app.add_url_rule(rule='/index.html', endpoint="index", view_func=index, methods=["GET","POST"])
 23         app.view_functions['index'] = index
 24 
 25 
 26  27         def auth(func):
 28             def inner(*args, **kwargs):
 29                 print('before')
 30                 result = func(*args, **kwargs)
 31                 print('after')
 32                 return result
 33 
 34         return inner
 35 
 36         class IndexView(views.View):
 37             methods = ['GET']
 38             decorators = [auth, ]
 39 
 40             def dispatch_request(self):
 41                 print('Index')
 42                 return 'Index!'
 43 
 44         app.add_url_rule('/index', view_func=IndexView.as_view(name='index'))  # name=endpoint
 45 
 46 
 47 
 48  49 
 50 
 51         class IndexView(views.MethodView):
 52             methods = ['GET']
 53             decorators = [auth, ]
 54 
 55             def get(self):
 56                 return 'Index.GET'
 57 
 58             def post(self):
 59                 return 'Index.POST'
 60 
 61 
 62         app.add_url_rule('/index', view_func=IndexView.as_view(name='index'))  # name=endpoint
 63 
 64 
 65 
 66 
 67         @app.route和app.add_url_rule参数:
 68             rule,                       URL规则
 69             view_func,                  视图函数名称
 70             defaults=None,              默认值,当URL中无参数,函数需要参数时,使用defaults={'k':'v'}为函数提供参数
 71             endpoint=None,              名称,用于反向生成URL,即: url_for('名称')
 72             methods=None,               允许的请求方式,如:["GET","POST"]
 73             
 74 
 75             strict_slashes=None,        对URL最后的 / 符号是否严格要求,
 76                                         如:
 77                                             @app.route('/index',strict_slashes=False),
 78                                                 访问 http://www.xx.com/index/ 或 http://www.xx.com/index均可
 79                                             @app.route('/index',strict_slashes=True)
 80                                                 仅访问 http://www.xx.com/index 
 81             redirect_to=None,           重定向到指定地址
 82                                         如:
 83                                             @app.route('/index/<int:nid>', redirect_to='/home/<nid>')
 84  85                                             def func(adapter, nid):
 86                                                 return "/home/888"
 87                                             @app.route('/index/<int:nid>', redirect_to=func)
 88             subdomain=None,             子域名访问
 89                                                 from flask import Flask, views, url_for
 90 
 91                                                 app = Flask(import_name=__name__)
 92                                                 app.config['SERVER_NAME'] = 'wupeiqi.com:5000'
 93 
 94 
 95                                                 @app.route("/", subdomain="admin")
 96                                                 def static_index():
 97                                                     """Flask supports static subdomains
 98                                                     This is available at static.your-domain.tld"""
 99                                                     return "static.your-domain.tld"
100 
101 
102                                                 @app.route("/dynamic", subdomain="<username>")
103                                                 def username_index(username):
104                                                     """Dynamic subdomains are also supported
105                                                     Try going to user1.your-domain.tld/dynamic"""
106                                                     return username + ".your-domain.tld"
107 
108 
109                                                 if __name__ == '__main__':
110                                                     app.run()
111         
View Code

3、自定义路由匹配(正则匹配)

 1            from flask import Flask, views, url_for
 2             from werkzeug.routing import BaseConverter
 3 
 4             app = Flask(import_name=__name__)
 5 
 6 
 7             class RegexConverter(BaseConverter):
 8                 """
 9                 自定义URL匹配正则表达式
10                 """
11                 def __init__(self, map, regex):
12                     super(RegexConverter, self).__init__(map)
13                     self.regex = regex
14 
15                 def to_python(self, value):
16                     """
17                     路由匹配时,匹配成功后传递给视图函数中参数的值
18                     :param value: 
19                     :return: 
20                     """
21                     return int(value)
22 
23                 def to_url(self, value):
24                     """
25                     使用url_for反向生成URL时,传递的参数经过该方法处理,返回的值用于生成URL中的参数
26                     :param value: 
27                     :return: 
28                     """
29                     val = super(RegexConverter, self).to_url(value)
30                     return val
31 
32             # 添加到flask中
33             app.url_map.converters['regex'] = RegexConverter
34 
35 
36             @app.route('/index/<regex("\d+"):nid>')
37             def index(nid):
38                 print(url_for('index', nid='888'))
39                 return 'Index'
40 
41 
42             if __name__ == '__main__':
43                 app.run()
View Code

四、Flask模版

1、模板的使用

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

2、自定义模板方法

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

 1 <!DOCTYPE html>
 2 <html>
 3 <head lang="en">
 4     <meta charset="UTF-8">
 5     <title></title>
 6 </head>
 7 <body>
 8     <h1>自定义函数</h1>
 9     {{ww()|safe}}
10 
11 </body>
12 </html>
13 复制代码
html
复制代码
 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 from flask import Flask,render_template
 4 app = Flask(__name__)
 5  
 6  
 7 def wangshuyang():
 8     return '<h1>Wupeiqi</h1>'
 9  
10 @app.route('/login', methods=['GET', 'POST'])
11 def login():
12     return render_template('login.html', ww=wangshuyang)
13  
14 app.run()
复制代码

五、Flask请求与响应

 1    from flask import Flask
 2     from flask import request
 3     from flask import render_template
 4     from flask import redirect
 5     from flask import make_response
 6 
 7     app = Flask(__name__)
 8 
 9 
10     @app.route('/login.html', methods=['GET', "POST"])
11     def login():
12 
13         # 请求相关信息
14         # request.method
15         # request.args
16         # request.form
17         # request.values
18         # request.cookies
19         # request.headers
20         # request.path
21         # request.full_path
22         # request.script_root
23         # request.url
24         # request.base_url
25         # request.url_root
26         # request.host_url
27         # request.host
28         # request.files
29         # obj = request.files['the_file_name']
30         # obj.save('/var/www/uploads/' + secure_filename(f.filename))
31 
32         # 响应相关信息
33         # return "字符串"
34         # return render_template('html模板路径',**{})
35         # return redirect('/index.html')
36 
37         # response = make_response(render_template('index.html'))
38         # response是flask.wrappers.Response类型
39         # response.delete_cookie('key')
40         # response.set_cookie('key', 'value')
41         # response.headers['X-Something'] = 'A value'
42         # return response
43 
44 
45         return "内容"
46 
47     if __name__ == '__main__':
48         app.run()
View Code

六、Flask之Session

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

  • 设置:session['username'] = 'xxx'

  • 删除:session.pop('username', None)

1、基本使用

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

2、自定义session(Flask-Session插件)

  1         pip3 install Flask-Session
  2         
  3         run.py
  4             from flask import Flask
  5             from flask import session
  6             from pro_flask.utils.session import MySessionInterface
  7             app = Flask(__name__)
  8 
  9             app.secret_key = 'A0Zr98j/3yX R~XHH!jmN]LWX/,?RT'
 10             app.session_interface = MySessionInterface()
 11 
 12             @app.route('/login.html', methods=['GET', "POST"])
 13             def login():
 14                 print(session)
 15                 session['user1'] = 'alex'
 16                 session['user2'] = 'alex'
 17                 del session['user2']
 18 
 19                 return "内容"
 20 
 21             if __name__ == '__main__':
 22                 app.run()
 23 
 24         session.py
 25             #!/usr/bin/env python
 26             # -*- coding:utf-8 -*-
 27             import uuid
 28             import json
 29             from flask.sessions import SessionInterface
 30             from flask.sessions import SessionMixin
 31             from itsdangerous import Signer, BadSignature, want_bytes
 32 
 33 
 34             class MySession(dict, SessionMixin):
 35                 def __init__(self, initial=None, sid=None):
 36                     self.sid = sid
 37                     self.initial = initial
 38                     super(MySession, self).__init__(initial or ())
 39 
 40 
 41                 def __setitem__(self, key, value):
 42                     super(MySession, self).__setitem__(key, value)
 43 
 44                 def __getitem__(self, item):
 45                     return super(MySession, self).__getitem__(item)
 46 
 47                 def __delitem__(self, key):
 48                     super(MySession, self).__delitem__(key)
 49 
 50 
 51 
 52             class MySessionInterface(SessionInterface):
 53                 session_class = MySession
 54                 container = {}
 55 
 56                 def __init__(self):
 57                     import redis
 58                     self.redis = redis.Redis()
 59 
 60                 def _generate_sid(self):
 61                     return str(uuid.uuid4())
 62 
 63                 def _get_signer(self, app):
 64                     if not app.secret_key:
 65                         return None
 66                     return Signer(app.secret_key, salt='flask-session',
 67                                   key_derivation='hmac')
 68 
 69                 def open_session(self, app, request):
 70                     """
 71                     程序刚启动时执行,需要返回一个session对象
 72                     """
 73                     sid = request.cookies.get(app.session_cookie_name)
 74                     if not sid:
 75                         sid = self._generate_sid()
 76                         return self.session_class(sid=sid)
 77 
 78                     signer = self._get_signer(app)
 79                     try:
 80                         sid_as_bytes = signer.unsign(sid)
 81                         sid = sid_as_bytes.decode()
 82                     except BadSignature:
 83                         sid = self._generate_sid()
 84                         return self.session_class(sid=sid)
 85 
 86                     # session保存在redis中
 87                     # val = self.redis.get(sid)
 88                     # session保存在内存中
 89                     val = self.container.get(sid)
 90 
 91                     if val is not None:
 92                         try:
 93                             data = json.loads(val)
 94                             return self.session_class(data, sid=sid)
 95                         except:
 96                             return self.session_class(sid=sid)
 97                     return self.session_class(sid=sid)
 98 
 99                 def save_session(self, app, session, response):
100                     """
101                     程序结束前执行,可以保存session中所有的值
102                     如:
103                         保存到resit
104                         写入到用户cookie
105                     """
106                     domain = self.get_cookie_domain(app)
107                     path = self.get_cookie_path(app)
108                     httponly = self.get_cookie_httponly(app)
109                     secure = self.get_cookie_secure(app)
110                     expires = self.get_expiration_time(app, session)
111 
112                     val = json.dumps(dict(session))
113 
114                     # session保存在redis中
115                     # self.redis.setex(name=session.sid, value=val, time=app.permanent_session_lifetime)
116                     # session保存在内存中
117                     self.container.setdefault(session.sid, val)
118 
119                     session_id = self._get_signer(app).sign(want_bytes(session.sid))
120 
121                     response.set_cookie(app.session_cookie_name, session_id,
122                                         expires=expires, httponly=httponly,
123                                         domain=domain, path=path, secure=secure)
View Code

七、Flask之蓝图

蓝图用于为应用提供目录划分:

小型应用程序:示例

大型应用程序:示例

其他:

  • 蓝图URL前缀:xxx = Blueprint('account', __name__,url_prefix='/xxx')
  • 蓝图子域名:xxx = Blueprint('account', __name__,subdomain='admin')
    # 前提需要给配置SERVER_NAME: app.config['SERVER_NAME'] = 'wupeiqi.com:5000'
    # 访问时:admin.wupeiqi.com:5000/login.html

八、Flask之message

message是一个基于Session实现的用于保存数据的集合,其特点是:使用一次就删除。(也称为闪现)

 1         from flask import Flask, flash, redirect, render_template, request, get_flashed_messages
 2 
 3         app = Flask(__name__)
 4         app.secret_key = 'some_secret'
 5 
 6 
 7         @app.route('/')
 8         def index1():
 9             messages = get_flashed_messages()
10             print(messages)
11             return "Index1"
12 
13 
14         @app.route('/set')
15         def index2():
16             v = request.args.get('p')
17             flash(v)
18             return 'ok'
19 
20 
21         if __name__ == "__main__":
22             app.run()
View Code

九、中间件

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

十、Flask插件

  • Flask-Session
  • WTForms
  • SQLAchemy
  • 等...  

详见:http://flask.pocoo.org/extensions/

Flask配置Cors跨域

1 跨域的理解

跨域是指:浏览器A服务器B获取的静态资源,包括Html、Css、Js,然后在Js中通过Ajax访问C服务器的静态资源或请求。即:浏览器A从B服务器拿的资源,资源中想访问服务器C的资源。

同源策略是指:浏览器A服务器B获取的静态资源,包括Html、Css、Js,为了用户安全,浏览器加了限制,其中的Js通过Ajax只能访问B服务器的静态资源或请求。即:浏览器A从哪拿的资源,那资源中就只能访问哪。

同源是指:同一个请求协议(如:Http或Https)、同一个Ip、同一个端口,3个全部相同,即为同源。

2 跨域的处理

跨域的这种需求还是有的,因此,W3C组织制定了一个Cross-Origin Resource Sharing规范,简写为Cors,现在这个规范已经被大多数浏览器支持,从而,处理跨域的需求。

Cors需要在后端应用进行配置,因此,是一种跨域的后端处理方式,这么做也容易理解,一个你不认识的源来访问你的应用,自然需要应用进行授权。除了后端处理方式,也有前端的解决方案,如:JSONP,因这里我们主要讲解Flask对Cors的配置,暂不对前端解决方案进行详细说明。

3 跨域的分类

跨域分为以下3种

名称英文名说明
简单请求 Simple Request 发起的Http请求符合:
1.无自定义请求头,
2.请求动词为GET、HEAD或POST之一,
3.动词为POST时,Content-Type是application/x-www-form-urlencoded,
multipart/form-data或text/plain之一
预检请求 Preflighted Request 发起的Http请求符合其中之一:
1.包含了自定义请求头,
2.请求动词不是GET、HEAD或POST,
3.动词是POST时, Content-Type不是application/x-www-form-urlencoded,
multipart/form-data或text/plain。 即:简单请求的相反
凭证请求 Requests with Credential 发起的Http请求中带有凭证

4 Flask配置Cors

Flask配Cors跨域,使用Flask-CORS包,详细文档,参见: https://flask-cors.readthedocs.io/en/latest/,总的来说,flask-cors包也提供了两种方式

方式范围说明
@cross_origin装饰器 配置单个路由 适用于配置特定的API接口
CORS函数 配置全局API接口 适用于全局的API接口配置

3.1 安装flask-cors

pip install flask-cors

3.2 使用@cross_origin装饰器

@app.route("/")
@cross_origin()
def helloWorld():
  return "Hello, cross-origin-world!"
装饰器参数类型Head字段说明
origins 列表、字符串或正则表达式 Access-Control-Allow-Origin 配置允许跨域访问的源,
*表示全部允许
methods 列表、字符串 Access-Control-Allow-Methods 配置跨域支持的请求方式,
如:GET、POST
expose_headers 列表、字符串 Access-Control-Expose-Headers 自定义请求响应的Head信息
allow_headers 列表、字符串或正则表达式 Access-Control-Request-Headers 配置允许跨域的请求头
supports_credentials 布尔值 Access-Control-Allow-Credentials 是否允许请求发送cookie,
false是不允许
max_age 整数、字符串 Access-Control-Max-Age 预检请求的有效时长

3.3 使用CORS函数

3.3.1 应用全局配置

app = Flask(__name__)
cors = CORS(app, resources={r"/api/*": {"origins": "*"}})

@app.route("/api/v1/users")
def list_users():
  return "user example"

3.3.2 单独Blueprints配置

api_v1 = Blueprint('API_v1', __name__)
CORS(api_v1) 

@api_v1.route("/api/v1/users/")
def list_users():
  return "user example"

3.3.3 CORS参数说明

参数类型Head字段说明
resources 字典、迭代器或字符串 全局配置允许跨域的API接口
origins 列表、字符串或正则表达式 Access-Control-Allow-Origin 配置允许跨域访问的源,
*表示全部允许
methods 列表、字符串 Access-Control-Allow-Methods 配置跨域支持的请求方式,
如:GET、POST
expose_headers 列表、字符串 Access-Control-Expose-Headers 自定义请求响应的Head信息
allow_headers 列表、字符串或正则表达式 Access-Control-Request-Headers 配置允许跨域的请求头
supports_credentials 布尔值 Access-Control-Allow-Credentials 是否允许请求发送cookie,
false是不允许
max_age 整数、字符串 Access-Control-Max-Age 预检请求的有效时长
posted @ 2020-09-18 01:03  Satansz  阅读(217)  评论(0编辑  收藏  举报