Python之flask总计

一、flask

Python之flask总结,pythonflask

一、flask

     a、Flask是1个依据Python开辟并且重视jinja二模板和Werkzeug
WSGI服务的三个袖珍框架,对于Werkzeug本质是Socket服务端,其用于收纳http请求并对请求举办预处理,然后触发Flask框架,开拓人士基于Flask框架提供的意义对请求举行相应的拍卖,并回到给用户,假使要回去给用户复杂的情节时,必要借助jinja二模板来落到实处对模板的处理,即:将模板和数据进行渲染,将渲染后的字符串再次来到给用户浏览器

     b、“微”(micro) 并不意味着你需求把方方面面 Web 应用塞进单个 Python
文件(纵然真正能够 ),也不代表 Flask
在功用上具有欠缺。微框架中的“微”意味着 Flask
目的在于维持主旨轻易而易于扩张。Flask
不会替你做出太多决策——比如利用何种数据库。而那多少个 Flask
所选用的——比如采纳何种模板引擎——则很轻巧替换。除了那些之外的整套都由可由你调整。如此,Flask
能够与你相反相成。

     c、默许景况下,Flask
不带有数据库抽象层、表单验证,或是其余任何已有多种库能够胜任的法力。可是,Flask
支持用扩大来给选取增多那一个意义,就如是 Flask
自身实现的同样。众多的扩充提供了数据库集成、表单验证、上传处理、各样各种的怒放认证手艺等作用。Flask
大概是“微小”的,但它已准备幸亏须要繁杂的生育环境中投入使用。

二、安装

      a、安装:pip3 install flask**

三、虚拟环境

**      a、安装: pip3 install virtualenv**

      b、# 创立虚拟环境 virtualenv env1

      c、# 进入虚拟环境 Scripts/activate

      d、 # 退出虚拟环境 Scripts/deactivate

四、flask框架**

**      a、简单介绍:轻量级框架                    
 Django:无socket、中间件、路由系统、视图(CBV,FBV)、
模板、O奥迪Q5M、cookie、Session、Admin、Form、缓存、时域信号、连串化….                    
 Flask:无socket、中间件(扩大)、路由系统、视图(CBV)、第贰方模板(jinja二)、cookie、Session弱爆了**

**      b、 什么是wsgi?
                           Web服务网管接口,协议。**

**      c、Flask重视3个落到实处了WSGI协议的模块:werkzeug**

五、flask

       a、 -依赖于wsgi模块:wsgiref,werkzeug,wsgi

       b、  -实例化Flask对象

                  -静态文件前缀  /xxx

                  -静态文件目录

                  -模板路径

        c、 加多路由关系      

                  -将
Rule(url和视图函数)增加到Flask对象的url_map字段中

                  -二种增多路由的艺术

        d、request

                 -request.form

                 -request.args 

6、基本使用

from flask import Flask

# 实例化Flask对象
app = Flask(__name__)

# 生成路由关系,并把关系保存到某个地方,app对象的 url_map字段中
@app.route('/xxxx')  # @decorator
def index():
    return "Index"

# def index():
#     return "Index"
# app.add_url_rule('/xxx', "n1", index)

if __name__ == '__main__':
    # 启动程序,监听用户请求
    # 一旦请求到来,执行 app.__call__方法
    # 封装用户请求
    # 进行路由匹配
    app.run()

     a、保留session的数额存到了浏览器上,
        - 优点:减轻了服务端的压力
        - 缺点:不安全

     b、路由系统:  

  • @app.route(‘/post/<path:path>’)
  • @app.route(‘/login’, methods=[‘GET’, ‘POST’])

  • @app.route(‘/user/<username>’)
  • @app.route(‘/post/<int:post_id>’)
  • @app.route(‘/post/<float:post_id>’)

七、路由系统**

**     a、  -可传唱参数**     **

            @app.route(‘/user/<username>’)

           
@qpp.route(‘/post/<int:post_id>’,methods=[‘GET’,’POST’],endpoint=’fff’)

     b、反向生成U中华VL:url_for**

     c、增添Flask的路由系统,让它帮助正则:**

from flask import Flask,url_for

                app = Flask(__name__)

                # 定义转换的类
                from werkzeug.routing import BaseConverter
                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)

                    def to_url(self, value):
                        """
                        使用url_for反向生成URL时,传递的参数经过该方法处理,返回的值用于生成URL中的参数
                        :param value: 
                        :return: 
                        """
                        val = super(RegexConverter, self).to_url(value)
                        return val

                # 添加到converts中
                app.url_map.converters['xxx'] = RegexConverter

                # 进行使用
                @app.route('/index/<xxx("\d+"):nid>',endpoint='xx')
                def index(nid):
                    url_for('xx',nid=123)
                    return "Index"

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

八、请求响应

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

    a、在django中用make_safe而在Flask中用make_response

九、模板语言   **

     a、模板的选用

               Flask使用的是Jinja二模板,所以其语法和Django未有差距

     b、自定义模板方法

             
 Flask中自定义模板方法的主意和Bottle相似,创设三个函数并通过参数的花样传播render_template,

十、session 

      a、 -session是或不是还有其余方法?

                     -它与字典方法一致

      b、  -session超时时间什么设置:**

