Python之flask总计

一、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**

3、虚拟环境

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

      b、# 创设虚拟环境 virtualenv env1

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

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

四、flask框架**

**      a、简要介绍:轻量级框架                    
 Django:无socket、中间件、路由系统、视图(CBV,FBV)、
模板、O昂科雷M、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 

陆、基本选取

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、反向生成UEnclaveL: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
对象。它同意你在分歧请求间存款和储蓄特定用户的音讯。它是在 Cookies
的功底上贯彻的,并且对 Cookies
实行密钥签字要接纳会话,你须求设置一个密钥。

     d、

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

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

十一、闪现(flash)**

   
 a、
session从在在服务端的2个字典中,session保存的数码取三遍,它依旧会有。而flash是依据session成立的,flash扶助在里边放值,只要在里面取值它就会并未有。闪现正是**

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

十二、蓝图**

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

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

    # 前提须求给安顿SE中华VVE途达_NAME: app.config[‘SERVER_NAME’] =
    ‘wupeiqi.com:5000’

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

十三、DBUtils**

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

      b、连接池的三种格局:**

            (一)、第三种形式:

                               
 它的症结:每1回呼吁反复成立数据库的链接,链接的次数太多

             (二)、第二种形式:

                                 它的欠缺:无法支撑并发

              (叁)、第二种情势:

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

                                       
-为各类线程创设多少个链接,该线程关闭时,不是当真的闭馆,本线程再一次调用时,照旧接纳的最开始的始建的链接,知道线程终止,数据库链接才关闭

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

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

              Python之flask总计。 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
,触发只进行2次的装饰器中(触发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、用户登入注册**

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

             
用户不可能为空;用户长度必须大于六;

             
密码无法为空;密码长度必须抢先1二;密码必须含有
字母、数字、特殊字符等(自定义正则);

美高梅开户网址 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是二个基于Python落成的OSportageM框架。该框架是起家在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等级2方插件, 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是1个基于Python开采并且依赖jinja二模板和Werkzeug
WSGI服务的三个小型框架,对于Werkzeug本质是Sock…

1.Flask:

1.Flask:

   
 a、Flask是三个基于Python开辟并且正视jinja2模板和Werkzeug
WSGI服务的贰个袖珍框架,对于Werkzeug本质是Socket服务端,其用来吸收接纳http请求并对请求实行预处理,然后触发Flask框架,开荒职员基于Flask框架提供的意义对请求举办对应的处理,并回到给用户,假设要回来给用户复杂的剧情时,需求借助jinja2模板来贯彻对模板的拍卖,即:将模板和多少进行渲染,将渲染后的字符串再次回到给用户浏览器

Flask是三个依据Python开辟并且信赖jinja二模板和Werkzeug
WSGI服务的二个袖珍框架,对于Werkzeug本质是Socket服务端,其用于收纳http请求并对请求举办预处理,然后触发Flask框架,开拓人士基于Flask框架提供的效应对请求进行相应的拍卖,并回到给用户,若是要回来给用户复杂的内容时,要求借助jinja2模板来贯彻对模板的拍卖,即:将模板和多少开始展览渲染,将渲染后的字符串再次回到给用户浏览器。

Flask是三个基于Python开辟并且信赖jinja二模板和Werkzeug
WSGI服务的三个袖珍框架,对于Werkzeug本质是Socket服务端,其用来吸收接纳http请求并对请求进行预处理,然后触发Flask框架,开辟职员基于Flask框架提供的功用对请求举行对应的处理,并回到给用户,如果要回来给用户复杂的内容时,要求借助jinja贰模板来贯彻对模板的处理,即:将模板和多少进行渲染,将渲染后的字符串再次回到给用户浏览器。

     b、“微”(micro) 并不意味着您要求把1切
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
自个儿达成的等同。众多的恢弘提供了数据库集成、表单验证、上传处理、各样各个的盛开认证才具等功用。Flask
可能是“微小”的,但它已准备辛亏须要繁杂的生产环境中投入使用。

暗中同意境况下,Flask
不带有数据库抽象层、表单验证,或是别的任何已有种种库能够胜任的成效。但是,Flask
协理用扩充来给采纳增多那几个功用,仿佛是 Flask
本人落成的平等。众多的恢弘提供了数据库集成、表单验证、上传处理、各样各种的绽开认证才干等功能。Flask
恐怕是“微小”的,但它已未焚徙薪辛亏急需繁杂的生产环境中投入使用。

二、安装

安装:pip3
install flask

安装:pip3
install flask

      a、安装:pip3 install flask**

 

 

三、虚拟环境

美高梅开户网址 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)、
模板、O索罗德M、cookie、Session、Admin、Form、缓存、连续信号、类别化….                    
 Flask:无socket、中间件(扩大)、路由系统、视图(CBV)、第一方模板(jinja二)、cookie、Session弱爆了**

3.flask框架

3.flask框架

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

   
 简单介绍:轻量级框架

     
            Django:无socket、中间件、路由系统、视图(CBV,FBV)、
模板、O安德拉M、cookie、Session、Admin、Form、缓存、                         
         频限信号、连串化….

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

   
 简要介绍:轻量级框架

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

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

**      c、Flask重视叁个贯彻了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

陆、基本采纳

          -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、反向生成U宝马7系L: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’)

八、请求响应

   
 -反向生成U福特ExplorerL:url_for

   
 -反向生成ULacrosseL: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、模板的应用

陆.视图函数

六.视图函数

               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.呼吁响应

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
的底子上实现的,并且对 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从在在服务端的3个字典中,session保存的多少取2次,它依旧会有。而flash是基于session创建的,flash扶助在里面放值,只要在内部取值它就会并未有。闪现正是**

7.模板语言 
 

七.模板语言 
 

   
 b、在session的基础上,把它的值真实的放在session上,当去它的时候不但把它的值取走,还把session的东西去掉。

   
 a、模板的采纳

   
 a、模板的应用

十二、蓝图**

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

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

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

   
 b、自定义模板方法

   
 b、自定义模板方法

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

    # 前提供给给配备SECRUISERVEPAJERO_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的1个用来得以完成数据库连接池的模块。**

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

              (3)、第二种方式:

<!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落成数据库连接池

其他

其他

                                       
-为各样线程成立1个链接,该线程关闭时,不是真的的关闭,本线程再度调用时,照旧选择的最伊始的开创的链接,知道线程终止,数据库链接才关闭

8.session

8.session

                                     
 -创立3个连接池(1二个链接),为具备线程提供链接,使用时来进展获取,使用落成时,再一次放回到连接池。

   
 -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
举行密钥具名要选取会话,你供给设置2个密钥。

除请求对象之外,还有三个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
,触发只进行3遍的装饰器中(触发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从在在服务端的2个字典中,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牧马人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奥迪Q5VE翼虎_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          # 创建数据库连接时,自动触发

12.配置文件

12.配备文件

十九、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、用户登6注册**

 

 

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

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实现的O奥迪Q5M框架。该框架是起家在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地图