flask 之 wtforms

 复习链接整理

先把标题给列出来,我们的flask到了这个阶段就需要把我们的源码都吃透了,源码都需要去整理出来

 

在看wtform源码之前我们先把面向对象的一些知识点给补充一下

 

class A():
    ...
class B(A):
    ...
class C():
    ...
class D(B,C):
    ...
print(D.__mro__)  # 深度优先

class HeType(type):
    def __init__(self, *args, **kwargs):
        super(HeType, self).__init__(*args, **kwargs)
        print('hello')


class Fo(object, metaclass=HeType):
    """
    Fo这个类是通过metaclass来选择我们自定义的HeType来创建的,而我们自定义的类又继承了Type类,

    """
    ...


obj = Fo()
"""
0,先执行我们的HeType里面的__init__
1,然后是HeType的__call__
2,再来就是Fo的__new__
3,最后是Fo的__init__
"""

class Fo():
    name='peter'
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def func(self):
        ...

print(1,Fo.__dict__)
"""
1 {'__module__': '__main__', 
'name': 'peter', 
'__init__': <function Fo.__init__ at 0x000000000252FAE8>, 
'func': <function Fo.func at 0x000000000252FF28>, 
'__dict__': <attribute '__dict__' of 'Fo' objects>, 
'__weakref__': <attribute '__weakref__' of 'Fo' objects>, 
'__doc__': None}
"""
print(2,dir(Fo))
"""
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', 
'__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', 
'__init__', '__init_subclass__', '__le__', '__lt__', '__module__', 
'__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', 
'__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 
'func', 'name']
"""

 

 

博客链接参详

s8day127

内容回顾：
    1. django/flask框架的认识？
    
    2. Flask上下文管理机制
        PS: 类
        
    3. 为什么把请求放到RequestContext中：
        ctx = RequestContext(request,session)
    4. Local对象作用？
        - 看过Local源码，threading.local相似，但是又有不同之处。
        - Local中基于greenlet获取唯一标识，粒度更细。
    5. LocalStack对象作用？
        - 对Local对象中的数据进行操作。
        - 将local对象中的数据维护成一个栈
            local = {
                1231：{stack: [ctx,]}
            }
    6. 上下文管理
        请求上下文：request/session
         App上下文: app/g
    7. 什么是g？
    
    8. 获取Session/g/current_app/request 
        
    9. 技术：
        - 反射 
        - 面向对象，封装：RequestContext
            __dict__
        - 线程（threading.local）
        - 笔试：自己写一个类+列表 实现栈。（LocalStack，文杰）
    
    PS: 一定要会
    
今日内容：
    1. flask-session 
    
    2. 数据库连接池：DBUtils(pymysql)
    
    3. wtforms
    
    4. SQLAchemy/flask-sqlachemy
    
    5. flask-script
    
    6. flask-migrate
    
内容概要：
    0. 补充：视频播放
    
    1. flask-session 
        作用：将默认保存的签名cookie中的值 保存到 redis/memcached/file/Mongodb/SQLAlchemy
        
        应用：
            a. 配置
                app.config['SESSION_TYPE'] = 'redis'
                app.config['SESSION_REDIS'] = Redis(host='192.168.0.94',port='6379')
                
            b. 替换 
                from flask_session import Session
                Session(app)
                
            注意：session中存储的是字典，修改字典内部元素时，会造成数据不更新。
                  - motified = True
                  - SESSION_REFRESH_EACH_REQUEST = True and  session.permanent = True(redis中默认)
        
        
        PS: 
                 数据框 模板      视图
            MTV, Model  Template  View
            MVC, Model  View      Controller
    
    2. 数据库连接池
        pip install DBUtils
        
        模式：
            - 每个线程创建一个连接，关闭（默认不关闭），线程终止时，才关闭连接。
            - 创建共享连接池
        
        应用：只要写原生SQL，用户数据框连接池
        
        
        
    3. wtforms 
        作用：用于对python web框架做表单验证。
        
        使用：
            class MyForm(Form):
                user = 类（正则,插件）
                字段 = 类（正则,插件）
                字段 = 类（正则,插件）
                字段 = 类（正则,插件）
                字段 = 类（正则,插件）
                字段 = 类（正则,插件）
                
            
            form = MyForm()
            # 生成HTML标签
            print(form.user) 类.__str__ ==> 插件.xx方法
    
            # 验证 
            form = MyForm(formdata=request.form)
            if form.validate():
                # 内部找到所有的字段：user + 用户发过来的数据 =》 正则校验
    
        基本使用：
            http://www.cnblogs.com/wupeiqi/articles/8202357.html
    
    
    
总结：
    1. 授权播放
    2. flask-session 
    3. dbutils
    4. wtforms 
        - 未完待续
    
    作业：
        - 上下文管理
        - flask-session
        - 路飞完成
        
        - wtforms
            - user = simple.StringField() 
                     UnboundField(simple.StringField，计数器)
            
            - FormMeta.__call__
        
        - 自己写类实现栈
        


































    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    

 

 

 

这里是基于蓝图创建的flask项目

蓝图的创建步骤,

一个文件夹,然后在里面再创建一个文件夹,这两者要同名,