app.config['SESSION_COOKIE_NAME'] = 'session_lvning'
            """
            '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,
            'PERMANENT_SESSION_LIFETIME':           timedelta(days=31)

     c、除请求对象之外,还有三个 session
对象。它同意你在差异请求间存储特定用户的音信。它是在 库克ies
的根底上贯彻的,并且对 Cookies
实行密钥签字要选用会话,你必要设置2个密钥。

     d、

  • 设置:session[‘username’] = ‘xxx’

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

十一、闪现(flash)**

   
 a、
session从在在服务端的3个字典中,session保存的数码取3次,它照旧会有。而flash是依照session创设的,flash辅助在里边放值,只要在里面取值它就会并未。闪现正是**

   
 b、在session的根底上,把它的值真实的位于session上,当去它的时候不仅把它的值取走,还把session的事物去掉。

十二、蓝图**

     a、蓝图用于为运用提供目录划分**

  • 蓝图URL前缀:xxx = Blueprint(‘account’,
    __name__,url_prefix=’/xxx’)
  • 蓝图子域名:xxx = Blueprint(‘account’,
    __name__,subdomain=’admin’)

    # 前提须求给配置SELacrosseVE智跑_NAME: app.config[‘SERVER_NAME’] =
    ‘wupeiqi.com:5000’

    # 访问时:admin.wupeiqi.com:5000/login.html

十三、DBUtils**

      a、DBUtils是Python的八个用以落到实处数据库连接池的模块。**

      b、Python之flask总计。连接池的三种情势:**

            (一)、第二种方式:

                               
 它的瑕疵:每三遍呼吁反复创立数据库的链接,链接的次数太多

             (2)、第几种形式:

                                 它的败笔:不能够支撑并发

              (3)、第二种格局:

                                它是依据DBUtils完毕数据库连接池

                                       
-为各种线程创制3个链接,该线程关闭时,不是确实的关闭,本线程再一次调用时,依然采用的最早先的创始的链接,知道线程终止,数据库链接才关闭

                                     
 -制造多个连接池(十三个链接),为拥有线程提供链接,使用时来展开获取,使用实现时,再度放回到连接池。

       c、DBUtils的应用:**

import time
import pymysql
import threading
from DBUtils.PooledDB import PooledDB, SharedDBConnection
POOL = PooledDB(
    creator=pymysql,  # 使用链接数据库的模块
    maxconnections=6,  # 连接池允许的最大连接数,0和None表示不限制连接数
    mincached=2,  # 初始化时,链接池中至少创建的空闲的链接,0表示不创建
    maxcached=5,  # 链接池中最多闲置的链接,0和None不限制
    maxshared=3,  # 链接池中最多共享的链接数量,0和None表示全部共享。PS: 无用,因为pymysql和MySQLdb等模块的 threadsafety都为1,所有值无论设置为多少,_maxcached永远为0,所以永远是所有链接都共享。
    blocking=True,  # 连接池中如果没有可用连接后,是否阻塞等待。True,等待;False,不等待然后报错
    maxusage=None,  # 一个链接最多被重复使用的次数,None表示无限制
    setsession=[],  # 开始会话前执行的命令列表。如:["set datestyle to ...", "set time zone ..."]
    ping=0,
    # ping MySQL服务端,检查是否服务可用。# 如:0 = None = never, 1 = default = whenever it is requested, 2 = when a cursor is created, 4 = when a query is executed, 7 = always
    host='127.0.0.1',
    port=3306,
    user='root',
    password='123',
    database='pooldb',
    charset='utf8'
)

十四、session

      a、 session和cookie的规律和区分:

               cookie是保存在浏览器上的键值对
             
 session是存在服务端的键值对(服务端的session便是3个大字典,字典中是随机字符串)(session与request原理同样)(session原理跟上下文也有涉及)

               session依赖于cookie存在**

**      b、  session流程**      **

当请求第一次进来,生成随机字符串
                  -发给用户cookie
                  -保存到session字典中时
                  它调用stark将随机字符串和对应的值放到local
                视图函数
                 -使用时导入用top(它拿的是session)
                     session=LocalProxy(partile(_lookup_req_object,'session '))
               请求处理完毕:
                     内存处理完毕后,将session做持久化(session存到数据库,存到Redis,存到加密的cookie中)

十五、session源码解析

     a、先执行Flask的__call__方法
,调用出来wsgi_app,它先做request的上下文做完,请求刚进来到push中,它先处理request将呼吁相关的数目,然后加多到了local中,

   
 b、 紧接着处理session(将RequestContext对象(request,session)增加到local中),request(将request消息打包到Request(environ)对象并复制给requestContext
对                     
 象),然后拿走cookie中的随机字符串,核实是否有,未有就变化。依照随便字符串,获取服务端session保存的值。把session放到内部存款和储蓄器中,

   
 c、  执行wsgi_app方法上边包车型客车视图函数。推行完视图函数再次回到到full_dispatch_requesthong
,触发只进行三回的装饰器中(触发Flask时域信号),

   
 d、  施行完那个装饰器,紧接着施行上面包车型地铁杰出的装饰器,假如这一个新鲜装饰器未有重临值,那么rv=None,固然有再次来到值,页面时就显得那个重回值,

   
 e、如若未有重返值,触发推行那多少个视图函数,拿重临值。请求试行完回到后,调用finalize_request,对它的重临值举办李包裹装。

十六、Flask和Django的区别 

     a、请求相关的数量           

                  -Django:参数

                  -Flask:    基于Local,LocalStark对象

     b、 七个请求进入会不会搅乱            

                  -单线程

                  -多线程

                  -协程

                    解决: from greenlet import getcurrent as
get_ident

十七、**Flask**信号

    a、 Flask框架中的时域信号基于blinker**

    b、安装: pip3 install blinker**

    c、11个实信号

1. 内置信号
            10个信号:
                2. request_started = _signals.signal('request-started')                # 请求到来前执行
                5. request_finished = _signals.signal('request-finished')              # 请求结束后执行

                3. before_render_template = _signals.signal('before-render-template')  # 模板渲染前执行
                4. template_rendered = _signals.signal('template-rendered')            # 模板渲染后执行

                2/3/4/5或不执行 got_request_exception = _signals.signal('got-request-exception')    # 请求执行出现异常时执行

                6. request_tearing_down = _signals.signal('request-tearing-down')      # 请求执行完毕后自动执行(无论成功与否)
                7. appcontext_tearing_down = _signals.signal('appcontext-tearing-down')# 请求上下文执行完毕后自动执行(无论成功与否)


                1. appcontext_pushed = _signals.signal('appcontext-pushed')            # 请求app上下文push时执行

                8. appcontext_popped = _signals.signal('appcontext-popped')            # 请求上下文pop时执行

                message_flashed = _signals.signal('message-flashed')                   # 调用flask在其中添加数据时,自动触发

   
 d、flask复信号本生本人不曾,用的是人家的,并且这么些时限信号通过装饰器全体方可取代了的,不过Django里面有些标新立异的
正是那么些model操作根本未有装饰器,就是同过内置的实信号来成功的

十八、django内置的功率信号

Request/response signals
                    request_started             # 请求到来前,自动触发
                    request_finished            # 请求结束后,自动触发
                    got_request_exception       # 请求异常后,自动触发

                Model signals
                    pre_init                    # django的modal执行其构造方法前,自动触发
                    post_init                   # django的modal执行其构造方法后,自动触发

                    pre_save                    # django的modal对象保存前,自动触发
                    post_save                   # django的modal对象保存后,自动触发

                    pre_delete                  # django的modal对象删除前,自动触发
                    post_delete                 # django的modal对象删除后,自动触发

                    m2m_changed                 # django的modal中使用m2m字段操作第三张表(add,remove,clear)前后,自动触发

                    class_prepared              # 程序启动时,检测已注册的app中modal类,对于每一个类,自动触发

                Management signals
                    pre_migrate                 # 执行migrate命令前,自动触发
                    post_migrate                # 执行migrate命令后,自动触发

                Test signals
                    setting_changed             # 使用test测试修改配置文件时,自动触发
                    template_rendered           # 使用test测试渲染模板时,自动触发
                Database Wrappers
                    connection_created          # 创建数据库连接时,自动触发

十九、Wtform

    a、WTForms是1个支撑七个web框架的form组件,重要用于对用户请求数据开始展览表达。

    b、安装: pip3 install wtform

    c、用途:**

**       1、用户登六注册**

 
           
 当用户登6时候,要求对用户提交的用户名和密码进行各个格式校验。如:

             
用户无法为空;用户长度必须大于陆;

             
密码无法为空;密码长度必须高于12;密码必须带有
字母、数字、特殊字符等(自定义正则);

亚洲必赢官网 1

#!/usr/bin/env python
# -*- coding:utf-8 -*-
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 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)(?=.*[[email protected]$!%*?&])[A-Za-z\[email protected]$!%*?&]{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()

app.py
亚洲必赢官网 2

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

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

login

二十、SQLALchemy

    a、介绍 :      

           SQLALchemy是1个根据Python完毕的O智跑M框架。该框架是确立在DB
API之上,使用关系对象映射举行数据库操作

         
 简言之便便是:将类和目的转变到SQL,然后选用数据API推行SQL并获取推行的结果

    b、安装: pip3 install SQLALchemy

    c、组成都部队分**

 engine,                                     框架的引擎

     Connection  Pooling  ,                      数据库连接池

     Dialect,                                    选择链接数据库的DB  API种类

     Schema /Types,                              架构和类型     

     SQL Exprression Language,                   SQL表达式语言

   
d、SQLALcheam外省不能操作数据库,其必须来pymysql等第一方插件, Dialect用于数据API的沟通,依据安插文件的不等**

调用差别的数据库API,从而完毕对数据库的操作

MySQL-Python
    mysql+mysqldb://<user>:<password>@<host>[:<port>]/<dbname>

pymysql
    mysql+pymysql://<username>:<password>@<host>/<dbname>[?<options>]

MySQL-Connector
    mysql+mysqlconnector://<user>:<password>@<host>[:<port>]/<dbname>

cx_Oracle
    oracle+cx_oracle://user:pass@host:port/dbname[?key=value&key=value...]

更多:http://docs.sqlalchemy.org/en/latest/dialects/index.html

 

 

  

 

一、flask
a、Flask是3个依据Python开辟并且正视jinja二模板和Werkzeug
WSGI服务的3个微型框架,对于Werkzeug本质是Sock…

1.Flask:

1.Flask:

   
 a、Flask是贰个依据Python开拓并且重视jinja二模板和Werkzeug
WSGI服务的三个小型框架,对于Werkzeug本质是Socket服务端,其用于收纳http请求并对请求举行预处理,然后触发Flask框架,开辟人士基于Flask框架提供的效率对请求进行相应的拍卖,并重回给用户,如若要赶回给用户复杂的故事情节时,要求借助jinja2模板来促成对模板的拍卖,即:将模板和数量开始展览渲染,将渲染后的字符串重回给用户浏览器

Flask是一个基于Python开荒并且注重jinja二模板和Werkzeug
WSGI服务的一个小型框架,对于Werkzeug本质是Socket服务端,其用来吸收接纳http请求并对请求举办预处理,然后触发Flask框架,开垦人士基于Flask框架提供的效果对请求进行对应的处理,并赶回给用户,假诺要赶回给用户复杂的始末时,要求借助jinja二模板来促成对模板的拍卖,即:将模板和数量实行渲染,将渲染后的字符串重返给用户浏览器。

Flask是三个遵照Python开采并且正视jinja2模板和Werkzeug
WSGI服务的二个小型框架,对于Werkzeug本质是Socket服务端,其用于收纳http请求并对请求举行预处理,然后触发Flask框架,开采人士基于Flask框架提供的效劳对请求举行相应的拍卖,并赶回给用户,就算要赶回给用户复杂的始末时,供给借助jinja二模板来促成对模板的拍卖,即:将模板和数量开始展览渲染,将渲染后的字符串再次来到给用户浏览器。

     b、“微”(micro) 并不意味你需求把全部Web 应用塞进单个 Python 文件(固然真正能够 ),也不代表 Flask
在职能上具有欠缺。微框架中的“微”意味着 Flask
意在维持大旨轻易而易于扩张。Flask
不会替你做出太多决策——比如利用何种数据库。而这多少个 Flask
所挑选的——比如选择何种模板引擎——则很轻易替换。除了这么些之外的任何都由可由你左右。如此,Flask
能够与您相得益彰。

“微”(micro)
并不表示你供给把全体 Web 应用塞进单个 Python 文件(即便真正可以),也不意味 Flask 在效益上有所欠缺。微框架中的“微”意味着 Flask
目的在于保持主旨轻松而易于扩大。Flask
不会替你做出太多决策——比如动用何种数据库。而那个 Flask
所挑选的——比如利用何种模板引擎——则很轻巧替换。除此而外的上上下下都由可由你左右。如此,Flask
能够与你相反相成。

“微”(micro)
并不代表您需求把全路 Web 应用塞进单个 Python 文件(即使真正可以),也不意味 Flask 在职能上保有欠缺。微框架中的“微”意味着 Flask
目的在于保证基本轻便而易于扩大。Flask
不会替你做出太多决策——比如选取何种数据库。而那多少个 Flask
所采用的——比如动用何种模板引擎——则很轻易替换。除此而外的成套都由可由你驾驭。如此,Flask
可以与您相反相成。

     c、暗中认可情形下,Flask
不分包数据库抽象层、表单验证,或是其余任何已有种种库可以胜任的效果。但是,Flask
协理用增加来给使用增添那么些成效,就如是 Flask
自身完成的同等。众多的增添提供了数据库集成、表单验证、上传处理、种种各种的开放认证工夫等职能。Flask
可能是“微小”的,但它已预备还好须要繁杂的生育条件中投入使用。

私下认可情状下,Flask
不含有数据库抽象层、表单验证,或是其余任何已有两种库能够胜任的功力。不过,Flask
接济用扩张来给使用增多那些功用,就如是 Flask
自个儿实现的1模一样。众多的扩张提供了数据库集成、表单验证、上传处理、各样种种的盛开认证本事等效果。Flask
或者是“微小”的,但它已准备万幸需要繁杂的生产条件中投入使用。

暗中同意意况下,Flask
不带有数据库抽象层、表单验证,或是其余任何已有各个库能够胜任的效用。但是,Flask
支持用扩展来给接纳增添那个意义,就好像是 Flask
自个儿实现的一样。众多的恢弘提供了数据库集成、表单验证、上传处理、各类各种的怒放认证本领等功效。Flask
或许是“微小”的,但它已准备幸亏急需繁杂的生育环境中投入使用。

二、安装

安装:pip3
install flask

安装:pip3
install flask

      a、安装:pip3 install flask**

 

 

3、虚拟环境

亚洲必赢官网 3亚洲必赢官网 4

亚洲必赢官网 5亚洲必赢官网 6

**      a、安装: pip3 install virtualenv**

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
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

      b、# 成立虚拟环境 virtualenv env1

View Code

View Code

      c、# 进入虚拟环境 Scripts/activate

 

 

      d、 # 退出虚拟环境 Scripts/deactivate

2.
虚拟环境

贰.
虚拟环境

四、flask框架**

安装:   pip3 install virtualenv

        # 创建虚拟环境
        virtualenv env1 

        # 进入虚拟环境
               Scripts/activate

        # 退出虚拟环境
              Scripts/deactivate
安装:   pip3 install virtualenv

        # 创建虚拟环境
        virtualenv env1 

        # 进入虚拟环境
               Scripts/activate

        # 退出虚拟环境
              Scripts/deactivate

**      a、简单介绍:轻量级框架                    
 Django:无socket、中间件、路由系统、视图(CBV,FBV)、
模板、OEvoqueM、cookie、Session、Admin、Form、缓存、复信号、连串化….                    
 Flask:无socket、中间件(扩展)、路由系统、视图(CBV)、第3方模板(jinja2)、cookie、Session弱爆了**

3.flask框架

3.flask框架

**      b、 什么是wsgi?
                           Web服务网管接口,协议。**

   
 简要介绍:轻量级框架

     
            Django:无socket、中间件、路由系统、视图(CBV,FBV)、
模板、ORAV四M、cookie、Session、Admin、Form、缓存、                         
         连续信号、类别化….

     
             
 Flask:无socket、中间件(扩充)、路由系统、视图(CBV)、第二方模板(jinja贰)、cookie、Session弱爆了

   
 简单介绍:轻量级框架

     
            Django:无socket、中间件、路由系统、视图(CBV,FBV)、
模板、OPAJEROM、cookie、Session、Admin、Form、缓存、                         
         实信号、类别化….

     
             
 Flask:无socket、中间件(扩张)、路由系统、视图(CBV)、第二方模板(jinja贰)、cookie、Session弱爆了

**      c、Flask正视3个完成了WSGI协议的模块:werkzeug**

     
             a. 什么是wsgi?

     
                     Web服务网管接口,协议。

     
             a. 什么是wsgi?

     
                     Web服务网管接口,协议。

五、flask

     
             b. Flask正视多少个兑现了WSGI协议的模块:werkzeug

     
             b. Flask正视三个兑现了WSGI协议的模块:werkzeug

       a、 -依赖于wsgi模块:wsgiref,werkzeug,wsgi

flask

flask

       b、  -实例化Flask对象

     
-依赖于wsgi模块:wsgiref,werkzeug,wsgi

     
-依赖于wsgi模块:wsgiref,werkzeug,wsgi

                  -静态文件前缀  /xxx

      -实例化Flask对象

      -实例化Flask对象

                  -静态文件目录

           -静态文件前缀  /xxx

           -静态文件前缀  /xxx

                  -模板路线

           -静态文件目录

           -静态文件目录

        c、 增多路由关系      

           -模板路线

           -模板路径

                  -将
Rule(url和视图函数)增多到Flask对象的url_map字段中

     增多路由关系

     加多路由关系

                  -三种增多路由的点子

           -将
Rule(url和视图函数)增加到Flask对象的url_map字段中

           -将
Rule(url和视图函数)增加到Flask对象的url_map字段中

        d、request

           -二种加多路由的法子

           -二种加多路由的点子

                 -request.form

     request

     request

                 -request.args 

          -request.form

          -request.form

6、基本使用

          -request.args 

          -request.args 

from flask import Flask

# 实例化Flask对象
app = Flask(__name__)

# 生成路由关系,并把关系保存到某个地方,app对象的 url_map字段中
@app.route('/xxxx')  # @decorator
def index():
    return "Index"

# def index():
#     return "Index"
# app.add_url_rule('/xxx', "n1", index)

if __name__ == '__main__':
    # 启动程序,监听用户请求
    # 一旦请求到来,执行 app.__call__方法
    # 封装用户请求
    # 进行路由匹配
    app.run()

四.为主使用:

肆.大旨采取:

     a、保留session的数额存到了浏览器上,
        - 优点:减轻了服务端的下压力
        - 缺点:不安全

from flask import Flask

# 实例化Flask对象
app = Flask(__name__)

# 生成路由关系,并把关系保存到某个地方,app对象的 url_map字段中
@app.route('/xxxx')  # @decorator
def index():
    return "Index"

# def index():
#     return "Index"
# app.add_url_rule('/xxx', "n1", index)

if __name__ == '__main__':
    # 启动程序,监听用户请求
    # 一旦请求到来,执行 app.__call__方法
    # 封装用户请求
    # 进行路由匹配
    app.run()
from flask import Flask

# 实例化Flask对象
app = Flask(__name__)

# 生成路由关系,并把关系保存到某个地方,app对象的 url_map字段中
@app.route('/xxxx')  # @decorator
def index():
    return "Index"

# def index():
#     return "Index"
# app.add_url_rule('/xxx', "n1", index)

if __name__ == '__main__':
    # 启动程序,监听用户请求
    # 一旦请求到来,执行 app.__call__方法
    # 封装用户请求
    # 进行路由匹配
    app.run()

     b、路由系统:  

练习:

练习:

  • @app.route(‘/post/<path:path>’)
  • @app.route(‘/login’, methods=[‘GET’, ‘POST’])
from flask import Flask,render_template,request,redirect,session
app = Flask(__name__)
app.secret_key = "sdsfdsgdfgdfgfh"

def wrapper(func):
    def inner(*args,**kwargs):
        if not session.get("user_info"):
            return redirect("/login")
        ret = func(*args,**kwargs)
        return ret
    return inner

@app.route("/login",methods=["GET","POST"])
def login():
    if request.method=="GET":
        return render_template("login.html")
    else:
        # print(request.values)   #这个里面什么都有,相当于body
        username = request.form.get("username")
        password = request.form.get("password")
        if username=="haiyan" and password=="123":
            session["user_info"] = username
            # session.pop("user_info")  #删除session
            return redirect("/index")
        else:
            # return render_template("login.html",**{"msg":"用户名或密码错误"})
            return render_template("login.html",msg="用户名或者密码错误")

@app.route("/index",methods=["GET","POST"])
@wrapper
def index():
    # if not session.get("user_info"):
    #     return redirect("/login")
    return render_template("index.html")


if __name__ == '__main__':
    app.run(debug=True)
from flask import Flask,render_template,request,redirect,session
app = Flask(__name__)
app.secret_key = "sdsfdsgdfgdfgfh"

def wrapper(func):
    def inner(*args,**kwargs):
        if not session.get("user_info"):
            return redirect("/login")
        ret = func(*args,**kwargs)
        return ret
    return inner

@app.route("/login",methods=["GET","POST"])
def login():
    if request.method=="GET":
        return render_template("login.html")
    else:
        # print(request.values)   #这个里面什么都有,相当于body
        username = request.form.get("username")
        password = request.form.get("password")
        if username=="haiyan" and password=="123":
            session["user_info"] = username
            # session.pop("user_info")  #删除session
            return redirect("/index")
        else:
            # return render_template("login.html",**{"msg":"用户名或密码错误"})
            return render_template("login.html",msg="用户名或者密码错误")

@app.route("/index",methods=["GET","POST"])
@wrapper
def index():
    # if not session.get("user_info"):
    #     return redirect("/login")
    return render_template("index.html")


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

保留session的数额存到了浏览器上,
  -
优点:减轻了服务端的下压力

  -
缺点:不安全

封存session的数量存到了浏览器上,
  -
优点:减轻了服务端的压力

亚洲必赢官网 ,  -
缺点:不安全

  • @app.route(‘/user/<username>’)
  • @app.route(‘/post/<int:post_id>’)
  • @app.route(‘/post/<float:post_id>’)

伍.路由系统:

5.路由系统:

七、路由系统**

  • @app.route(‘/post/<path:path>’)
  • @app.route(‘/login’,
    methods=[‘GET’, ‘POST’])
  • @app.route(‘/post/<path:path>’)
  • @app.route(‘/login’,
    methods=[‘GET’, ‘POST’])

**     a、  -可传唱参数**     **

            @app.route(‘/user/<username>’)

  • @app.route(‘/user/<username>’)
  • @app.route(‘/post/<int:post_id>’)
  • @app.route(‘/post/<float:post_id>’)
  • @app.route(‘/user/<username>’)
  • @app.route(‘/post/<int:post_id>’)
  • @app.route(‘/post/<float:post_id>’)

           
@qpp.route(‘/post/<int:post_id>’,methods=[‘GET’,’POST’],endpoint=’fff’)

   
路由系统

   
路由系统

     b、反向生成ULacrosseL:url_for**

     
-可传唱参数

     
-可传唱参数

     c、恢宏Flask的路由系统,让它援救正则:**

     
     @app.route(‘/user/<username>’)

     
     @app.route(‘/user/<username>’)

from flask import Flask,url_for

                app = Flask(__name__)

                # 定义转换的类
                from werkzeug.routing import BaseConverter
                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)

                    def to_url(self, value):
                        """
                        使用url_for反向生成URL时,传递的参数经过该方法处理,返回的值用于生成URL中的参数
                        :param value: 
                        :return: 
                        """
                        val = super(RegexConverter, self).to_url(value)
                        return val

                # 添加到converts中
                app.url_map.converters['xxx'] = RegexConverter

                # 进行使用
                @app.route('/index/<xxx("\d+"):nid>',endpoint='xx')
                def index(nid):
                    url_for('xx',nid=123)
                    return "Index"

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

     
   
 @qpp.route(‘/post/<int:post_id>’,methods=[‘GET’,’POST’],endpoint=’fff’)

     
   
 @qpp.route(‘/post/<int:post_id>’,methods=[‘GET’,’POST’],endpoint=’fff’)

8、请求响应

   
 -反向生成U卡宴L:url_for

   
 -反向生成UTiguanL:url_for

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

   
 -重定向

   
 -重定向

    a、在django中用make_safe而在Flask中用make_response

   
 -扩张Flask的路由系统,让它协助正则:

   
 -扩张Flask的路由系统,让它协助正则:

九、模板语言   **

from flask import Flask,url_for

                app = Flask(__name__)

                # 定义转换的类
                from werkzeug.routing import BaseConverter
                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)

                    def to_url(self, value):
                        """
                        使用url_for反向生成URL时,传递的参数经过该方法处理,返回的值用于生成URL中的参数
                        :param value: 
                        :return: 
                        """
                        val = super(RegexConverter, self).to_url(value)
                        return val

                # 添加到converts中
                app.url_map.converters['xxx'] = RegexConverter

                # 进行使用
                @app.route('/index/<xxx("\d+"):nid>',endpoint='xx')
                def index(nid):
                    url_for('xx',nid=123)
                    return "Index"

                if __name__ == '__main__':
                    app.run()
from flask import Flask,url_for

                app = Flask(__name__)

                # 定义转换的类
                from werkzeug.routing import BaseConverter
                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)

                    def to_url(self, value):
                        """
                        使用url_for反向生成URL时,传递的参数经过该方法处理,返回的值用于生成URL中的参数
                        :param value: 
                        :return: 
                        """
                        val = super(RegexConverter, self).to_url(value)
                        return val

                # 添加到converts中
                app.url_map.converters['xxx'] = RegexConverter

                # 进行使用
                @app.route('/index/<xxx("\d+"):nid>',endpoint='xx')
                def index(nid):
                    url_for('xx',nid=123)
                    return "Index"

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

     a、模板的选用

六.视图函数

6.视图函数

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

Django:
            /index/    func

            /index/    IndexClass.as_view()

        Flask:
            FBV:
                @app.route('/index',endpoint='xx')
                def index(nid):
                    url_for('xx',nid=123)
                    return "Index"



                def index(nid):
                    url_for('xx',nid=123)
                    return "Index"

                app.add_url_rule('/index',index)

            CBV:
                def auth(func):
                    def inner(*args, **kwargs):
                        result = func(*args, **kwargs)
                        return result
                    return inner

                class IndexView(views.MethodView):
                    # methods = ['POST']

                    decorators = [auth,]       #静态字段

                    def get(self):
                        v = url_for('index')
                        print(v)
                        return "GET"

                    def post(self):
                        return "GET"

                app.add_url_rule('/index', view_func=IndexView.as_view(name='index'))

                if __name__ == '__main__':
                    app.run()
Django:
            /index/    func

            /index/    IndexClass.as_view()

        Flask:
            FBV:
                @app.route('/index',endpoint='xx')
                def index(nid):
                    url_for('xx',nid=123)
                    return "Index"



                def index(nid):
                    url_for('xx',nid=123)
                    return "Index"

                app.add_url_rule('/index',index)

            CBV:
                def auth(func):
                    def inner(*args, **kwargs):
                        result = func(*args, **kwargs)
                        return result
                    return inner

                class IndexView(views.MethodView):
                    # methods = ['POST']

                    decorators = [auth,]       #静态字段

                    def get(self):
                        v = url_for('index')
                        print(v)
                        return "GET"

                    def post(self):
                        return "GET"

                app.add_url_rule('/index', view_func=IndexView.as_view(name='index'))

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

     b、自定义模板方法

6.呼吁响应

陆.伸手响应

             
 Flask中自定义模板方法的秘诀和Bottle相似,创建三个函数并透过参数的样式传播render_template,

 

 

十、session 

亚洲必赢官网 7亚洲必赢官网 8

亚洲必赢官网 9亚洲必赢官网 10

      a、 -session是还是不是还有其他艺术?

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

                     -它与字典方法同样

伸手响应

恳请响应

      b、  -session超时时间什么设置:**

 

 

app.config['SESSION_COOKIE_NAME'] = 'session_lvning'
            """
            '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,
            'PERMANENT_SESSION_LIFETIME':           timedelta(days=31)

    –
