flask大全
django：重武器，内部包含了非常多组件：ORM、Form、ModelForm、缓存、Session，中间件，信号等...
flask：短小精悍、内部没有太多组件，第三方组件非常丰富
1.初识flask
安装
pip3 install flask
wsgi与werkzeug
本质的本质就socket
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)
from wsgiref.simple_server import make_server def RunServer(environ, start_response): start_response('200 OK', [('Content-Type', 'text/html')]) return ['<h1>Hello, web!</h1>'.encode('utf-8')] #py3 # return '<h1>Hello, web!</h1>' py2 if __name__ == '__main__': httpd = make_server('', 8888, RunServer) print("Serving HTTP on port 8888...") httpd.serve_forever()
快速上手
from flask import Flask
#实例flask对象
app = Flask(__name__)
#将‘/’ 和 函数hello_world的对应关系添加到路由中
@app.route('/') #第一步执行route函数，得到一函数返回值v， 第二步把hellow_world当参数执行v
def hello_world():
return 'Hello World!'
if __name__ == '__main__':
#监听用户请求，请求一到来，执行app的__call__方法
app.run() #底层执行了run_simple
2.配置文件
flask里的配置提供了三种方式：
- 字典赋值 app.config对本质上就是一个字典对象
- py文件赋值
- 类对象赋值
实际项目应用中，提倡第三种方式，因为可以通过类的继承来实现对生产环境和开发环境的部署
第三种方式内部实现的原理：字符串分割-->import_lib导入模块-->getattr获取类
flask中的配置文件是一个flask.config.Config对象（继承字典）,默认配置为： { 'DEBUG': get_debug_flag(default=False), 是否开启Debug模式 'TESTING': False, 是否开启测试模式 'PROPAGATE_EXCEPTIONS': None, 'PRESERVE_CONTEXT_ON_EXCEPTION': None, 'SECRET_KEY': None, 'PERMANENT_SESSION_LIFETIME': timedelta(days=31), 'USE_X_SENDFILE': False, 'LOGGER_NAME': None, 'LOGGER_HANDLER_POLICY': 'always', 'SERVER_NAME': None, 'APPLICATION_ROOT': None, 'SESSION_COOKIE_NAME': 'session', 'SESSION_COOKIE_DOMAIN': None, 'SESSION_COOKIE_PATH': None, 'SESSION_COOKIE_HTTPONLY': True, 'SESSION_COOKIE_SECURE': False, 'SESSION_REFRESH_EACH_REQUEST': True, 'MAX_CONTENT_LENGTH': None, 'SEND_FILE_MAX_AGE_DEFAULT': timedelta(hours=12), 'TRAP_BAD_REQUEST_ERRORS': False, 'TRAP_HTTP_EXCEPTIONS': False, 'EXPLAIN_TEMPLATE_LOADING': False, 'PREFERRED_URL_SCHEME': 'http', 'JSON_AS_ASCII': True, 'JSON_SORT_KEYS': True, 'JSONIFY_PRETTYPRINT_REGULAR': True, 'JSONIFY_MIMETYPE': 'application/json', 'TEMPLATES_AUTO_RELOAD': None, } 方式一： app.config['DEBUG'] = True PS： 由于Config对象本质上是字典，所以还可以使用app.config.update(...) 方式二： app.config.from_pyfile("python文件名称") 如： settings.py DEBUG = True 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("python类或类的路径") app.config.from_object('pro_flask.settings.TestingConfig') settings.py 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 class TestingConfig(Config): TESTING = True PS: 从sys.path中已经存在路径开始写 PS: settings.py文件默认路径要放在程序root_path目录，如果instance_relative_config为True，则就是instance_path目录
3.路由系统
flask的路由在使用时，稍微有点特殊，使用装饰器实现的，但是究其本质是通过add_url_rule实现的，所以也可以使用 这个方法来实现和django路由类似的效果
# -*- coding:utf-8 -*-
from flask import Flask,url_for,redirect,render_template,session,request
# from flask_sqlalchemy import SQLAlchemy
from exchange import db
import config
app = Flask(__name__)
app.config.from_object(config)
# db = SQLAlchemy(app)
db.init_app(app)
# with app.app_context():
# db.create_all()
'''
第一步：执行app.route函数
def route(self, rule, **options):
#rule = '/'
#options -> methods=['GET', 'POST'], endpoint='n1'
def decorator(f):
endpoint = options.pop('endpoint', None)
self.add_url_rule(rule, endpoint, f, **options)
return f
return decorator
执行结果：返回decorator函数，并在上面过程传入了参数实现闭包
所有此时在视图函数的结果为 @decorator
第二步：@decorator --> 执行decorator(index)函数
在这个过程中，我们发现它执行了 self.add_url_rule这么一个函数
它干了一件啥事了，就是把url和视图函数添加到映射表里
从上面的分析过程，我们可以得出：flask路由本质还是add_url_rule来实现的
所以我也可以不用装饰器来实现路由映射，直接用add_url_rule来实现路由映射从而和django类似的效果
'''
@app.route('/', methods=['GET', 'POST'], endpoint='n1')
def index():
redirect_url = url_for('login')
return redirect(redirect_url)
return u'您已经登录'
def login():
return 'login'
#其中 endpoint相当于别名，可以传None 最终会去view_func.__name__，也是视图函数名称
#路由类似django实现方式
app.add_url_rule('/login', 'n2', login, methods=['GET', 'POST'])
if __name__ == '__main__':
app.run()
@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"] 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, 重定向到指定地址 如： @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'] = 'oldboyedu.com:5000'
@app.route("/", subdomain="admin")
def static_index():
"""Flask supports static subdomains
This is available at static.your-domain.tld"""
return "xxxxxx.your-domain.tld"
@app.route("/dynamic", subdomain="<username>")
def username_index(username):
"""Dynamic subdomains are also supported
Try going to user1.your-domain.tld/dynamic"""
return username + ".your-domain.tld"
if __name__ == '__main__':
app.run()
CBV和FBV
- FBV（function base views） 就是在视图里使用函数处理请求
- CBV（class base views） 就是在视图里使用类处理请求
在flask中，可以继承views.MethodView来实现CBV的效果
# -*- coding:utf-8 -*-
from flask import Flask,url_for,redirect,render_template,session,request,views
# from flask_sqlalchemy import SQLAlchemy
from exchange import db
import config
app = Flask(__name__)
app.config.from_object(config)
# db = SQLAlchemy(app)
db.init_app(app)
# with app.app_context():
# db.create_all()
def auth(func):
def inner(*args, **kwargs):
result = func(*args, **kwargs)
return result
return inner
class IndexView(views.MethodView):
methods = ['GET']
decorators = [auth,]
def get(self):
return 'Index.GET'
def post(self):
return 'Index.POST'
app.add_url_rule('/index', view_func=IndexView.as_view(name='index')) #name = endpoint
'''
不难发现IndexView.as_view(name='index')的执行结果还是一个函数
我们看as_view里源码：
请求到来前：
1.定义 返回 内部自定义的一个view函数对象
def view(*args, **kwargs):
self = view.view_class(*class_args, **class_kwargs)
return self.dispatch_request(*args, **kwargs)
2.给view函数套装饰器
if cls.decorators:
view.__name__ = name
view.__module__ = cls.__module__
for decorator in cls.decorators:
view = decorator(view)
3.给view绑定各种属性：视图类，别名，请求方法
view.view_class = cls
view.__name__ = name
view.methods = cls.methods
请求到来时：
执行view函数，实例IndexView视图类对象，执行dispatch_request方法
在dispatch_request函数干了一件啥事了，获取请求里的method，然后去视图对象里getattr映射，并执行该方法
'''
if __name__ == '__main__':
app.run()
路由匹配
flask默认支持以下五种路由匹配
- @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,
}
如果上述还不能满足你的需求，flask还提供了扩展的方式
from flask import Flask, views, url_for
from werkzeug.routing import BaseConverter
app = Flask(import_name=__name__)
# 1. 写RegexConverter类
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:
"""
# "123"
return int(value)
def to_url(self, value):
"""
使用url_for反向生成URL时，传递的参数经过该方法处理，返回的值用于生成URL中的参数
:param value:
:return:
"""
val = super(RegexConverter, self).to_url(value)
return val
# 2. 将RegexConverter添加到flask中
app.url_map.converters['regex'] = RegexConverter
@app.route('/index/<regex("\d+"):nid>')
def index(nid):
print(nid,type(nid))
url_for('index',nid=89)
return 'Index'
if __name__ == '__main__':
app.run()
这里还需要思考一个问题，那就是如果进行登录验证再加上一个装饰器，应该怎么加呢？
如果加上最上面的话，那url和视图函数对应关系加不上(这主要和多个装饰器原理有关系，验证一下)，也只能加在路由下面了，不过这样也还有一个小问题，那就是flask映射路由时，默认使用装饰器下面的视图函数名，现在把登录装饰器夹在中间，就使用登录装饰器返回的函数名，比如inner，所有的路由映射都用这个就会报错，解决方法有两个，一个是不使用默认的，用endpoint进行别名，另外一个就是让登录装饰器保留装饰的视图函数的元信息，所以在定义登录装饰器时，在内存函数使用@functools.wraps(f)进行装饰
4.模板
flask使用是jinja2模板，语法上和django无差别
对flask模板里的自定义方法，使用起来非常的简洁，你只要在后端定义好函数，通过模板渲染参数的形式传给前端调用(调用时，加括号，这一点和django的稍微不同)
#!/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()
flask默认是帮我们做了防xss攻击的，如果想给前端返回标签，前端可通过管道符{{xx()|safe}}，后端则可以用Markup，类似于django里的mark_safe
除了上述以外，flask中还提供了一种自定义宏的方式，就相当于定义好了一个组件，在其他的地方可以重复调用
<!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>
5.请求和响应
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()
6.session
上面所有的请求数据都会封装在request对象里，flask里也有session这么一个对象，用于提供session相关操作，它允许你在不同请求间存储特定用户的信息，并且是基于cookie实现，要求是加密cookie，所以你使用前需要设置一个密钥，app.secret_key
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'
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)
#!/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()
7.闪现
闪现就是对临时数据进行存取，用完即焚，本质上是基本flask的session来实现的，取的时候用的是pop
多用于正常流程里，不同路由之间的临时数据共享：比如正常访问页面发生错误，跳转到提示错误路由（错误信息的共享）
from flask import Flask,flash,get_flashed_messages,request,redirect
app = Flask(__name__)
app.secret_key = 'asdfasdf'
@app.route('/index')
def index():
# 从某个地方获取设置过的所有值，并清除。
val = request.args.get('v')
if val == 'oldboy':
return 'Hello World!'
flash('超时错误',category="x1")
return "ssdsdsdfsd"
# return redirect('/error')
@app.route('/error')
def error():
"""
展示错误信息
:return:
"""
data = get_flashed_messages(category_filter=['x1'])
if data:
msg = data[0]
else:
msg = "..."
return "错误信息：%s" %(msg,)
if __name__ == '__main__':
app.run()
8.请求扩展
主要是对请求前和请求后，还有发生错误时，以及类似于django自定义simple_tag等相关功能的扩展
定义多个请求前函数和请求后函数时的执行顺序：请求前是按照定义函数时，从上往下的顺序，请求后则相反，从下往上，如果在请求前函数，请求中断，请求后函数还是按照规则执行所有
请求前继续执行返回None，而请求后继续执行返回response回调参数
应用场景：请求前对登录进行验证，权限控制，请求前后缓存的操作...
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from flask import Flask, Request, render_template
app = Flask(__name__, template_folder='templates')
app.debug = True
@app.before_first_request
def before_first_request1():
print('before_first_request1')
@app.before_first_request
def before_first_request2():
print('before_first_request2')
@app.before_request
def before_request1():
Request.nnn = 123
print('before_request1')
@app.before_request
def before_request2():
print('before_request2')
@app.after_request
def after_request1(response):
print('before_request1', response)
return response
@app.after_request
def after_request2(response):
print('before_request2', response)
return response
@app.errorhandler(404)
def page_not_found(error):
return 'This page does not exist', 404
@app.template_global()
def sb(a1, a2):
return a1 + a2
@app.template_filter()
def db(a1, a2, a3):
return a1 + a2 + a3
@app.route('/')
def hello_world():
return render_template('hello.html')
if __name__ == '__main__':
app.run()
调用方式：{{sb(1,2)}} {{ 1|db(2,3)}}
9.中间件
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)
10.蓝图
蓝图主要干啥的呢？主要是帮我们构造程序目录的
你可以把蓝图理解为代理模式的一种，每个蓝图负责自己范围，比如url映射，渲染模板，和请求扩展，而app对象就是代理对象，负责接收所有的请求，并决定分发给哪个蓝图
蓝图具备以下优点：
- 防止相互导入
- 批量设置url，添加前缀 xxx = Blueprint('account', __name__,url_prefix='/xxx')
- 请求扩展针对单个蓝图和针对app，比如登录验证，就不要设置白名单，只需要登录验证蓝图下进行请求扩展
大型应用程序：示例
小型应用程序：示例
