wtforms组件使用实例及源码解析

WTForms是一个支持多个web框架的form组件，主要用于对用户请求数据进行验证。

WTforms作用：当网站中需要用到表单时，WTForms变得很有效。应该把表单定义为类，作为单独的一个模块。

创建表单： 创建表单时，通常是创建一个Form的子类，表单的中的字段作为类的属性。

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 MyValidator(object): # 自定义验证器
    def __init__(self,message):
        self.message = message

    def __call__(self, form, field):
        # print(field.data)
        if field.data == '王浩':
            return None
        raise validators.StopValidation(self.message)


class LoginForm(Form):
    name = simple.StringField(
        label='用户名',
        validators=[
            # MyValidator(message='用户名必须等于王浩')
            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)


# ########################### 用户注册 ##########################
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()

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

 

源码分析

将按照代码的执行顺序分析

1.当定义好一个自定义的Form类，项目加载Form类所在模块，代码都做了什么？

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'}
    )

自定义类继承了Form类，看一下Form类

class Form(with_metaclass(FormMeta, BaseForm)):
    pass


def with_metaclass(meta, base=object):
    return meta("NewBase", (base,), {})

# 那么相当于Form继承了FormMeta("NewBase",(BaseForm,),{} ) 使用 FormMeta元类创建的对象让Form继承，则Form的元类也被指定为FormMeta

class FormMeta(type):
    def __init__(cls, name, bases, attrs):
        type.__init__(cls, name, bases, attrs)
        cls._unbound_fields = None
        cls._wtforms_meta = None

则 FormMeta创建RegisterForm为了RegisterForm产生了两个类变量

RegisterForm._unbound_fields = None
RegisterForm._wtforms_meta = None

再看类变量name 和 pwd 的字段是什么

class StringField(Field):
    """
    This field is the base for most of the more complicated fields, and
    represents an ``<input type="text">``.
    """
    widget = widgets.TextInput()

    def process_formdata(self, valuelist):
        if valuelist:
            self.data = valuelist[0]
        elif self.data is None:
            self.data = ''

    def _value(self):
        return text_type(self.data) if self.data is not None else ''
    
class Field(object):
    """
    Field base class
    """
    errors = tuple()
    process_errors = tuple()
    raw_data = None
    validators = tuple()
    widget = None
    _formfield = True
    _translations = DummyTranslations()
    do_not_call_in_templates = True  # Allow Django 1.4 traversal

    def __new__(cls, *args, **kwargs):
        if '_form' in kwargs and '_name' in kwargs:
            return super(Field, cls).__new__(cls)
        else:
            return UnboundField(cls, *args, **kwargs)

    def __init__(self, label=None, validators=None, filters=tuple(),
                 description='', id=None, default=None, widget=None,
                 render_kw=None, _form=None, _name=None, _prefix='',
                 _translations=None, _meta=None):
        pass

此时RegisterForm的类变量为

RegisterForm._unbound_fields = None
RegisterForm._wtforms_meta = None
RegisterForm.name = UnboundField(simple.StringField)
RegisterForm.pwd = UnboundField(simple.PasswordField)

print(RegisterForm.name,type(RegisterForm.name))
“”“
<UnboundField(StringField, (), {'label': '用户名', 'validators': [<wtforms.validators.DataRequired object at 0x000001C76FE778D0>], 

'widget': <wtforms.widgets.core.TextInput object at 0x000001C76FE77B00>, 'render_kw': {'class': 'form-control'}, 'default': 'ppp'})>

 <class 'wtforms.fields.core.UnboundField'>

”“”

class UnboundField(object):
    _formfield = True
    creation_counter = 0 # 初始值为0 

    def __init__(self, field_class, *args, **kwargs):
        UnboundField.creation_counter += 1 # 每事实例化一次，类变量creation_counter +1 
        self.field_class = field_class
        self.args = args
        self.kwargs = kwargs
        self.creation_counter = UnboundField.creation_counter # 实例自己的creation_counter = 被实例化先后的序号，

    def bind(self, form, name, prefix='', translations=None, **kwargs):
        kw = dict(
            self.kwargs,
            _form=form,
            _prefix=prefix,
            _name=name,
            _translations=translations,
            **kwargs
        )
        return self.field_class(*self.args, **kw)

    def __repr__(self):
        return '<UnboundField(%s, %r, %r)>' % (self.field_class.__name__, self.args, self.kwargs)

所以可知

RegisterForm._unbound_fields = None
RegisterForm._wtforms_meta = None
RegisterForm.name = UnboundField(creation_counter=1，simple.StringField)
RegisterForm.pwd = UnboundField(creation_counter=,2，simple.PasswordField)

 

2.接着在视图函数中RegisterForm中实例化发生了什么？

补充：dir() 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。