from urllib.parse import urlencode,quote,unquote

    –
make_response

    –
from urllib.parse import urlencode,quote,unquote

    –
make_response

     c、除请求对象之外,还有四个 session
对象。它同意你在不相同请求间存款和储蓄特定用户的新闻。它是在 Cookies
的底蕴上贯彻的,并且对 库克ies
进行密钥签字要选用会话,你须求设置几个密钥。

在django中用make_safe而在Flask中用make_response

在django中用make_safe而在Flask中用make_response

     d、

 

 

  • 设置:session[‘username’] = ‘xxx’

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

from flask import Flask,url_for,request,redirect,render_template,jsonify,make_response
from urllib.parse import urlencode,quote,unquote
app = Flask(__name__)

@app.route('/index',endpoint='xx')
def index():
    from werkzeug.datastructures import ImmutableMultiDict
    # get_data = request.args
    # get_dict = get_data.to_dict()
    # get_dict['xx'] = '18'
    # url = urlencode(get_dict)
    # print(url)

    # print(request.query_string)
    # print(request.args)

    # val = "%E6%8A%8A%E5%87%A0%E4%B8%AA"
    # print(unquote(val))
    #
    # return "Index"

    # return "Index"
    # return redirect()
    # return render_template()
    # return jsonify(name='alex',age='18')

    response = make_response('xxxxx')
    response.headers['xxx'] = '123123'
    return response


