一、flask

Python之flask总结,pythonflask

一、flask

     a、Flask是二个基于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陆风X8M、cookie、Session、Admin、Form、缓存、非确定性信号、类别化….                    
 Flask:无socket、中间件(扩张)、路由系统、视图(CBV)、第叁方模板(jinja二)、cookie、Session弱爆了**

*Python之flask总括。*      b、 什么是wsgi?
                           Web服务网管接口,协议。**

**      c、Flask依赖三个落到实处了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、反向生成UOdysseyL: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使用的是Jinja2模板,所以其语法和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
对象。它同意你在不相同请求间存款和储蓄特定用户的音讯。它是在 Cookies
的底蕴上落到实处的,并且对 Cookies
进行密钥签名要运用会话,你要求设置三个密钥。

     d、

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

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

十一、闪现(flash)**

   
 a、
session从在在服务端的1个字典中,session保存的数量取1次,它照旧会有。而flash是依靠session创制的,flash补助在中间放值,只要在其间取值它就会并未有。闪现就是**

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

十二、蓝图**

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

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

    # 前提必要给配置SE福睿斯VE福睿斯_NAME: app.config[‘SERVER_NAME’] =
    ‘wupeiqi.com:5000’

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

十三、DBUtils**

      a、DBUtils是Python的贰个用以得以落成数据库连接池的模块。**

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

            (一)、第二种情势:

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

             (二)、第2种格局:

                                 它的症结:无法支撑并发

              (3)、第叁种方式:

                                它是依照DBUtils落成数据库连接池

                                       
-为各样线程创建多少个链接,该线程关闭时,不是确实的关闭,本线程再一次调用时,依旧选用的最起初的创导的链接,知道线程终止,数据库链接才关闭

                                     
 -创立多个连接池(十个链接),为拥有线程提供链接,使用时来进行获取,使用完成时,再度放回到连接池。

       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
,触发只举行1遍的装饰器中(触发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、十一个非时域信号

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是2个支撑八个web框架的form组件,首要用于对用户请求数据开始展览表明。

    b、安装: pip3 install wtform

    c、用途:**

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

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

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

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

金沙注册送58 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
金沙注册送58 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是3个基于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是二个根据Python开垦并且重视jinja二模板和Werkzeug
WSGI服务的一个袖珍框架,对于Werkzeug本质是Sock…

1.Flask:

1.Flask:

   
 a、Flask是2个基于Python开拓并且信赖jinja二模板和Werkzeug
WSGI服务的二个袖珍框架,对于Werkzeug本质是Socket服务端,其用于吸收接纳http请求并对请求进行预管理,然后触发Flask框架,开荒人士基于Flask框架提供的效劳对请求进行对应的管理,并回到给用户,即使要回到给用户复杂的内容时,须要借助jinja二模板来完成对模板的管理,即:将模板和数目进行渲染,将渲染后的字符串重返给用户浏览器

Flask是二个依照Python开采并且注重jinja二模板和Werkzeug
WSGI服务的二个袖珍框架,对于Werkzeug本质是Socket服务端,其用于收纳http请求并对请求进行预管理,然后触发Flask框架,开辟人士基于Flask框架提供的功力对请求举行相应的拍卖,并回到给用户,若是要回到给用户复杂的内容时,必要借助jinja二模板来达成对模板的拍卖,即:将模板和数目开始展览渲染,将渲染后的字符串再次来到给用户浏览器。

Flask是一个基于Python开垦并且正视jinja2模板和Werkzeug
WSGI服务的3个袖珍框架,对于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
本人达成的1致。众多的恢弘提供了数据库集成、表单验证、上传管理、有滋有味的怒放认证技艺等效率。Flask
或然是“微小”的,但它已安不忘虞幸好须求繁杂的生育情形中投入使用。

暗许情况下,Flask
不包涵数据库抽象层、表单验证,或是别的任何已有多样库能够胜任的作用。不过,Flask
协理用扩充来给使用加多这个成效,就像是是 Flask
自己实现的同等。众多的恢宏提供了数据库集成、表单验证、上传管理、各种各样的绽开认证技能等职能。Flask
可能是“微小”的,但它已预备万幸供给繁杂的生产条件中投入使用。

暗中认可意况下,Flask
不含有数据库抽象层、表单验证,或是别的任何已有三种库能够胜任的功效。可是,Flask
扶助用扩张来给使用增加那一个功能,就像是是 Flask
本身达成的一模同样。众多的恢宏提供了数据库集成、表单验证、上传管理、多姿多彩的盛开认证技能等效果。Flask
或者是“微小”的,但它已图谋幸好须求繁杂的生产条件中投入使用。

二、安装

安装:pip3
install flask

安装:pip3
install flask

      a、安装:pip3 install flask**

 

 

三、虚拟境况

金沙注册送58 3金沙注册送58 4

金沙注册送58 5金沙注册送58 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)、
模板、O陆风X8M、cookie、Session、Admin、Form、缓存、功率信号、种类化….                    
 Flask:无socket、中间件(扩大)、路由系统、视图(CBV)、第二方模板(jinja2)、cookie、Session弱爆了**

