Flask的介绍，入门，配置文件，路由系统，模版，请求和响应，session和cookie
一、和其它框架的比较
Django：重武器，内部包含了非常多组件：ORM、Form、ModelForm、缓存、Session、中间件、信号等...
Flask：短小精悍，内部没有太多组件。第三方组件非常丰富。
路由比较特殊：基于装饰器来实现，但是究其本质还是通过add_url_rule来实现。
bottle：比flask更简洁，几乎没有企业应用
web.py：比较老
Tornado：异步非阻塞框架（node.js）
二、wsgi
1、werkzeug示例：
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)
2、wsgiref示例：
from wsgiref.simple_server import make_server def runserver(environ, start_response): start_response('200 OK', [('Content-Type', 'text/html')]) return [bytes('<h1>Hello, web!</h1>', encoding='utf-8'), ] if __name__ == '__main__': # obj = WSGIHandler() httpd = make_server('', 8000, runserver) httpd.serve_forever()
3、本质：
import socket def handle_request(client): buf = client.recv(1024) client.send("HTTP/1.1 200 OK\r\n\r\n") client.send("Hello, Seven") def main(): sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.bind(('localhost', 8000)) sock.listen(5) while True: connection, address = sock.accept() handle_request(connection) connection.close() if __name__ == '__main__': main()
三、flask简单示例
from flask import Flask # 实例化Flask对象 app = Flask(__name__) # 设置为检测到修改程序时自动重启 app.debug = True # 设置路由匹配，\就是路径，匹配到后就执行hello_word函数 @app.route('/') # ---》 第1步. v = app.route('/') 第2步. v(hello_world) def hello_world(): return 'Hello World!' if __name__ == '__main__': # 监听用户请求，若有请求来，则执行app的_ _call_ _方法 app.run()
四、配置文件
方式一：
# 这种句点符方式只是对某些参数有效，所以一般我们不用 app.debug = True
方式二：
# 相较方式一更为普遍，但是较为繁琐
# 由于Config对象本质上是字典，所以还可以使用app.config.update(...)
app.config["debug"] = True
方式三：指定的配置文件中的配置参数一定要大写
# 这个方法就会在当前文件的根目录下寻找指定的文件，找不到是会报错的，所以一定# 和当前文件是同一级目录 # 找到打开并读取这个文件，我们就可以把相关的配置写到这个文件中 # 一定要注意这个文件中的配置参数要大写才会生效
#app.config.from_pyfile("python文件名称")
app.config.from_pyfile("settings.py")
补充：
app.config.from_envvar("环境变量名称") # 环境变量的值为python文件名称名称，内部调用from_pyfile方法 app.config.from_json("json文件名称") #JSON文件名称，必须是json格式，因为内部会执行json.loads app.config.from_mapping({'DEBUG':True}) # 字典格式
方式四：最常用的
# 参数要写存放配置信息类的路径 app.config.from_object("settings.DevelopmentConfig") # 路径中的类根据不同的需求创建，可以配置不同的参数 class Config(object): DEBUG = False TESTING = False DATABASE_URI = 'sqlite://:memory:' class ProductionConfig(Config): DATABASE_URI = 'mysql://user@localhost/foo' # 根据路径就找到了这个类，就会自动加载类中的配置参数，依然要大写 class DevelopmentConfig(Config): DEBUG = True
五、路由系统
# app.route做的事 # 1、执行route方法，返回decorator(函数名) # 2、执行@，也就是执行decorator函数，参数就是login，也就是被装饰的函数 # 在decorator函数中会执行add_url_rule方法，这个方法就是把路径/login和login函数 # 的对应关系添加到路由中，路由我们可以简单的理解为一个字典，保存着路径和函数的 # 对应关系 @app.route('/login') def login(): return "OK"
1、flask路由的特点：
基于装饰器实现，本质上就是add_url_rule方法
注意一点：flask的路由默认是不支持正则规则的，所以要想在URL中传参，就用下面的格式
# 想这样用尖括号表示 @app.route('/user/<username>') # int是类型，post_id是参数名 @app.route('/post/<int:post_id>') # float是类型 @app.route('/post/<float:post_id>') @app.route('/post/<path:path>')
反向生成URL
url_for("endpoint参数值") 如果URL中有参数的话就直接写参数名=xxxxx这样来传值，别名部允许重复
2、参数：@app.route和app.add_url_rule参数：
基本：
rule, #URL规则，就是要匹配的路径 view_func, #视图函数名称 defaults=None, #默认值,当URL中无参数，函数需要参数时，使用defaults={'k':'v'}为函数提供参数 endpoint=None, #名称，用于反向生成URL，即： url_for('名称') methods=None, #允许的请求方式，如：["GET","POST"]
其它：
对URL最后的/是否有要求
strict_slashes = None, # 对URL最后的 / 符号是否严格要求， # 如： @app.route('/index', strict_slashes=False) # 访问 # http: // www.xx.com / index / 或http: // www.xx.com / index均可 @app.route('/index', strict_slashes=True) # 仅访问 # http: // www.xx.com / index
重定向
redirect_to=None, # 重定向到指定地址，访问这个URL时直接重定向到指定的函数 # 如： @app.route('/index/<int:nid>', redirect_to='/home/<nid>') # 或 def func(adapter, nid): return "/home/888" @app.route('/index/<int:nid>', redirect_to=func)
子域名
subdomain=None #子域名访问 from flask import Flask, views, url_for app = Flask(import_name=__name__) # 这个参数必须设置 app.config['SERVER_NAME'] = 'wupeiqi.com:5000' @app.route("/", subdomain="admin") def static_index(): return "static.your-domain.tld" @app.route("/dynamic", subdomain="<username>") def username_index(username): return username + ".your-domain.tld" if __name__ == '__main__': app.run()
3、基于CBV
实现流程：as_view --> view --> dispatch_request --> 反射 --> 执行对应的方法
from flask import views,Flask app = Flask(__name__) def auth(func): def inner(*args, **kwargs): print('before') result = func(*args, **kwargs) print('after') return result return inner class IndexView(views.MethodView): methods = ['GET'] decorators = [auth, ] def get(self): return 'Index.GET' def post(self): return 'Index.POST' # 1、将路径和视图的对应关系添加到路由中 # 2、路由匹配成功后会执行as_view方法，实际执行的是MethodView继承的View类的as_view方法 # as_view方法中会循环decorators参数，view = decorator(view)一层一层的装饰下去， # 最后返回view函数名 # 把name参数值赋给view.__name__，所以add_url_rule方法没有传view_func参数时就会自动把view_func函数名作为别名 # 这里因为as_view返回的是view，所以view就是view_fun参数值，这里定义的name参数值就是url的别名。相当于endpoint参数 # 因为as_view有括号所以继续执行，首先实例化IndexView对象，继而执行dispatch_request方法 # 这里实际执行的就是MethodView的dispatch_request方法，这个方法中就是利用了反射根据请求method的不同 # 执行同名的方法，跟django CBV的原理一样 app.add_url_rule('/index', view_func=IndexView.as_view(name='index')) # name=endpoint if __name__ == '__main__': # 会调用add_url_rule方法 app.run()
4、flask路由默认是不支持正则规则，但是可以自定制
from flask import Flask, views, url_for from werkzeug.routing import BaseConverter app = Flask(import_name=__name__) class RegexConverter(BaseConverter): """ 自定义URL匹配正则表达式 """ def __init__(self, map, regex): super(RegexConverter, self).__init__(map) self.regex = regex # 路由匹配成功后调用视图函数之前执行 def to_python(self, value): """ 路由匹配时，匹配成功后传递给视图函数中参数的值 :param value: :return: """ return int(value) # 执行url_for反向解析url方法时会先执行to_url方法 def to_url(self, value): """ 使用url_for反向生成URL时，传递的参数经过该方法处理，返回的值用于生成URL中的参数 :param value: :return: """ val = super(RegexConverter, self).to_url(value) return val # 添加到flask中 app.url_map.converters['regex'] = RegexConverter @app.route('/index/<regex("\d+"):nid>') def index(nid): print(url_for('index', nid='888')) return 'Index' if __name__ == '__main__': app.run()
六、模版
Flask使用的是Jinja2模板，所以其语法和Django无差别
但是还是有一些细微的差别
1、模版渲染方法
from flask import Flask,render_template app = Flask(__name__) def wupeiqi(): return '<h1>Wupeiqi</h1>' @app.route('/login', methods=['GET', 'POST']) def login(): # flask会从根目录下的templates目录中查找模版文件 # ww就相当于django中render方法传给模版的变量，这里不是字典的形式 return render_template('login.html', ww=wupeiqi) app.run()
<!DOCTYPE html> <html> <head lang="en"> <meta charset="UTF-8"> <title></title> </head> <body> <h1>自定义函数</h1> 模版文件中直接加括号调用，这里就跟django不一样了 也有safe过滤器 {{ww()|safe}} </body> </html>
补充：django中的mark_safe方法flask中也有，叫Markup
2、模版中循环字典，使用items时一定要叫括号，取值的时候有三种方法
（1）用句点符 （2）[key] 索引取值 （3）get(key)取值
3、模版继承和django是一样的
4、include引用模版也是一样的
补充：模版中利用传参的方式定制标签，利用macro
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> </head> <body> {% macro input(name, type='text', value='') %} <input type="{{ type }}" name="{{ name }}" value="{{ value }}"> {% endmacro %} {{ input('n1') }} {% include 'tp.html' %} <h1>asdf{{ v.k1}}</h1> </body> </html>
七、请求和响应
request需要导入
GET数据：request.query_string
POST数据：request.form
当要给响应添加cookie时，必须用make_response方法，如下
response = make_response(render_template('index.html'))
response.set_cookie设置cookie
获取cookie request.cookies.get(key)
from flask import Flask from flask import request from flask import render_template from flask import redirect from flask import make_response app = Flask(__name__) @app.route('/login.html', methods=['GET', "POST"]) def login(): # 请求相关信息 # request.method # request.args # request.form # request.values # 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 # request.files # obj = request.files['the_file_name'] # obj.save('/var/www/uploads/' + secure_filename(f.filename)) # 响应相关信息 # return "字符串" # return render_template('html模板路径',**{}) # return redirect('/index.html') # response = make_response(render_template('index.html')) # response是flask.wrappers.Response类型 # response.delete_cookie('key') # response.set_cookie('key', 'value') # response.headers['X-Something'] = 'A value' # return response return "内容" if __name__ == '__main__': app.run()
八、session
首先导入：from flask import session
设置值：session['username'] ＝ 'xxx'
取值：session.pop('username', None)
还要设置密钥，其实就是随机字符串：app.secret_key = "sdfsdgrgasdgewrgw"
1、基本使用：
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'
2、自定义session
pip3 install Flask-Session run.py from flask import Flask from flask import session from pro_flask.utils.session import MySessionInterface app = Flask(__name__) app.secret_key = 'A0Zr98j/3yX R~XHH!jmN]LWX/,?RT' app.session_interface = MySessionInterface() @app.route('/login.html', methods=['GET', "POST"]) def login(): print(session) session['user1'] = 'alex' session['user2'] = 'alex' del session['user2'] return "内容" if __name__ == '__main__': app.run() session.py #!/usr/bin/env python # -*- coding:utf-8 -*- import uuid import json from flask.sessions import SessionInterface from flask.sessions import SessionMixin from itsdangerous import Signer, BadSignature, want_bytes class MySession(dict, SessionMixin): def __init__(self, initial=None, sid=None): self.sid = sid self.initial = initial super(MySession, self).__init__(initial or ()) def __setitem__(self, key, value): super(MySession, self).__setitem__(key, value) def __getitem__(self, item): return super(MySession, self).__getitem__(item) def __delitem__(self, key): super(MySession, self).__delitem__(key) class MySessionInterface(SessionInterface): session_class = MySession container = {} def __init__(self): import redis self.redis = redis.Redis() def _generate_sid(self): return str(uuid.uuid4()) def _get_signer(self, app): if not app.secret_key: return None return Signer(app.secret_key, salt='flask-session', key_derivation='hmac') def open_session(self, app, request): """ 程序刚启动时执行，需要返回一个session对象 """ sid = request.cookies.get(app.session_cookie_name) if not sid: sid = self._generate_sid() return self.session_class(sid=sid) signer = self._get_signer(app) try: sid_as_bytes = signer.unsign(sid) sid = sid_as_bytes.decode() except BadSignature: sid = self._generate_sid() return self.session_class(sid=sid) # session保存在redis中 # val = self.redis.get(sid) # session保存在内存中 val = self.container.get(sid) if val is not None: try: data = json.loads(val) return self.session_class(data, sid=sid) except: return self.session_class(sid=sid) return self.session_class(sid=sid) def save_session(self, app, session, response): """ 程序结束前执行，可以保存session中所有的值 如： 保存到resit 写入到用户cookie """ domain = self.get_cookie_domain(app) path = self.get_cookie_path(app) httponly = self.get_cookie_httponly(app) secure = self.get_cookie_secure(app) expires = self.get_expiration_time(app, session) val = json.dumps(dict(session)) # session保存在redis中 # self.redis.setex(name=session.sid, value=val, time=app.permanent_session_lifetime) # session保存在内存中 self.container.setdefault(session.sid, val) session_id = self._get_signer(app).sign(want_bytes(session.sid)) response.set_cookie(app.session_cookie_name, session_id, expires=expires, httponly=httponly, domain=domain, path=path, secure=secure) 自定义Session
3、第三方session
#!/usr/bin/env python # -*- coding:utf-8 -*- """ pip3 install redis pip3 install flask-session """ from flask import Flask, session, redirect from flask.ext.session import Session app = Flask(__name__) app.debug = True app.secret_key = 'asdfasdfasd' app.config['SESSION_TYPE'] = 'redis' from redis import Redis app.config['SESSION_REDIS'] = Redis(host='192.168.0.94',port='6379') Session(app) @app.route('/login') def login(): session['username'] = 'alex' return redirect('/index') @app.route('/index') def index(): name = session['username'] return name if __name__ == '__main__': app.run() 第三方session