if __name__ == '__main__':
    # app.__call__
    app.run()
from flask import Flask,url_for,request,redirect,render_template,jsonify,make_response
from urllib.parse import urlencode,quote,unquote
app = Flask(__name__)

@app.route('/index',endpoint='xx')
def index():
    from werkzeug.datastructures import ImmutableMultiDict
    # get_data = request.args
    # get_dict = get_data.to_dict()
    # get_dict['xx'] = '18'
    # url = urlencode(get_dict)
    # print(url)

    # print(request.query_string)
    # print(request.args)

    # val = "%E6%8A%8A%E5%87%A0%E4%B8%AA"
    # print(unquote(val))
    #
    # return "Index"

    # return "Index"
    # return redirect()
    # return render_template()
    # return jsonify(name='alex',age='18')

    response = make_response('xxxxx')
    response.headers['xxx'] = '123123'
    return response


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

十一、闪现(flash)**

 

 

   
 a、
session从在在服务端的叁个字典中,session保存的数据取二回,它依旧会有。而flash是根据session创立的,flash支持在中间放值,只要在中间取值它就会并未有。闪现正是**

7.模板语言 
 

7.模板语言 
 

   
 b、在session的根底上,把它的值真实的放在session上,当去它的时候不但把它的值取走,还把session的事物去掉。

   
 a、模板的选取

   
 a、模板的运用