3.flask框架

3.flask框架

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

   
 简单介绍:轻量级框架

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

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

   
 简介:轻量级框架

     
            Django:无socket、中间件、路由系统、视图(CBV,FBV)、
模板、O奥迪Q5M、cookie、Session、Admin、Form、缓存、                         
         非能量信号、类别化….

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

**      c、Flask信赖二个达成了WSGI协议的模块:werkzeug**

     
             a. 什么是wsgi?

     
                     Web服务网管接口,协议。

     
             a. 什么是wsgi?

     
                     Web服务网管接口,协议。

五、flask

     
             b. Flask依赖3个贯彻了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、金沙注册送58 , 增加路由关系      

           -模板路线

           -模板路线

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

六、基本采取

          -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.路由系统:

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、反向生成UKoleosL: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’)

八、请求响应

   
 -反向生成UHavalL:url_for

   
 -反向生成U翼虎L: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、自定义模板方法

陆.请求响应

陆.伸手响应

             
 Flask中自定义模板方法的点子和Bottle相似,创造三个函数并因而参数的款式传播render_template,

 

 

十、session 

金沙注册送58 7金沙注册送58 8

金沙注册送58 9金沙注册送58 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
的基本功上完毕的,并且对 Cookies
进行密钥具名要运用会话,你需求安装二个密钥。

在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保存的多寡取2次,它依旧会有。而flash是依附session创制的,flash辅助在在那之中放值,只要在在这之中取值它就会未有。闪现就是**

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

    # 前提须求给配备SELX570VE中华V_NAME: app.config[‘SERVER_NAME’] =
    ‘wupeiqi.com:5000’

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

     
       
 Flask中自定义模板方法的方法和Bottle相似,成立一个函数并透过参数的情势传播render_template,如:

     
       
 Flask中自定义模板方法的秘技和Bottle相似,创立二个函数并透过参数的方式传播render_template,如:

十三、DBUtils**

金沙注册送58 11金沙注册送58 12

金沙注册送58 13金沙注册送58 14

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

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

            (壹)、第一种形式:

金沙注册送58 15金沙注册送58 16

金沙注册送58 17金沙注册送58 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

                                 它的通病:无法支撑并发

金沙注册送58 19金沙注册送58 20

金沙注册送58 21金沙注册送58 22

              (叁)、第1种格局:

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

                                     
 -创制一个连接池(十一个链接),为保有线程提供链接,使用时来进行获取,使用完成时,再一次放回到连接池。

   
 -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的原理和界别:

除请求对象之外,还有二个session 对象。它同意你在差别请求间存款和储蓄特定用户的音信。它是在 Cookies
的根基上完结的,并且对 Cookies
进行密钥具名要动用会话,你要求安装1个密钥。

除请求对象之外,还有二个session 对象。它同意你在分歧请求间存款和储蓄特定用户的音讯。它是在 库克ies
的根底上落到实处的,并且对 Cookies
进行密钥具名要使用会话,你要求设置一个密钥。

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

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

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

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

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

               session依赖于cookie存在**

金沙注册送58 23金沙注册送58 24

金沙注册送58 25金沙注册送58 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源码解析

金沙注册送58 27金沙注册送58 28

金沙注册送58 29金沙注册送58 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实信号),

金沙注册送58 31金沙注册送58 32

金沙注册送58 33金沙注册送58 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从在在服务端的1个字典中,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.蓝图

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

    #
    前提供给给配备SEEvoqueVEPRADO_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’)

    #
    前提须要给安插SEBMWX五VE凯雷德_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是二个支持多个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)

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

 

 

             
密码不能够为空;密码长度必须抢先12;密码必须包含字母、数字、特殊字符等(自定义正则);

 

 

金沙注册送58 35金沙注册送58 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

 

 

金沙注册送58 37金沙注册送58 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完成的OLANDM框架。该框架是树立在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品级3方插件, 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地图