Python之flask总括

By admin in 4858.com on 2019年4月4日

一、flask

Python之flask总结,pythonflask

一、flask

     a、Flask是三个基于Python开发并且信赖jinja二模板和Werkzeug
WSGI服务的贰个微型框架,对于Werkzeug本质是Socket服务端,其用来吸收接纳http请求并对请求举行预处理,然后触发Flask框架,开发职员基于Flask框架提供的效果对请求实行对应的处理,并回到给用户,假设要赶回给用户复杂的内容时,必要借助jinja2模板来促成对模板的拍卖,即:将模板和数量进行渲染,将渲染后的字符串再次回到给用户浏览器

     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昂CoraM、cookie、Session、Admin、Form、缓存、能量信号、种类化….                    
 Flask:无socket、中间件(扩张)、路由系统、视图(CBV)、第一方模板(jinja二)、cookie、Session弱爆了**

**      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、反向生成U翼虎L: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,

十、sessionPython之flask总括。 

4858.com ,      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从在在服务端的一个字典中,session保存的多少取贰回,它依然会有。而flash是基于session创造的,flash扶助在内部放值,只要在内部取值它就会未有。闪现正是**

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

十二、蓝图**

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

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

    # 前提要求给布署SE奥迪Q7VE凯雷德_NAME: app.config[‘SERVER_NAME’] =
    ‘wupeiqi.com:5000’

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

十三、DBUtils**

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

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

            (一)、第壹种情势:

                               
 它的老毛病:每一次呼吁反复成立数据库的链接,链接的次数太多

             (2)、第两种方式:

                                 它的症结:无法支撑并发

              (三)、第几种方式:

                                它是基于DBUtils完结数据库连接池

                                       
-为各种线程创制2个链接,该线程关闭时,不是真的的倒闭,本线程再度调用时,依旧使用的最初阶的始建的链接,知道线程终止,数据库链接才关闭

                                     
 -创制2个连接池(十三个链接),为具无线程提供链接,使用时来拓展获取,使用达成时,再一次放回到连接池。

       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正是一个大字典,字典中是随机字符串)(session与request原理相同)(session原理跟上下文也有关联)

               session依赖于cookie存在**

**      b、  session流程**      **

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

十五、session源码解析

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

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

   
 c、  执行wsgi_app方法下面包车型地铁视图函数。执行完视图函数再次回到到full_dispatch_requesthong
,触发只举办三回的装饰器中(触发Flask功率信号),

   
 d、  执行完这么些装饰器,紧接着执行上面包车型大巴出格的装饰器,假设这个很是装饰器未有再次回到值,那么rv=None,如若有重返值,页面时就展现这几个再次来到值,

   
 e、假设未有重回值,触发执行那些视图函数,拿重临值。请求执行完再次回到后,调用finalize_request,对它的重返值进行打包。

十六、Flask和Django的区别 

     a、伸手相关的数码           

                  -Django:参数

                  -Flask:    基于Local,LocalStark对象

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

                  -单线程

                  -多线程

                  -协程

                    解决: from greenlet import getcurrent as
get_ident

十七、**Flask**信号

    a、 Flask框架中的非确定性信号基于blinker**

    b、安装: pip3 install blinker**

    c、十个功率信号

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

    b、安装: pip3 install wtform

    c、用途:**

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

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

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

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

4858.com 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
4858.com 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完成的O奥迪Q7M框架。该框架是树立在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

 

 

  

 

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

1.Flask:

1.Flask:

   
 a、Flask是3个基于Python开发并且依赖jinja二模板和Werkzeug
WSGI服务的一个微型框架,对于Werkzeug本质是Socket服务端,其用来吸收接纳http请求并对请求进行预处理,然后触发Flask框架,开发人士基于Flask框架提供的成效对请求举行对应的处理,并赶回给用户,尽管要回来给用户复杂的内容时,需求借助jinja二模板来贯彻对模板的拍卖,即:将模板和多少实行渲染,将渲染后的字符串再次来到给用户浏览器

Flask是二个依照Python开发并且重视jinja2模板和Werkzeug
WSGI服务的三个微型框架,对于Werkzeug本质是Socket服务端,其用于收纳http请求并对请求实行预处理,然后触发Flask框架,开发人士基于Flask框架提供的成效对请求进行相应的处理,并回到给用户,假诺要回来给用户复杂的内容时,需求借助jinja二模板来落实对模板的处理,即:将模板和数据实行渲染,将渲染后的字符串重回给用户浏览器。