十二、蓝图**

     
         Flask使用的是Jinja二模板,所以其语法和Django无差异

     
         Flask使用的是Jinja二模板,所以其语法和Django无异

     a、蓝图用于为使用提供目录划分**

   
 b、自定义模板方法

   
 b、自定义模板方法

  • 蓝图URL前缀:xxx = Blueprint(‘account’,
    __name__,url_prefix=’/xxx’)
  • 蓝图子域名:xxx = Blueprint(‘account’,
    __name__,subdomain=’admin’)

    # 前提须求给布置SE福特ExplorerVELAND_NAME: app.config[‘SERVER_NAME’] =
    ‘wupeiqi.com:5000’

    # 访问时:admin.wupeiqi.com:5000/login.html

     
       
 Flask中自定义模板方法的办法和Bottle相似,创造三个函数并透过参数的款式传播render_template,如:

     
       
 Flask中自定义模板方法的措施和Bottle相似,创设二个函数并因而参数的款式传播render_template,如:

十三、DBUtils**

亚洲必赢官网 11亚洲必赢官网 12

亚洲必赢官网 13亚洲必赢官网 14

      a、DBUtils是Python的三个用于落到实处数据库连接池的模块。**

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

</body>
</html>

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

</body>
</html>

html

      b、连接池的两种方式:**