class A:
    x = 'xxx'
    age = 111
    def __init__(self,name):
        self.name = 'cp'

    def say_hi(self):
        print('hi')

print(dir(A))
a = A('cp')
print("="*40)
print(dir(a))
"""
['__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__', 'age', 'say_hi', 'x'
]
========================================
['__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__', 'age', 'name', 'say_hi', 'x'
 ]
"""

执行 form = RegisterForm(data={'gender': 1})

# 因为RegisterForm指定了FormMeta为元类,则()触发其__call__方法
def __call__(cls, *args, **kwargs):
    if cls._unbound_fields is None:
        fields = []
        for name in dir(cls): # 遍历RegisterForm的成员 name为str
            if not name.startswith('_'): # 可知自定义表单类中字段名不能以'_'开头
                unbound_field = getattr(cls, name) 
                if hasattr(unbound_field, '_formfield'): # _formfield为UnboundField的类变量 默认True 如果有x=123 则为False
                    fields.append((name, unbound_field))
        # fields = [
        #    (name, UnboundField(creation_counter=1，simple.StringField))
        #    (pwd, UnboundField(creation_counter=2，simple.PasswordField))
        # ]
        # 利用creation_counter序列编号按前后代码中的字段顺序排序
        fields.sort(key=lambda x: (x[1].creation_counter, x[0]))
        cls._unbound_fields = fields  # 此时_unbound_fields的初始值None被覆盖了

　　　
　　if cls._wtforms_meta is None:
       bases = []
       for mro_class in cls.__mro__: # 从RegisterForm的mro列表中遍历
           if 'Meta' in mro_class.__dict__: # 查看是否有写去过Meta类
               bases.append(mro_class.Meta)    # 只在Form中找到 Meta = DefaultMeta

 　　# 相当于 type('Meta', tuple(DefaultMeta), {})

       cls._wtforms_meta = type('Meta', tuple(bases), {}) 

return type.__call__(cls, *args, **kwargs)

接着执行： type.__call__(cls, *args, **kwargs)  

因为RegisterForm及其父类没有写__new__方法，则调用object的__new__创建对象，__init__则查找到父类Form中的。

class Form(with_metaclass(FormMeta, BaseForm)):
    def __init__(self, formdata=None, obj=None, prefix='', data=None, meta=None, **kwargs):
        meta_obj = self._wtforms_meta()
        if meta is not None and isinstance(meta, dict):
            meta_obj.update_values(meta)
        super(Form, self).__init__(self._unbound_fields, meta=meta_obj, prefix=prefix) # 调用父类的方法


        for name, field in iteritems(self._fields): # 上一步给self._fields赋好值后，循环
            setattr(self, name, field) # 给self.name = simple.StringField()  self.pwd = simple.PasswordField()
            # 就可以 form.name form.pwd 了
        self.process(formdata, obj, data=data, **kwargs) # BaseForm的方法


class BaseForm(object):
    def __init__(self, fields, prefix='', meta=DefaultMeta()):
        if prefix and prefix[-1] not in '-_;:/.':
            prefix += '-'

        self.meta = meta
        self._prefix = prefix
        self._errors = None
        self._fields = OrderedDict()

        if hasattr(fields, 'items'):
            fields = fields.items()

        translations = self._get_translations()
        extra_fields = []
        if meta.csrf:
            self._csrf = meta.build_csrf(self)
            extra_fields.extend(self._csrf.setup_form(self))

        # fields = _unbound_fields = [
        #    (name, UnboundField(creation_counter=1，simple.StringField))
        #    (pwd, UnboundField(creation_counter=2，simple.PasswordField))
        # ]
        for name, unbound_field in itertools.chain(fields, extra_fields):
            options = dict(name=name, prefix=prefix, translations=translations)
            field = meta.bind_field(self, unbound_field, options) # 实例化simple.StringField
            self._fields[name] = field # OrderedDict()向有序字典中添加排好序的fields

        #  self._fields = OrderedDict = {
        #   name: simple.StringField(),
        #   pwd: simple.PasswordField(),
        # }

    def process(self, formdata=None, obj=None, data=None, **kwargs):
        """
        Take form, object data, and keyword arg input and have the fields
        process them.
        。。。
        """
        formdata = self.meta.wrap_formdata(self, formdata)

        if data is not None:
            # XXX we want to eventually process 'data' as a new entity.
            #     Temporarily, this can simply be merged with kwargs.
            kwargs = dict(data, **kwargs)

        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)

 

 

 从源码中可知使用注意：

1、字段名是区分大小写的

2、字段名不能以'_'开头

3、字段名不能以'validate'开头

 

 

参考：

1.https://www.cnblogs.com/Chuck-Y/p/8260156.html?utm_source=tuicool&utm_medium=referral

2.https://www.cnblogs.com/wupeiqi/articles/8202357.html