Flask基本介绍

Fask

1、Flask简介

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

2、安装

pip install flask

3、werkzeug简介

werkzeug是一个WSGI工具包，他可以作为一个Web框架的底层库。他既不是一个Web服务器，也不是一个web框架，而是一个工具包。它封存了很多web框架的东西，例如，Request ，Response等等。

代码示例：

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)

4、Flask的快速使用

from flask import Flask

# 生成一个flask对象
app = Flask(__name__)


@app.route('/')   # 写路由地址
def index():
    return 'ok'


if __name__ == '__main__':
    app.run()   # 最终调用了run_simple()

5、模板

比django中多可以加括号，执行函数，传参数

from flask import Flask, render_template, render_template_string, Markup,request
app = Flask(__name__)
app.debug = True
def test(a, b):
    return a + b
def test2():
    # 方法一,{{test2()}}
    # aa = Markup('<input type="text" name="name">')
    # return aa
    # 方法二，在html中{{test2()|safe}}，后面加上safe
    return '<input type="text" name="name">'

@app.route('/index')
def index():
    print(request.args)
    aa=request.args.get('name')
    print(aa)
    return render_template('index.html', test2=test2)


if __name__ == '__main__':
    app.run()

index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    {{test()}}
	{{test2()|safe}}
</body>
</html>

注意：

  • Markup等价Django的mark_safe，
  • extends，include一模一样

6、CBV加装饰器

from flask import views, session, redirect, Flask
app = Flask(__name__)
app.debug = True
from functools import wraps
def login_auth(func):
    @wraps
    def inner(*args, **kwargs):
        user = session.get('user')
        if user:
            res = func(*args, **kwargs)
            return res
        else:
            return redirect('/login')
    return inner

class CBVTest(views.MethodView):
    #需要配置能够处理的请求方式
    methods = ['GET', 'POST']
    # 加装饰器，内部循环decorators,包裹as_view返回值（view函数）
    decorators = [login_auth, ]
    # login_auth(函数)
    def get(self):
        return 'cbv-get'
    def post(self):
        return 'cbv=post'


app.add_url_rule('/cbvtest', view_func=CBVTest.as_view(name='cbvtest'))
# name就是endpoint
if __name__ == '__main__':
    app.run(port=8000)

7、app.add_url_rule参数，