html

html

            (一)、第二种情势:

亚洲必赢官网 15亚洲必赢官网 16

亚洲必赢官网 17亚洲必赢官网 18

                               
 它的弱点:每次呼吁反复创设数据库的链接,链接的次数太多

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

run.py
#!/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()

run.py

             (贰)、第二种格局:

run

run

                                 它的短处:无法支撑并发

亚洲必赢官网 19亚洲必赢官网 20

亚洲必赢官网 21亚洲必赢官网 22

              (三)、第二种格局:

<!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>

其他
<!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>

其他

                                它是基于DBUtils实现数据库连接池

其他

其他

                                       
-为各种线程创立多少个链接,该线程关闭时,不是真的的闭馆,本线程再度调用时,还是使用的最发轫的创办的链接,知道线程终止,数据库链接才关闭

8.session

8.session

                                     
 -成立1个连接池(13个链接),为有着线程提供链接,使用时来拓展获取,使用落成时,再度放回到连接池。

   
 -session是不是还有别的措施?

   
 -session是或不是还有别的方法?

       c、DBUtils的应用:**

     
       -它与字典方法一样

     
       -它与字典方法同样

import time
import pymysql
import threading
from DBUtils.PooledDB import PooledDB, SharedDBConnection
POOL = PooledDB(
    creator=pymysql,  # 使用链接数据库的模块
    maxconnections=6,  # 连接池允许的最大连接数,0和None表示不限制连接数
    mincached=2,  # 初始化时,链接池中至少创建的空闲的链接,0表示不创建
    maxcached=5,  # 链接池中最多闲置的链接,0和None不限制
    maxshared=3,  # 链接池中最多共享的链接数量,0和None表示全部共享。PS: 无用,因为pymysql和MySQLdb等模块的 threadsafety都为1,所有值无论设置为多少,_maxcached永远为0,所以永远是所有链接都共享。
    blocking=True,  # 连接池中如果没有可用连接后,是否阻塞等待。True,等待;False,不等待然后报错
    maxusage=None,  # 一个链接最多被重复使用的次数,None表示无限制
    setsession=[],  # 开始会话前执行的命令列表。如:["set datestyle to ...", "set time zone ..."]
    ping=0,
    # ping MySQL服务端,检查是否服务可用。# 如:0 = None = never, 1 = default = whenever it is requested, 2 = when a cursor is created, 4 = when a query is executed, 7 = always
    host='127.0.0.1',
    port=3306,
    user='root',
    password='123',
    database='pooldb',
    charset='utf8'
)

   
-session超时时间怎么设置:

   
-session超时时间怎么样设置:

十四、session

app.config['SESSION_COOKIE_NAME'] = 'session_lvning'
            """
            '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,
            'PERMANENT_SESSION_LIFETIME':           timedelta(days=31)
app.config['SESSION_COOKIE_NAME'] = 'session_lvning'
            """
            '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,
            'PERMANENT_SESSION_LIFETIME':           timedelta(days=31)

      a、 session和cookie的法则和分裂:

除请求对象之外,还有2个session 对象。它同意你在分裂请求间存款和储蓄特定用户的音讯。它是在 库克ies
的功底上完毕的,并且对 Cookies
举办密钥签字要动用会话,你需求安装多少个密钥。

除请求对象之外,还有3个session 对象。它同意你在差别请求间存款和储蓄特定用户的新闻。它是在 Cookies
的基本功上达成的,并且对 Cookies
实行密钥签字要利用会话,你需求设置多个密钥。

               cookie是保存在浏览器上的键值对
             
 session是存在服务端的键值对(服务端的session就是二个大字典,字典中是随机字符串)(session与request原理同样)(session原理跟上下文也有提到)

  • 设置:session[‘username’]
    = ‘xxx’

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

  • 设置:session[‘username’]
    = ‘xxx’

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

               session依赖于cookie存在**

亚洲必赢官网 23亚洲必赢官网 24

亚洲必赢官网 25亚洲必赢官网 26

**      b、  session流程**      **

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'
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'
当请求第一次进来,生成随机字符串
                  -发给用户cookie
                  -保存到session字典中时
                  它调用stark将随机字符串和对应的值放到local
                视图函数
                 -使用时导入用top(它拿的是session)
                     session=LocalProxy(partile(_lookup_req_object,'session '))
               请求处理完毕:
                     内存处理完毕后,将session做持久化(session存到数据库,存到Redis,存到加密的cookie中)

骨干选择

着力采取

十五、session源码解析

亚洲必赢官网 27亚洲必赢官网 28

亚洲必赢官网 29亚洲必赢官网 30

     a、先执行Flask的__call__方法
,调用出来wsgi_app,它先做request的上下文做完,请求刚进来到push中,它先处理request将呼吁相关的数量,然后加多到了local中,

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
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

   
 b、 紧接着处理session(将RequestContext对象(request,session)加多到local中),request(将request信息打包到Request(environ)对象并复制给requestContext
对                     
 象),然后拿走cookie中的随机字符串,核准是否有,未有就转换。依据随便字符串,获取服务端session保存的值。把session放到内部存款和储蓄器中,

自定义session

自定义session

   
 c、  执行wsgi_app方法上面包车型客车视图函数。实践完视图函数再次回到到full_dispatch_requesthong
,触发只实行三次的装饰器中(触发Flask实信号),

亚洲必赢官网 31亚洲必赢官网 32

亚洲必赢官网 33亚洲必赢官网 34

   
 d、  实践完这一个装饰器,紧接着实施下边的奇异的装饰器,假使那一个特殊装饰器未有再次回到值,那么rv=None,借使有重返值,页面时就展现这几个重回值,

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

   
 e、要是未有重回值,触发实施那么些视图函数,拿重临值。请求推行完再次来到后,调用finalize_request,对它的重回值举办打包。

第三方session

第三方session

十六、Flask和Django的区别 

玖.请求扩充

玖.伸手扩充

     a、请求相关的数码           

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

                  -Django:参数

 

 

                  -Flask:    基于Local,LocalStark对象

调用方式:{{sb(1,2)}}  {{ 1|db(2,3)}}
调用方式:{{sb(1,2)}}  {{ 1|db(2,3)}}

     b、 多少个请求进入会不会搅乱            

 

 

                  -单线程

10.闪现(flash)

10.闪现(flash)

                  -多线程

session从在在服务端的一个字典中,session保存的数码取贰回,它照旧会有。而flash是遵照session创设的,flash帮助在里面放值,只要在里面取值它就会未有。闪现便是

session从在在服务端的叁个字典中,session保存的数量取三回,它如故会有。而flash是依据session创立的,flash协助在里头放值,只要在里头取值它就会未有。闪现便是

                  -协程

在session的功底上,把它的值真实的放在session上,当去它的时候不但把它的值取走,还把session的事物去掉。

在session的基本功上,把它的值真实的位于session上,当去它的时候不仅把它的值取走,还把session的事物去掉。

                    解决: from greenlet import getcurrent as
get_ident

闪现的用处:

闪现的用处:

十七、**Flask**信号

 

 

    a、 Flask框架中的时限信号基于blinker**

from flask import Flask,session,Session,flash,get_flashed_messages,redirect,render_template,request
app = Flask(__name__)
app.secret_key ='sdfsdfsdf'

@app.route('/users')
def users():
    # msg = request.args.get('msg','')
    # msg = session.get('msg')
    # if msg:
    #     del session['msg']

    v = get_flashed_messages()
    print(v)
    msg = ''
    return render_template('users.html',msg=msg)

@app.route('/useradd')
def user_add():
    # 在数据库中添加一条数据
    # 假设添加成功,在跳转到列表页面时,显示添加成功
    # return redirect('/users?msg=添加成功')
    # session['msg'] = '添加成功'

    flash('添加成功')
    return redirect('/users')


if __name__ == '__main__':
    app.run()
from flask import Flask,session,Session,flash,get_flashed_messages,redirect,render_template,request
app = Flask(__name__)
app.secret_key ='sdfsdfsdf'

@app.route('/users')
def users():
    # msg = request.args.get('msg','')
    # msg = session.get('msg')
    # if msg:
    #     del session['msg']

    v = get_flashed_messages()
    print(v)
    msg = ''
    return render_template('users.html',msg=msg)

@app.route('/useradd')
def user_add():
    # 在数据库中添加一条数据
    # 假设添加成功,在跳转到列表页面时,显示添加成功
    # return redirect('/users?msg=添加成功')
    # session['msg'] = '添加成功'

    flash('添加成功')
    return redirect('/users')


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

    b、安装: pip3 install blinker**

 

 

    c、十二个信号

11.蓝图

11.蓝图

