Flask-WTForms

what's the WTForms

　　WTForms是一個支持多個web框架的form組件，主要用於對用戶請求數據進行驗證。其做用是能夠爲輕量級的框架提供相似Django的form的功能。

安裝：

pip3 install wtforms

　

源碼流程分析

實例化流程分析

# 源碼流程
    1. 執行type的 __call__ 方法，讀取字段到靜態字段 cls._unbound_fields 中； meta類讀取到cls._wtforms_meta中
    2. 執行構造方法
        
        a. 循環cls._unbound_fields中的字段，並執行字段的bind方法，而後將返回值添加到 self._fields[name] 中。
            即：
                _fields = {
                    name: wtforms.fields.core.StringField(),
                }
                
            PS：因爲字段中的__new__方法，實例化時：name = simple.StringField(label='用戶名')，建立的是UnboundField(cls, *args, **kwargs)，當執行完bind以後，才變成執行 wtforms.fields.core.StringField()
        
        b. 循環_fields，爲對象設置屬性
            for name, field in iteritems(self._fields):
                # Set all the fields to attributes so that they obscure the class
                # attributes with the same names.
                setattr(self, name, field)
        c. 執行process，爲字段設置默認值：self.process(formdata, obj, data=data, **kwargs)
            優先級：obj,data,formdata;
            
            再循環執行每一個字段的process方法，爲每一個字段設置值：
            for name, field, in iteritems(self._fields):
                if obj is not None and hasattr(obj, name):
                    field.process(formdata, getattr(obj, name))
                elif name in kwargs:
                    field.process(formdata, kwargs[name])
                else:
                    field.process(formdata)
            
            執行每一個字段的process方法，爲字段的data和字段的raw_data賦值
            def process(self, formdata, data=unset_value):
                self.process_errors = []
                if data is unset_value:
                    try:
                        data = self.default()
                    except TypeError:
                        data = self.default
        
                self.object_data = data
        
                try:
                    self.process_data(data)
                except ValueError as e:
                    self.process_errors.append(e.args[0])
        
                if formdata:
                    try:
                        if self.name in formdata:
                            self.raw_data = formdata.getlist(self.name)
                        else:
                            self.raw_data = []
                        self.process_formdata(self.raw_data)
                    except ValueError as e:
                        self.process_errors.append(e.args[0])
        
                try:
                    for filter in self.filters:
                        self.data = filter(self.data)
                except ValueError as e:
                    self.process_errors.append(e.args[0])
                
        d. 頁面上執行print(form.name) 時，打印標籤
            
            由於執行了：
                字段的 __str__ 方法
                字符的 __call__ 方法
                self.meta.render_field(self, kwargs)
                    def render_field(self, field, render_kw):
                        other_kw = getattr(field, 'render_kw', None)
                        if other_kw is not None:
                            render_kw = dict(other_kw, **render_kw)
                        return field.widget(field, **render_kw)
                執行字段的插件對象的 __call__ 方法，返回標籤字符串

View Code

驗證流程分析

a. 執行form的validate方法，獲取鉤子方法
            def validate(self):
                extra = {}
                for name in self._fields:
                    inline = getattr(self.__class__, 'validate_%s' % name, None)
                    if inline is not None:
                        extra[name] = [inline]
        
                return super(Form, self).validate(extra)
        b. 循環每個字段，執行字段的 validate 方法進行校驗(參數傳遞了鉤子函數)
            def validate(self, extra_validators=None):
                self._errors = None
                success = True
                for name, field in iteritems(self._fields):
                    if extra_validators is not None and name in extra_validators:
                        extra = extra_validators[name]
                    else:
                        extra = tuple()
                    if not field.validate(self, extra):
                        success = False
                return success
        c. 每一個字段進行驗證時候
            字段的pre_validate 【預留的擴展】
            字段的_run_validation_chain，對正則和字段的鉤子函數進行校驗
            字段的post_validate【預留的擴展】

View Code

 

用戶登陸註冊示例

1. 用戶登陸

　　當用戶登陸時候，須要對用戶提交的用戶名和密碼進行多種格式校驗。如：

　　用戶不能爲空；用戶長度必須大於6；

　　密碼不能爲空；密碼長度必須大於12；密碼必須包含 字母、數字、特殊字符等（自定義正則）；

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

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

 

2. 用戶註冊

　　註冊頁面須要讓用戶輸入：用戶名、密碼、密碼重複、性別、愛好等。

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 RegisterForm(Form):
    name = simple.StringField(
        label='用戶名',
        validators=[
            validators.DataRequired()
        ],
        widget=widgets.TextInput(),
        render_kw={'class': 'form-control'},
        default='alex'
    )

    pwd = simple.PasswordField(
        label='密碼',
        validators=[
            validators.DataRequired(message='密碼不能爲空.')
        ],
        widget=widgets.PasswordInput(),
        render_kw={'class': 'form-control'}
    )

    pwd_confirm = simple.PasswordField(
        label='重複密碼',
        validators=[
            validators.DataRequired(message='重複密碼不能爲空.'),
            validators.EqualTo('pwd', message="兩次密碼輸入不一致")
        ],
        widget=widgets.PasswordInput(),
        render_kw={'class': 'form-control'}
    )

    email = html5.EmailField(
        label='郵箱',
        validators=[
            validators.DataRequired(message='郵箱不能爲空.'),
            validators.Email(message='郵箱格式錯誤')
        ],
        widget=widgets.TextInput(input_type='email'),
        render_kw={'class': 'form-control'}
    )

    gender = core.RadioField(
        label='性別',
        choices=(
            (1, '男'),
            (2, '女'),
        ),
        coerce=int
    )
    city = core.SelectField(
        label='城市',
        choices=(
            ('bj', '北京'),
            ('sh', '上海'),
        )
    )

    hobby = core.SelectMultipleField(
        label='愛好',
        choices=(
            (1, '籃球'),
            (2, '足球'),
        ),
        coerce=int
    )

    favor = core.SelectMultipleField(
        label='喜愛',
        choices=(
            (1, '籃球'),
            (2, '足球'),
        ),
        widget=widgets.ListWidget(prefix_label=False),
        option_widget=widgets.CheckboxInput(),
        coerce=int,
        default=[1, 2]
    )

    def __init__(self, *args, **kwargs):
        super(RegisterForm, self).__init__(*args, **kwargs)
        self.favor.choices = ((1, '籃球'), (2, '足球'), (3, '羽毛球'))

    def validate_pwd_confirm(self, field):
        """
        自定義pwd_confirm字段規則，例：與pwd字段是否一致
        :param field: 
        :return: 
        """
        # 最開始初始化時，self.data中已經有全部的值

        if field.data != self.data['pwd']:
            # raise validators.ValidationError("密碼不一致") # 繼續後續驗證
            raise validators.StopValidation("密碼不一致")  # 再也不繼續後續驗證


