威尼斯人线上娱乐

Python之flask计算

19 4月 , 2019  

一、flask

Python之flask总结,pythonflask

一、flask

     a、Flask是2个基于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)、第二方模板(jinja2)、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**

Python之flask计算。     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()

8、请求响应

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、除请求对象之外,还有3个 session
对象。它同意你在不一样请求间存款和储蓄特定用户的消息。它是在 Cookies
的根底上落成的,并且对 Cookies
举行密钥具名要采用会话,你要求设置一个密钥。

     d、

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

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

十一、闪现(flash)**

   
 a、
session从在在服务端的四个字典中,session保存的数目取2遍,它照旧会有。而flash是依照session创制的,flash支持在里面放值,只要在里面取值它就会并未有。闪现正是**

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

十二、蓝图**

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

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

    # 前提须要给安插SE普拉多VE锐界_NAME: app.config[‘SERVER_NAME’] =
    ‘wupeiqi.com:5000’

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

十三、DBUtils**

      a、DBUtils是Python的二个用以得以完结数据库连接池的模块。**

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

            (一)、第2种方式:

                               
 它的通病:每壹回呼吁反复创造数据库的链接,链接的次数太多

             (二)、第二种形式:

                                 它的短处:不能补助并发

              (三)、第三种形式:

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

                                       
-为每一种线程创造3个链接,该线程关闭时,不是当真的关闭,本线程再一次调用时,照旧选用的最开首的创设的链接,知道线程终止,数据库链接才关闭

                                     
 -创设3个连接池(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的规律和区分:

               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、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里面某个特殊的
正是那1个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二;密码必须带有
字母、数字、特殊字符等(自定义正则);

威尼斯人线上娱乐 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是2个依照Python落成的OOdysseyM框架。该框架是创建在DB
API之上,使用关系对象映射实行数据库操作

         
 简言之便就是:将类和对象调换来SQL,然后利用数据API实行SQL并获得施行的结果

    b、安装: pip3 install SQLALchemy

    c、组成都部队分**

 engine,                                     框架的引擎

     Connection  Pooling  ,                      数据库连接池

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

     Schema /Types,                              架构和类型     

     SQL Exprression Language,                   SQL表达式语言

   
d、SQLALcheam省内不能操作数据库,其必须来pymysql品级三方插件, Dialect用于数据API的调换,依据安插文件的例外**

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

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

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

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

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

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

 

 

  

 

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

1.Flask:

1.Flask:

   
 a、Flask是2个依据Python开采并且注重jinja2模板和Werkzeug
WSGI服务的贰个小型框架,对于Werkzeug本质是Socket服务端,其用于收纳http请求并对请求进行预处理,然后触发Flask框架,开垦人士基于Flask框架提供的效率对请求进行对应的处理,并赶回给用户,即便要重返给用户复杂的内容时,需求借助jinja二模板来兑现对模板的拍卖,即:将模板和数码开始展览渲染,将渲染后的字符串重临给用户浏览器

Flask是贰个基于Python开辟并且注重jinja2模板和Werkzeug
WSGI服务的二个袖珍框架,对于Werkzeug本质是Socket服务端,其用来吸收接纳http请求并对请求举行预处理,然后触发Flask框架,开垦职员基于Flask框架提供的功力对请求进行对应的拍卖,并重回给用户,倘若要回去给用户复杂的故事情节时,要求借助jinja2模板来得以落成对模板的拍卖,即:将模板和数据开始展览渲染,将渲染后的字符串重临给用户浏览器。

Flask是叁个依据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**

 

 

三、虚拟环境

威尼斯人线上娱乐 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

二.
虚拟环境

二.
虚拟环境

四、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奥迪Q3M、cookie、Session、Admin、Form、缓存、频限信号、连串化….                    
 Flask:无socket、中间件(扩充)、路由系统、视图(CBV)、第一方模板(jinja2)、cookie、Session弱爆了**

3.flask框架

3.flask框架

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

   
 简单介绍:轻量级框架

     
            Django:无socket、中间件、路由系统、视图(CBV,FBV)、
模板、O奥迪Q7M、cookie、Session、Admin、Form、缓存、                         
         确定性信号、体系化….

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

   
 简单介绍:轻量级框架

     
            Django:无socket、中间件、路由系统、视图(CBV,FBV)、
模板、O路虎极光M、cookie、Session、Admin、Form、缓存、                         
         复信号、体系化….

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

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

     
             a. 什么是wsgi?

     
                     Web服务网管接口,协议。

     
             a. 什么是wsgi?

     
                     Web服务网管接口,协议。

五、flask

     
             b. Flask注重四个实现了WSGI协议的模块:werkzeug

     
             b. Flask依赖2个达成了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’)

8、请求响应

   
 -反向生成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使用的是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()

                     -它与字典方法1致

伸手响应

请求响应

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

 

 

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

    –