1. 内置信号
            10个信号:
                2. request_started = _signals.signal('request-started')                # 请求到来前执行
                5. request_finished = _signals.signal('request-finished')              # 请求结束后执行

                3. before_render_template = _signals.signal('before-render-template')  # 模板渲染前执行
                4. template_rendered = _signals.signal('template-rendered')            # 模板渲染后执行

                2/3/4/5或不执行 got_request_exception = _signals.signal('got-request-exception')    # 请求执行出现异常时执行

                6. request_tearing_down = _signals.signal('request-tearing-down')      # 请求执行完毕后自动执行(无论成功与否)
                7. appcontext_tearing_down = _signals.signal('appcontext-tearing-down')# 请求上下文执行完毕后自动执行(无论成功与否)


                1. appcontext_pushed = _signals.signal('appcontext-pushed')            # 请求app上下文push时执行

                8. appcontext_popped = _signals.signal('appcontext-popped')            # 请求上下文pop时执行

                message_flashed = _signals.signal('message-flashed')                   # 调用flask在其中添加数据时,自动触发

蓝图用于为使用提供目录划分

蓝图用于为运用提供目录划分

   
 d、flask时限信号本生本身从没,用的是外人的,并且这几个实信号通过装饰器全体得以代表了的,可是Django里面有个别异样的
就是那么些model操作根本未曾装饰器,正是同过内置的实信号来完结的

 

 

十八、django内置的时限信号

  • 蓝图URL前缀:xxx
    = Blueprint(‘account’, __name__,url_prefix=’/xxx’)
  • 蓝图子域名:xxx
    = Blueprint(‘account’, __name__,subdomain=’admin’)

    #
    前提须要给安顿SE宝马X伍VE瑞虎_NAME: app.config[‘SERVER_NAME’] =
    ‘wupeiqi.com:5000’

    #
    访问时:admin.wupeiqi.com:5000/login.html
  • 蓝图URL前缀:xxx
    = Blueprint(‘account’, __name__,url_prefix=’/xxx’)
  • 蓝图子域名:xxx
    = Blueprint(‘account’, __name__,subdomain=’admin’)

    #
    前提需求给配置SE科雷傲VE奥迪Q5_NAME: app.config[‘SERVER_NAME’] =
    ‘wupeiqi.com:5000’

    #
    访问时:admin.wupeiqi.com:5000/login.html
Request/response signals
                    request_started             # 请求到来前,自动触发
                    request_finished            # 请求结束后,自动触发
                    got_request_exception       # 请求异常后,自动触发

                Model signals
                    pre_init                    # django的modal执行其构造方法前,自动触发
                    post_init                   # django的modal执行其构造方法后,自动触发

                    pre_save                    # django的modal对象保存前,自动触发
                    post_save                   # django的modal对象保存后,自动触发

                    pre_delete                  # django的modal对象删除前,自动触发
                    post_delete                 # django的modal对象删除后,自动触发

                    m2m_changed                 # django的modal中使用m2m字段操作第三张表(add,remove,clear)前后,自动触发

                    class_prepared              # 程序启动时,检测已注册的app中modal类,对于每一个类,自动触发

                Management signals
                    pre_migrate                 # 执行migrate命令前,自动触发
                    post_migrate                # 执行migrate命令后,自动触发

                Test signals
                    setting_changed             # 使用test测试修改配置文件时,自动触发
                    template_rendered           # 使用test测试渲染模板时,自动触发
                Database Wrappers
                    connection_created          # 创建数据库连接时,自动触发

1二.安排文件

1二.布局文件

十九、Wtform

 

 

    a、WTForms是1个补助四个web框架的form组件,首要用以对用户请求数据开展认证。

1. 配置文件
        a. 以后遇到 xxx['xx'] = 123
            - __setitem__
            - 继承dict
            PS: 
                class Foo(dict):
                    def __init__(self,val):
                        dict.__init__(self,val)

                obj = Foo({'xxx':123})
                print(obj)

        b. 配置方式
            # 方式一:
            # app.config['SESSION_COOKIE_NAME'] = 'session_lvning'  #
            # 方式二:
            # app.config.from_pyfile('settings.py')
            # 方式三:
            # import os
            # os.environ['FLAKS-SETTINGS'] = 'settings.py'
            # app.config.from_envvar('FLAKS-SETTINGS')
            # 方式四:
            # app.config.from_object('settings.DevConfig')
1. 配置文件
        a. 以后遇到 xxx['xx'] = 123
            - __setitem__
            - 继承dict
            PS: 
                class Foo(dict):
                    def __init__(self,val):
                        dict.__init__(self,val)

                obj = Foo({'xxx':123})
                print(obj)

        b. 配置方式
            # 方式一:
            # app.config['SESSION_COOKIE_NAME'] = 'session_lvning'  #
            # 方式二:
            # app.config.from_pyfile('settings.py')
            # 方式三:
            # import os
            # os.environ['FLAKS-SETTINGS'] = 'settings.py'
            # app.config.from_envvar('FLAKS-SETTINGS')
            # 方式四:
            # app.config.from_object('settings.DevConfig')

    b、安装: pip3 install wtform

 

 

    c、用途:**

14.中间件

14.中间件

**       1、用户登入注册**

 

 

 
           
 当用户登入时候,要求对用户提交的用户名和密码实行各类格式校验。如:

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

             
用户不能够为空;用户长度必须大于陆;

 

 

             
密码不能够为空;密码长度必须超越1贰;密码必须含有
字母、数字、特殊字符等(自定义正则);

 

 

亚洲必赢官网 35亚洲必赢官网 36

 

 

#!/usr/bin/env python
# -*- coding:utf-8 -*-
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 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()

 

 

app.py

 

 

亚洲必赢官网 37亚洲必赢官网 38

 

 

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

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

 

 

login

 

 

二十、SQLALchemy

 

 

    a、介绍 :      

      

      

           SQLALchemy是一个基于Python完结的OOdysseyM框架。该框架是起家在DB
API之上,使用关系对象映射举办数据库操作

 

 

         
 简言之便正是:将类和目的转变到SQL,然后接纳数据API试行SQL并赢得实行的结果

       

       

    b、安装: pip3 install SQLALchemy

 

 

    c、组成都部队分**

 engine,                                     框架的引擎

     Connection  Pooling  ,                      数据库连接池

     Dialect,                                    选择链接数据库的DB  API种类

     Schema /Types,                              架构和类型     

     SQL Exprression Language,                   SQL表达式语言

   
d、SQLALcheam省外不只怕操作数据库,其必须来pymysql等级一方插件, Dialect用于数据API的沟通,依据安插文件的两样**

调用不相同的数据库API,从而达成对数据库的操作

MySQL-Python
    mysql+mysqldb://<user>:<password>@<host>[:<port>]/<dbname>

pymysql
    mysql+pymysql://<username>:<password>@<host>/<dbname>[?<options>]

MySQL-Connector
    mysql+mysqlconnector://<user>:<password>@<host>[:<port>]/<dbname>

cx_Oracle
    oracle+cx_oracle://user:pass@host:port/dbname[?key=value&key=value...]

更多:http://docs.sqlalchemy.org/en/latest/dialects/index.html

 

 

  

 

网站地图xml地图