@app.route和app.add_url_rule参数：
view_func，视图函数名称
defaults=None,默认值，当URL中无参数，函数需要参数时，使用defaults={'k':'v'}
为函数提供参数
endpoint=None,名称，用于反向生成URL，即:url_for('名称')
metnods=None,允许的请求方式，如：['GET','POST']
#对URL最后的/符号是否严格要求
strict_slashes=None
'''
        @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>')
"""
#子域名的访问
subdomain=None,

8、支持正则

#写类，继承BaseConverter
#注册：app.url_map.converters['regex'] = RegexConverter
# 使用：使用：@app.route('/index/<regex("\d+"):nid>') 正则表达式会当做第二个参数传到类中

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):
        """
        路由匹配时，匹配成功后传递给视图函数中参数的值
        """
        return int(value)

    def to_url(self, value):
        """
        使用url_for反向生成URL时，传递的参数经过该方法处理，返回的值用于生成URL中的参数
        """
        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()

8、Flask中路由的反向解析

  • 正向解析：程序自动解析，根据@app.route()中的访问路径，来匹配处理函数

  • 反向解析：通过视图处理函数的名称自动生成对应的访问路径，在flask中实现反向解析的话要使用：

    url_for(funName,args)
funName:要生成的地址的函数名
args:该地址中需要的参数

    from flask import Flask, url_for
 
app = Flask(__name__)
 
@app.route('/index')
def index():
    return "<h1>这是首页</h1>"
 
@app.route('/admin/login/form/show/<name>')
def show(name):
    return "参数的值为:%s" % name
 
@app.route('/url')
def url():
    #通过index()解析出对应的访问路径
    url_index = url_for('index')
    print("index():"+url_index)
    #通过show(name)解析出对应的访问路径
    url_show = url_for('show',name='wangwc')
    print("show(name):"+url_show)
    return "<a href='%s'>访问show(name)</a>" % url_show
 
 
if __name__ == "__main__":
    app.run(debug=True)

9、请求响应

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')
        #return jsonify({'k1':'v1'})

        # 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()

10、session

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

设置：session['uesr']='xxx
删除：session.pop('user',none)
取值：session['user']

11、闪现

设置值：flash('aaa')

取值：get_flashed_message()

假设在a页面操作出错，跳转到b页面，在b页面显示a页面的错误信息

示例：

from flask import Flask, request, flash, redirect, session, get_flashed_messages

app = Flask(__name__)
app.debug = True
app.secret_key = 'ssdsfff'

@app.route('/index')
def index():
    name = request.args.get('name')
    if name == 'xcc':
        return 'ok'
    else:
        # category='aa',分类存，取
        flash('你的名字不是xcc是%s', category='aa')
        flash('333', category='bb')
        print('我是index')
        return '写入了错误信息'
        # return redirect('/order')

@app.route('/order')
def order():
     m = get_flashed_messages(category_filter=['aa',])
     print(m)
     return 'order--%s' %m[0]
    # print('我是order')
    # return 'order'

if __name__ == '__main__':
    app.run()

12、请求扩展

1、before_request

类比django中间件中的process_request，在请求收到之前绑定一个函数做一些事

基于它做 用户登录认证
@app.before_request
def process_request(*args,**kwargs):
    if request.path=='/login':
        return None
    user=session.get('user')
    if user:
        return None
    return redirect('/login')

2、after_request

类比django中间件中的process_response，每一个请求之后绑定一个函数，如果请求没有异常

@app.after_request
def process_response(re)
print('走了')
return re

3、before_first_request

第一次请求时，跟浏览器无关

@app.before_first_request
def first():
pass

13、蓝图

蓝图的使用：

# 第一步：生成一个蓝图
from flask import Blueprint
# 创建一个蓝图：
order_blue=Blueprint('order',__name__,url_prefix='/app02')
# 第二步:使用
@order_blue.route('/order')
# 第三步:注册
from flask_test.views import order
from flask_test.views import user				app.register_blueprint(order.order_blue)
app.register_blueprint(user.user_blue)

对程序进行目录结构划分

不使用蓝图，自己分文件

目录结构：

-templates
-views
	-__init__.py
    -user.py
    -order.py
-app.py

app.py

from views import app
if __name__ == '__main__':
    app.run()

init.py

from flask import Flask,request
app = Flask(__name__)
#不导入这个不行
from . import account
from . import order
from . import user

user.py

from . import app
@app.route('/user')
def user():
    return 'user'

order.py

from . import app
@app.route('/order')
def order():
    return 'order'

使用蓝图之中小型系统

详见代码：pro_flask_简单应用程序目录示例.zip

目录结构：

-flask_pro
	-flask_test
    	-__init__.py
    	-static
        -templates
        -views
        	-order.py
            -user.py
     -manage.py

_init.py

from flask import  Flask
app=Flask(__name__)
from flask_test.views import user
from flask_test.views import order
app.register_blueprint(user.us)
app.register_blueprint(order.ord)

manage.py

from flask_test import  app
if __name__ == '__main__':
    app.run(port=8008)

user.py

from flask import Blueprint
us=Blueprint('user',__name__)

@us.route('/login')
def login():
    return 'login'

order.py

from flask import Blueprint
ord=Blueprint('order',__name__)

@ord.route('/test')
def test():
    return 'order test'

使用蓝图之大型系统

详见代码：pro_flask_大型应用目录示例.zip

总结：

1 xxx = Blueprint('account', name,url_prefix='/xxx') ：蓝图URL前缀，表示url的前缀，在该蓝图下所有url都加前缀

2 xxx = Blueprint('account', name,url_prefix='/xxx',template_folder='tpls')：给当前蓝图单独使用templates，向上查找，当前找不到，会找总templates

3 蓝图的befort_request，对当前蓝图有效

4 大型项目，可以模拟出类似于django中app的概念

14、中间件

from flask import Flask

app = Flask(__name__)

@app.route('/')
def index():
    return 'Hello World!'
# 模拟中间件
class Md(object):
    def __init__(self,old_wsgi_app):
        self.old_wsgi_app = old_wsgi_app

    def __call__(self,  environ, start_response):
        print('开始之前')
        ret = self.old_wsgi_app(environ, start_response)
        print('结束之后')
        return ret

if __name__ == '__main__':
    #把原来的wsgi_app替换为自定义的
    app.wsgi_app = Md(app.wsgi_app)
    app.run()

15、请求上下文源码分析

第一阶段：将ctx(request,session)放到Local对象上
				   
第二阶段：视图函数导入：request/session 
request.method
	-LocalProxy对象.method,执行getattr方法，getattr(self._get_current_object(), name)
		-self._get_current_object()返回return self.__local()，self.__local()，在LocakProxy实例化的时候,object.__setattr__(self, '_LocalProxy__local', local),此处local就是：partial(_lookup_req_object, 'request')

	-def _lookup_req_object(name):
			top = _request_ctx_stack.top #_request_ctx_stack 就是LocalStack()对象，top方法把ctx取出来
			if top is None:
				raise RuntimeError(_request_ctx_err_msg)
			return getattr(top, name)#获取ctx中的request或session对象

第三阶段：请求处理完毕
		- 获取session并保存到cookie
		- 将ctx删除

程序运行，两个LocalStack()对象，一个里面放request和session，另一个放g和current_app

16、g对象

专门用来存储用户信息的g对象，g的全称的为global

g对象在一次请求中的所有的代码的地方，都是可以使用的

g对象和session的区别

session对象是可以跨request的，只要session还未失效，不同的request的请求会获取到同一个session，但是g对象不是，g对象不需要管过期时间，请求一次就g对象就改变了一次，或者重新赋值了一次

17.flask-session

作用：将默认保存的签名cookie中的值 保存到 redis/memcached/file/Mongodb/SQLAlchemy

安装：pip3 install flask-session

使用1：

from flask import Flask,session
from flask_session import RedisSessionInterface
import redis
app = Flask(__name__)
conn=redis.Redis(host='127.0.0.1',port=6379)
#use_signer是否对key签名
app.session_interface=RedisSessionInterface(conn,key_prefix='lqz')
@app.route('/')
def hello_world():
    session['name']='lqz'
    return 'Hello World!'

if __name__ == '__main__':
    app.run()

使用2：

from redis import Redis
from flask.ext.session import Session
app.config['SESSION_TYPE'] = 'redis'
app.config['SESSION_REDIS'] = Redis(host='192.168.0.94',port='6379')
Session(app)

问题：设置cookie时，如何设定关闭浏览器则cookie失效。

response.set_cookie('k','v',exipre=None)#这样设置即可
#在session中设置
app.session_interface=RedisSessionInterface(conn,key_prefix='lqz',permanent=False)
#一般不用，我们一般都设置超时时间，多长时间后失效

问题：cookie默认超时时间是多少？如何设置超时时间

#源码expires = self.get_expiration_time(app, session)
'PERMANENT_SESSION_LIFETIME':           timedelta(days=31),#这个配置文件控制

18、wtforms

安装:pip3 install wtforms

###使用1：

from flask import Flask, render_template, request, redirect
from wtforms import Form
from wtforms.fields import simple
from wtforms import validators
from wtforms import widgets

app = Flask(__name__, template_folder='templates')

app.debug = True


class LoginForm(Form):
    # 字段（内部包含正则表达式）
    name = simple.StringField(
        label='用户名',
        validators=[
            validators.DataRequired(message='用户名不能为空.'),
            validators.Length(min=6, max=18, message='用户名长度必须大于%(min)d且小于%(max)d')
        ],
        widget=widgets.TextInput(), # 页面上显示的插件
        render_kw={'class': 'form-control'}

    )
    # 字段（内部包含正则表达式）
    pwd = simple.PasswordField(
        label='密码',
        validators=[
            validators.DataRequired(message='密码不能为空.'),
            validators.Length(min=8, message='用户名长度必须大于%(min)d'),
            validators.Regexp(regex="^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[$@$!%*?&])[A-Za-z\d$@$!%*?&]{8,}",
                              message='密码至少8个字符，至少1个大写字母，1个小写字母，1个数字和1个特殊字符')

        ],
        widget=widgets.PasswordInput(),
        render_kw={'class': 'form-control'}
    )



@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'GET':
        form = LoginForm()
        return render_template('login.html', form=form)
    else:
        form = LoginForm(formdata=request.form)
        if form.validate():
            print('用户提交数据通过格式验证，提交的值为：', form.data)
        else:
            print(form.errors)
        return render_template('login.html', form=form)

if __name__ == '__main__':
    app.run()

login.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1>登录</h1>
<form method="post">
    <p>{{form.name.label}} {{form.name}} {{form.name.errors[0] }}</p>

    <p>{{form.pwd.label}} {{form.pwd}} {{form.pwd.errors[0] }}</p>
    <input type="submit" value="提交">
</form>
</body>
</html>

使用2：

from flask import Flask, render_template, request, redirect
from wtforms import Form
from wtforms.fields import core
from wtforms.fields import html5
from wtforms.fields import simple
from wtforms import validators
from wtforms import widgets

app = Flask(__name__, template_folder='templates')
app.debug = True



class RegisterForm(Form):
    name = simple.StringField(
        label='用户名',
        validators=[
            validators.DataRequired()
        ],
        widget=widgets.TextInput(),
        render_kw={'class': 'form-control'},
        default='alex'
    )

    pwd = simple.PasswordField(
        label='密码',
        validators=[
            validators.DataRequired(message='密码不能为空.')
        ],
        widget=widgets.PasswordInput(),
        render_kw={'class': 'form-control'}
    )

    pwd_confirm = simple.PasswordField(
        label='重复密码',
        validators=[
            validators.DataRequired(message='重复密码不能为空.'),
            validators.EqualTo('pwd', message="两次密码输入不一致")
        ],
        widget=widgets.PasswordInput(),
        render_kw={'class': 'form-control'}
    )

    email = html5.EmailField(
        label='邮箱',
        validators=[
            validators.DataRequired(message='邮箱不能为空.'),
            validators.Email(message='邮箱格式错误')
        ],
        widget=widgets.TextInput(input_type='email'),
        render_kw={'class': 'form-control'}
    )

    gender = core.RadioField(
        label='性别',
        choices=(
            (1, '男'),
            (2, '女'),
        ),
        coerce=int # “1” “2”
     )
    city = core.SelectField(
        label='城市',
        choices=(
            ('bj', '北京'),
            ('sh', '上海'),
        )
    )

    hobby = core.SelectMultipleField(
        label='爱好',
        choices=(
            (1, '篮球'),
            (2, '足球'),
        ),
        coerce=int
    )

    favor = core.SelectMultipleField(
        label='喜好',
        choices=(
            (1, '篮球'),
            (2, '足球'),
        ),
        widget=widgets.ListWidget(prefix_label=False),
        option_widget=widgets.CheckboxInput(),
        coerce=int,
        default=[1, 2]
    )

    def __init__(self, *args, **kwargs):
        super(RegisterForm, self).__init__(*args, **kwargs)
        self.favor.choices = ((1, '篮球'), (2, '足球'), (3, '羽毛球'))

    def validate_pwd_confirm(self, field):
        """
        自定义pwd_confirm字段规则，例：与pwd字段是否一致
        :param field:
        :return:
        """
        # 最开始初始化时，self.data中已经有所有的值

        if field.data != self.data['pwd']:
            # raise validators.ValidationError("密码不一致") # 继续后续验证
            raise validators.StopValidation("密码不一致")  # 不再继续后续验证


@app.route('/register', methods=['GET', 'POST'])
def register():
    if request.method == 'GET':
        form = RegisterForm(data={'gender': 2,'hobby':[1,]}) # initial
        return render_template('register.html', form=form)
    else:
        form = RegisterForm(formdata=request.form)
        if form.validate():
            print('用户提交数据通过格式验证，提交的值为：', form.data)
        else:
            print(form.errors)
        return render_template('register.html', form=form)



if __name__ == '__main__':
    app.run()

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1>用户注册</h1>
<form method="post" novalidate style="padding:0  50px">
    {% for field in form %}
    <p>{{field.label}}: {{field}} {{field.errors[0] }}</p>
    {% endfor %}
    <input type="submit" value="提交">
</form>
</body>
</html>
posted @ 2019-02-15 20:07  薛才昌  阅读(545)  评论(0)  编辑  收藏  举报