在最外层的文件夹里面创建一个manage文件,还有一个settings文件

在里面的这层同名的文件夹里面创建templates文件夹,存放我们的HTML模板,

还有自定义的组件/模块,

还有views文件夹,里面是视图函数

 

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>用户登录</title>
</head>
<body>
<form method="post">
    {{form.user}} {{form.user.errors[0]}}
    {{form.pwd}}  {{form.pwd.errors[0]}}
    <input type="submit" value="提交">{{msg}}
</form>
</body>
</html>

 

import pymysql
from settings import BaseConfig


class SQBase():
    @staticmethod
    def open(cursor):
        POOL = BaseConfig.SQL_POOL
        conn = POOL.connection()
        cursor = conn.cursor(cursor=cursor)  # 这里等号右边的cursor是我们的形参,传入的值
        return conn, cursor

    @staticmethod
    def close(conn, cursor):
        conn.commit()
        cursor.close()
        conn.close()

    @classmethod
    def fetch_one(cls, sql, args, cursor=pymysql.cursors.DictCursor):
        conn, cursor = cls.open(cursor)
        cursor.execute(sql, args)
        obj = cursor.fetchone()
        cls.close(conn, cursor)
        return obj

    @classmethod
    def fetch_all(cls, sql, args, cursor=pymysql.cursors.DictCursor):
        conn, cursor = cls.open(cursor)
        cursor.execute(sql, args)
        obj = cursor.fetchall()
        cls.close(conn, cursor)
        return obj

 

from flask import request, redirect, render_template, Blueprint, session
from wtforms import Form
from ..utils.demo import SQBase
from wtforms import simple, validators, widgets

acc = Blueprint('account', __name__)


class LoginForm(Form):
    user = simple.StringField(
        validators=[
            validators.DataRequired(message='用户名不能够为空'),
        ],
        widget=widgets.TextInput(),
        render_kw={'class': 'form-control', 'placeholder': 'user'}  # 这是给我们的前端标签添加属性
    )
    pwd = simple.PasswordField(
        validators=[
            validators.DataRequired(message='密码不能为空'),
        ],
        widget=widgets.PasswordInput(),
        render_kw={'class': 'form-control', 'placeholder': 'pwd'}
    )


@acc.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'GET':
        form = LoginForm()
        return render_template('login.html', form=form)

    form = LoginForm(formdata=request.form)
    if not form.validate():
        return render_template('login.html', form=form)

    fh = SQBase.fetch_one("select id,name from userinfo where name=%(user)s and pwd=%(pwd)s", form.data)
    if fh:
        session.permanent = True
        session['user_info'] = {'id': fh['id'], 'name': fh['name']}
        return redirect('/index')
    else:
        return render_template('login.html', msg='user or pwd is wrong', form=form)

from flask import Blueprint,session
hom=Blueprint('index',__name__)
@hom.route('/index')
def index():
    user_obj=session.get('user_info')
    print('old message',user_obj)
    session['user_info']['h1']=798
    user_obj=session.get('user_info')
    print('new message',user_obj)
    return 'index'

 

from flask import Flask
from flask_session import Session
from .views import account
from .views import index

def create_aps():
    app=Flask(__name__)
    app.config.from_object('settings.DevelopmentConfig')

    app.register_blueprint(account.acc)
    app.register_blueprint(index.hom)
    # 将session替换成redis session
    Session(app)
    return app

from threading_pool import create_aps
app=create_aps()
if __name__=='__main__':
    app.__call__
    app.run()

from datetime import timedelta
from redis import Redis
import pymysql
from DBUtils.PooledDB import PooledDB, SharedDBConnection


class BaseConfig():
    DEBUG = True
    SECRET_KEY = 'aslgjkas'
    PERMANENT_SESSION_LIFETIME = timedelta(minutes=20)
    SESSION_TYPE = 'redis'
    SQL_POOL = PooledDB(
        creator=pymysql,  # 使用链接数据库的模块
        maxconnections=6,  # 连接池允许的最大连接数,0还有None表示不限制连接数
        mincached=2,  # 初始化时,连接池中至少创建的空闲的链接,0表示不创建,
        maxcached=4,  # 连接池中最多闲置的链接,0和None表示不限制,
        maxshared=3,  # 连接池中最多共享的连接数量,0和None表示共享所有,PS:基本不用这个参数,
        # 因为pymysql和MySQLdb等模块的threadsafety都是1,所以无论设置这个值为多少,maxcached永远为0,也就是所有链接共享
        blocking=True,  # 连接池中如果没有可用的链接,是否阻塞等待,
        maxusage=None,  # 一个连接最多被重复使用的次数,None表示无限次
        setsession=[],  # 开始会话前执行的命令列表,如['set datestyle to,''', 'set time zone...']
        ping=0,  # pingMySQL服务端,检查是否服务可用, # 如: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='book_list',
        charset='utf8'
    )


class ProductionConfig(BaseConfig):
    SESSION_REDIS = Redis(host='192.168.13.184', port='6379')


class DevelopmentConfig(BaseConfig):
    SESSION_REDIS = Redis(host='127.0.0.1', port='6379')


class TestingConfig(BaseConfig):
    ...