Flask是3个根据Python开发并且依赖jinja贰模板和Werkzeug
WSGI服务的贰个袖珍框架,对于Werkzeug本质是Socket服务端,其用于收纳http请求并对请求实行预处理,然后触发Flask框架,开发人士基于Flask框架提供的作用对请求进行相应的拍卖,并回到给用户,如若要回去给用户复杂的内容时,须求借助jinja贰模板来落到实处对模板的拍卖,即:将模板和数据开始展览渲染,将渲染后的字符串重回给用户浏览器。

     b、“微”(micro) 并不代表你供给把全部Web 应用塞进单个 Python 文件(即使真正能够 ),也不意味 Flask
在作用上富有欠缺。微框架中的“微”意味着 Flask
意在保持焦点不难而易于增加。Flask
不会替你做出太多决策——比如选拔何种数据库。而那一个 Flask
所选拔的——比如动用何种模板引擎——则很不难替换。除了那些之外的成套都由可由你精通。如此,Flask
能够与您相辅相成。

“微”(micro)
并不意味着你供给把全路 Web 应用塞进单个 Python 文件(纵然真正可以),也不表示 Flask 在遵循上装有欠缺。微框架中的“微”意味着 Flask
目的在于保险基本简单而不难扩大。Flask
不会替你做出太多决策——比如选用何种数据库。而那个 Flask
所选择的——比如动用何种模板引擎——则很简单替换。除此而外的全部都由可由你驾驭。如此,Flask
能够与你相辅相成。

“微”(micro)
并不表示您须求把全路 Web 应用塞进单个 Python 文件(即便真正能够),也不意味着 Flask 在职能上享有欠缺。微框架中的“微”意味着 Flask
意在保证基本不难而简单扩张。Flask
不会替你做出太多决策——比如采纳何种数据库。而那多少个 Flask
所选取的——比如动用何种模板引擎——则很简单替换。除了那么些之外的整体都由可由你控制。如此,Flask
能够与你相得益彰。

     c、暗中同意情状下,Flask
不分包数据库抽象层、表单验证,或是别的任何已有三种库能够胜任的效劳。可是,Flask
扶助用扩张来给采纳添加这一个效应,就像是 Flask
本人完结的均等。众多的扩张提供了数据库集成、表单验证、上传处理、种种种种的开放认证技术等功能。Flask
可能是“微小”的,但它已忧盛危明幸好供给繁杂的生育环境中投入使用。

默许情形下,Flask
不含有数据库抽象层、表单验证,或是别的任何已有两种库能够胜任的功力。但是,Flask
扶助用扩展来给使用添加那些成效,就如是 Flask
本人完成的同一。众多的扩大提供了数据库集成、表单验证、上传处理、种种各种的盛开认证技术等职能。Flask
只怕是“微小”的,但它已预备还好供给繁杂的生产条件中投入使用。

暗许情形下,Flask
不带有数据库抽象层、表单验证,或是其它任何已有八种库能够胜任的功效。不过,Flask
协理用扩充来给选用添加那一个效应,就好像是 Flask
自个儿实现的一律。众多的恢弘提供了数据库集成、表单验证、上传处理、种种种种的怒放认证技术等功效。Flask
可能是“微小”的,但它已预备万幸急需繁杂的生育环境中投入使用。

二、安装

安装:pip3
install flask

安装:pip3
install flask

      a、安装:pip3 install flask**

 

 

三、虚拟环境

4858.com 34858.com 4

4858.com 54858.com 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)、第叁方模板(jinja二)、cookie、Session弱爆了

   
 简介:轻量级框架

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

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

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

     
             a. 什么是wsgi?

     
                     Web服务网管接口,协议。

     
             a. 什么是wsgi?

     
                     Web服务网管接口,协议。

五、flask

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

     
             b. Flask依赖二个兑现了WSGI协议的模块:werkzeug

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

flask

flask

       b、  -实例化Flask对象

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

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

                  -静态文件前缀  /xxx

      -实例化Flask对象

      -实例化Flask对象

                  -静态文件目录

           -静态文件前缀  /xxx

           -静态文件前缀  /xxx

                  -模板路径

           -静态文件目录

           -静态文件目录

        c、 添加路由关系      

           -模板路径

           -模板路径

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

     添加路由关系

     添加路由关系

                  -三种添加路由的方法

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

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

        d、request

           -二种添加路由的格局

           -二种添加路由的法子

                 -request.form

     request

     request

                 -request.args 

          -request.form

          -request.form

6、基本选择

          -request.args 

          -request.args 

from flask import Flask

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

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

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

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

肆.中央采纳:

肆.主干使用:

     a、封存session的多少存到了浏览器上,
        - 优点:减轻了服务端的压力
        - 缺点:不安全

from flask import Flask

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

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

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

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

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

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

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

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

     b、路由系统:  

练习:

练习:

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

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

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

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


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

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

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

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


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

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

  -