from urllib.parse import urlencode,quote,unquote

    –
make_response

    –
from urllib.parse import urlencode,quote,unquote

    –
make_response

     c、除请求对象之外,还有一个 session
对象。它同意你在不相同请求间存款和储蓄特定用户的音信。它是在 Cookies
的功底上落到实处的,并且对 Cookies
实行密钥签字要运用会话,你供给设置三个密钥。

在django中用make_safe而在Flask中用make_response

在django中用make_safe而在Flask中用make_response

     d、

 

 

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

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

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

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

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

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

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

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


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

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

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

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

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

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


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

十一、闪现(flash)**

 

 

   
 a、
session从在在服务端的一个字典中,session保存的数额取三次,它还是会有。而flash是基于session成立的,flash支持在里面放值,只要在内部取值它就会未有。闪现正是**

柒.模板语言 
 

七.模板语言 
 

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

   
 a、模板的使用

   
 a、模板的利用

十二、蓝图**

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

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

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

   
 b、自定义模板方法

   
 b、自定义模板方法

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

    # 前提必要给配备SE君越VE揽胜_NAME: app.config[‘SERVER_NAME’] =
    ‘wupeiqi.com:5000’

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

     
       
 Flask中自定义模板方法的秘诀和Bottle相似,创设一个函数并经过参数的格局传播render_template,如:

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

十三、DBUtils**

威尼斯人线上娱乐 11威尼斯人线上娱乐 12

威尼斯人线上娱乐 13威尼斯人线上娱乐 14

      a、DBUtils是Python的三个用来得以完毕数据库连接池的模块。**

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

</body>
</html>

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

</body>
</html>

html

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

html

html

            (一)、第1种格局:

威尼斯人线上娱乐 15威尼斯人线上娱乐 16

威尼斯人线上娱乐 17威尼斯人线上娱乐 18

                               
 它的通病:每3回呼吁反复创造数据库的链接,链接的次数太多

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


def wupeiqi():
    return '<h1>Wupeiqi</h1>'

@app.route('/login', methods=['GET', 'POST'])
def login():
    return render_template('login.html', ww=wupeiqi)

app.run()

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


def wupeiqi():
    return '<h1>Wupeiqi</h1>'

@app.route('/login', methods=['GET', 'POST'])
def login():
    return render_template('login.html', ww=wupeiqi)

app.run()

run.py

             (二)、第三种情势:

run

run

                                 它的欠缺:不能补助并发

威尼斯人线上娱乐 19威尼斯人线上娱乐 20

威尼斯人线上娱乐 21威尼斯人线上娱乐 22

              (叁)、第二种方式:

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


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

    {{ input('n1') }}

    {% include 'tp.html' %}

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

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


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

    {{ input('n1') }}

    {% include 'tp.html' %}

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

其他

                                它是依照DBUtils完结数据库连接池

其他

其他

                                       
-为每一种线程创制二个链接,该线程关闭时,不是的确的关闭,本线程再一次调用时,依然选用的最开端的创办的链接,知道线程终止,数据库链接才关闭

8.session

8.session

                                     
 -创设1个连接池(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 对象。它同意你在分化请求间存储特定用户的新闻。它是在 库克ies
的根底上实现的,并且对 Cookies
实行密钥具名要动用会话,你须求设置二个密钥。

除请求对象之外,还有二个session 对象。它同意你在不一样请求间存款和储蓄特定用户的音讯。它是在 Cookies
的基本功上贯彻的,并且对 Cookies
实行密钥签字要采纳会话,你要求设置2个密钥。

               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
,触发只进行2遍的装饰器中(触发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从在在服务端的1个字典中,session保存的数目取三遍,它依然会有。而flash是依照session创造的,flash帮衬在里头放值,只要在里头取值它就会未有。闪现正是

session从在在服务端的3个字典中,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’)

    #
    前提需求给布署SECRUISERVEXC90_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’)

    #
    前提需求给配置SEOdysseyVE奥迪Q7_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)

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

 

 

             
密码不可能为空;密码长度必须高于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是3个依照Python达成的O普拉多M框架。该框架是身无寸铁在DB
API之上,使用关系对象映射进行数据库操作

 

 

         
 简言之便正是:将类和目标转换来SQL,然后利用数据API实行SQL并得到实践的结果

       

       

    b、安装: pip3 install SQLALchemy

 

 

    c、组成都部队分**

 engine,                                     框架的引擎

     Connection  Pooling  ,                      数据库连接池

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

     Schema /Types,                              架构和类型     

     SQL Exprression Language,                   SQL表达式语言

   
d、SQLALcheam本省无法操作数据库,其必须来pymysql等级一方插件, Dialect用于数据API的调换,依据安插文件的两样**

调用不同的数据库API,从而完毕对数据库的操作

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

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

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

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

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

 

 

  

 


相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图