@app.route('/register', methods=['GET', 'POST'])
def register():
    if request.method == 'GET':
        form = RegisterForm(data={'gender': 1})
        return render_template('register.html', form=form)
    else:
        form = RegisterForm(formdata=request.form)
        if form.validate():
            print('用戶提交數據經過格式驗證，提交的值爲：', form.data)
        else:
            print(form.errors)
        return render_template('register.html', form=form)



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

app.py

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1>用戶註冊</h1>
<form method="post" novalidate style="padding:0  50px">
    {% for item in form %}
    <p>{{item.label}}: {{item}} {{item.errors[0] }}</p>
    {% endfor %}
    <input type="submit" value="提交">
</form>
</body>
</html>

register.html

 

metaclass知識點

　　metaclass是建立類的元類，即通常的類是metaclass的對象，在類被解釋的時候就會觸發其元類的__init__方法，而類被實例化的時候，會先執行元類的__call__方法再執行本身的__new__方法最後才執行本身的__init__方法

#方式一：
class MyType(type):
    def __init__(self, *args, **kwargs):
        print('MyType建立類',self)
        super(MyType, self).__init__(*args, **kwargs)

    def __call__(self, *args, **kwargs):
        obj = super(MyType, self).__call__(*args, **kwargs)
        print('類建立對象', self, obj)
        return obj


class Foo(object,metaclass=MyType):
    user = 'wupeiqi'
    age = 18

obj = Foo()



#方式二：
class MyType(type):
    def __init__(self, *args, **kwargs):
        super(MyType, self).__init__(*args, **kwargs)

    def __call__(cls, *args, **kwargs):
        v = dir(cls)
        obj = super(MyType, cls).__call__(*args, **kwargs)
        return obj


class Foo(MyType('MyType', (object,), {})):
    user = 'wupeiqi'
    age = 18


obj = Foo()




#方式三：
class MyType(type):
    def __init__(self, *args, **kwargs):
        super(MyType, self).__init__(*args, **kwargs)

    def __call__(cls, *args, **kwargs):
        v = dir(cls)
        obj = super(MyType, cls).__call__(*args, **kwargs)
        return obj


def with_metaclass(arg,base):
    return MyType('MyType', (base,), {})


class Foo(with_metaclass(MyType,object)):
    user = 'wupeiqi'
    age = 18


obj = Foo()

metaclass建立類的三種方式

 

自定義form

　　form組件其實由三大部分組成：類、字段、插件。因此咱們要自定義form，就自定義這三部分就行。

from flask import Flask, render_template, request, redirect,Markup
app = Flask(__name__, template_folder='templates')
import wtforms
app.debug = True

# 插件
class Widget(object):
    #基類
    pass

class InputText(Widget):
    # input插件
    def __call__(self, *args, **kwargs):
        return "<input type='text' name='name' />"

class TextArea(Widget):
    # textarea插件
    def __call__(self, *args, **kwargs):
        return "<textarea name='email'> </textarea>"

# Form類
class BaseForm(object):
    def __init__(self):
        # 獲取當前字段
        _fields = {}
        for name,field in self.__class__.__dict__.items():
            if isinstance(field,Field):
                _fields[name] = field
        self._fields = _fields
        self.data = {}


    def validate(self,request_data):
        # 找到全部的字段，執行每一個字段的validate方法
        flag = True
        for name,field in self._fields.items():
            # 123
            input_val = request_data.get(name,'')
            result = field.validate(input_val)
            if not result:
                flag = False
            else:
                self.data[name] = input_val
        return flag
# 字段
class Field(object):

    def __str__(self):
        return Markup(self.widget())

class StringField(Field):
    widget = InputText()

    def validate(self,val):
        if val:
            return True

class EmailField(Field):
    widget = TextArea() # EmailField.widget/ self.widget
    reg = ".*@.*"

    def validate(self, val):
        import re
        if re.match(self.reg,val):
            return True

########## 使用 ###############
class LoginForm(BaseForm):
    name = StringField()
    email = EmailField()


@app.route('/login', methods=['GET', 'POST'])
def login():

    form = LoginForm()
    ret = form.validate(request.form)
    print("驗證成功",ret)
    print("驗證成功值",form.data)
    # print(obj.name)
    # print(obj.email)
    return render_template('login.html',form=form)

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

app.py

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<form method="post">
    {{ form.name }}
    {{ form.email }}
    <input type="submit" value="提交">
    </form>
</body>
</html>

login.html