缺点:不安全

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

  -
缺点:不安全

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

5.路由系统:

伍.路由系统:

七、路由系统**

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

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

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

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

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

   
路由系统

   
路由系统

     b、反向生成UPRADOL: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索罗德L: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、模板的利用

陆.视图函数

陆.视图函数

               Flask使用的是Jinja二模板,所以其语法和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 

4858.com 74858.com 8

4858.com 94858.com 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、除请求对象之外,还有1个 session
对象。它同意你在分裂请求间存款和储蓄特定用户的音讯。它是在 Cookies
的底子上完成的,并且对 Cookies
举行密钥签名要动用会话,你要求设置2个密钥。

在django中用make_safe而在Flask中用make_response

在django中用make_safe而在Flask中用make_response

     d、

 

 

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

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

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

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

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

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

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

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


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

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

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

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

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

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


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

十一、闪现(flash)**

 

 

   
 a、
session从在在服务端的三个字典中,session保存的多少取一次,它仍然会有。而flash是基于session创设的,flash帮衬在内部放值,只要在内部取值它就会并未有。闪现正是**

7.模板语言 
 

7.模板语言 
 

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

   
 a、模板的应用

   
 a、模板的选拔

十二、蓝图**

     
         Flask使用的是Jinja贰模板,所以其语法和Django没有差异

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

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

   
 b、自定义模板方法

   
 b、自定义模板方法

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

    # 前提须求给配备SEPRADOVE大切诺基_NAME: app.config[‘SERVER_NAME’] =
    ‘wupeiqi.com:5000’

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

     
       
 Flask中自定义模板方法的艺术和Bottle相似,创立1个函数并通过参数的花样传播render_template,如:

     
       
 Flask中自定义模板方法的办法和Bottle相似,成立1个函数并通过参数的花样传播render_template,如:

十三、DBUtils**

4858.com 114858.com 12

4858.com 134858.com 14

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

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

</body>
</html>

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

</body>
</html>

html

      b、连接池的两种情势:**

html

html

            (1)、第三种形式:

4858.com 154858.com 16

4858.com 174858.com 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

                                 它的欠缺:不能扶助并发

4858.com 194858.com 20

4858.com 214858.com 22

              (三)、第二种方式:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>


    {% macro input(name, type='text', value='') %}
        <input type="{{ type }}" name="{{ name }}" value="{{ value }}">
    {% endmacro %}

    {{ input('n1') }}

    {% include 'tp.html' %}

    <h1>asdf{{ v.k1}}</h1>
</body>
</html>

其他
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>


    {% macro input(name, type='text', value='') %}
        <input type="{{ type }}" name="{{ name }}" value="{{ value }}">
    {% endmacro %}

    {{ input('n1') }}

    {% include 'tp.html' %}

    <h1>asdf{{ v.k1}}</h1>
</body>
</html>

其他

                                它是依据DBUtils实现数据库连接池

其他

其他

                                       
-为种种线程创设三个链接,该线程关闭时,不是确实的关闭,本线程再度调用时,依旧接纳的最初步的创始的链接,知道线程终止,数据库链接才关闭

8.session

8.session

                                     
 -创制一个连接池(13个链接),为富有线程提供链接,使用时来开始展览获取,使用完成时,再度放回到连接池。

   
 -session是还是不是还有其余办法?

   
 -session是不是还有其它艺术?

       c、DBUtils的应用:**

     
       -它与字典方法同样

     
       -它与字典方法同样

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

   
-session超时时间什么设置:

   
-session超时时间怎么设置:

十四、session

app.config['SESSION_COOKIE_NAME'] = 'session_lvning'
            """
            'SESSION_COOKIE_NAME':                  'session',
            'SESSION_COOKIE_DOMAIN':                None,
            'SESSION_COOKIE_PATH':                  None,
            'SESSION_COOKIE_HTTPONLY':              True,
            'SESSION_COOKIE_SECURE':                False,
            'SESSION_REFRESH_EACH_REQUEST':         True,
            'PERMANENT_SESSION_LIFETIME':           timedelta(days=31)
app.config['SESSION_COOKIE_NAME'] = 'session_lvning'
            """
            'SESSION_COOKIE_NAME':                  'session',
            'SESSION_COOKIE_DOMAIN':                None,
            'SESSION_COOKIE_PATH':                  None,
            'SESSION_COOKIE_HTTPONLY':              True,
            'SESSION_COOKIE_SECURE':                False,
            'SESSION_REFRESH_EACH_REQUEST':         True,
            'PERMANENT_SESSION_LIFETIME':           timedelta(days=31)

      a、 session和cookie的原理和界别:

除请求对象之外,还有3个session 对象。它同意你在分化请求间存款和储蓄特定用户的新闻。它是在 Cookies
的基本功上完结的,并且对 Cookies
实行密钥签名要动用会话,你供给安装三个密钥。

除请求对象之外,还有三个session 对象。它同意你在不一样请求间存款和储蓄特定用户的信息。它是在 库克ies
的基础上落到实处的,并且对 Cookies
举行密钥签名要使用会话,你须要设置3个密钥。

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

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

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

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

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

               session依赖于cookie存在**

4858.com 234858.com 24

4858.com 254858.com 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源码解析

4858.com 274858.com 28

4858.com 294858.com 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信号),

4858.com 314858.com 32

4858.com 334858.com 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的区别 

9.呼吁扩张

九.请求扩张

     a、请求相关的多少           

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from flask import Flask, Request, render_template

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


@app.before_first_request
def before_first_request1():
    print('before_first_request1')


@app.before_first_request
def before_first_request2():
    print('before_first_request2')


@app.before_request
def before_request1():
    Request.nnn = 123
    print('before_request1')


@app.before_request
def before_request2():
    print('before_request2')


@app.after_request
def after_request1(response):
    print('before_request1', response)
    return response


@app.after_request
def after_request2(response):
    print('before_request2', response)
    return response


@app.errorhandler(404)
def page_not_found(error):
    return 'This page does not exist', 404


@app.template_global()
def sb(a1, a2):
    return a1 + a2


@app.template_filter()
def db(a1, a2, a3):
    return a1 + a2 + a3


@app.route('/')
def hello_world():
    return render_template('hello.html')


if __name__ == '__main__':
    app.run()
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from flask import Flask, Request, render_template

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


@app.before_first_request
def before_first_request1():
    print('before_first_request1')


@app.before_first_request
def before_first_request2():
    print('before_first_request2')


@app.before_request
def before_request1():
    Request.nnn = 123
    print('before_request1')


@app.before_request
def before_request2():
    print('before_request2')


@app.after_request
def after_request1(response):
    print('before_request1', response)
    return response


@app.after_request
def after_request2(response):
    print('before_request2', response)
    return response


@app.errorhandler(404)
def page_not_found(error):
    return 'This page does not exist', 404


@app.template_global()
def sb(a1, a2):
    return a1 + a2


@app.template_filter()
def db(a1, a2, a3):
    return a1 + a2 + a3


@app.route('/')
def hello_world():
    return render_template('hello.html')


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

                  -Django:参数

 

 

                  -Flask:    基于Local,LocalStark对象

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

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

 

 

                  -单线程

10.闪现(flash)

10.闪现(flash)

                  -多线程

session从在在服务端的二个字典中,session保存的多少取一遍,它依然会有。而flash是根据session创设的,flash协理在里面放值,只要在内部取值它就会未有。闪现就是

session从在在服务端的一个字典中,session保存的多少取叁回,它照旧会有。而flash是基于session创制的,flash扶助在内部放值,只要在内部取值它就会没有。闪现就是

                  -协程

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

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

                    解决: from greenlet import getcurrent as
get_ident

闪现的用途:

闪现的用途:

十七、**Flask**信号

 

 

    a、 Flask框架中的功率信号基于blinker**

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

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

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

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

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


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

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

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

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

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


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

    b、安装: pip3 install blinker**

 

 

    c、十三个能量信号

11.蓝图

11.蓝图

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

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

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

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


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

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

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

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

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

   
 d、flask时域信号本生自个儿从未,用的是外人的,并且那几个时域信号通过装饰器全部得以代表了的,但是Django里面有些特殊的
就是那个model操作根本未有装饰器,正是同过内置的时限信号来形成的

 

 

十八、django内置的时域信号

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

    #
    前提须求给陈设SE大切诺基VETiguan_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’)

    #
    前提须要给配置SELacrosseVEPRADO_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)

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

 

 

             
密码无法为空;密码长度必须当先1贰;密码必须包括字母、数字、特殊字符等(自定义正则);

 

 

4858.com 354858.com 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

 

 

4858.com 374858.com 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是1个依照Python实现的O酷路泽M框架。该框架是手无寸铁在DB
API之上,使用关系对象映射进行数据库操作

 

 

         
 简言之便正是:将类和对象转换到SQL,然后利用数据API执行SQL并赢得执行的结果

       

       

    b、安装: pip3 install SQLALchemy

 

 

    c、组成都部队分**

 engine,                                     框架的引擎

     Connection  Pooling  ,                      数据库连接池

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

     Schema /Types,                              架构和类型     

     SQL Exprression Language,                   SQL表达式语言

   
d、SQLALcheam外省不能操作数据库,其必须来pymysql等第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地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有