Django form组件

时间 2019-12-07

标签 django form 组件栏目 Python 繁體版

原文原文链接

一. 前言

　　在使用Form组件以前，咱们都是经过form表单来提交数据的，若是须要对form表单中的数据进行校验，就要采用JQuery、ajax等来获取各个用户输入的内容并进行判断，若是不规范还要用一堆判断去确认返回的结果。总之有些繁琐，而Django中的Form组件则为咱们提供了很便利的方法来完成以上操做。css

　　当咱们进行校验时，前端能够不进行校验，可是后端是必须进行数据校验的。由于前端的的防护简直形如虚设，能够在谷歌浏览器上经过右键检查--》ctrl+shift+c点击对应的内容定位至对应代码--》双击修改代码（好比密码显示密文，能够经过该方式将type修改成text让密码显示为明文）。html

　　Form组件能够帮咱们完成一下三件事：前端

渲染标签
校验数据（先后端都可进行校验）
展现信息（如校验未经过，展现相应错误信息）

二. Form组件的使用

1. 校验数据

　　1. 首先须要先导入模块，并定义一个Form类jquery

　　Form类中定义的字段其实就是Form组件校验数据的依据，好比password长度咱们设置为3~6，那么当输入的密码长度不符合时就是校验未经过。git

from django import forms

# 乍一看是否是跟Django的ORM models派生类很像
class MyForm(forms.Form):
    # 定义name字段，最大长度6
    name = forms.CharField(max_length=6)
    # 定义password字段，长度至少为3，最大长度6
    password = forms.CharField(max_length=6, min_length=3)
    # 定义email字段
    email = forms.EmailField()

　　2. 实例化对象，实例化时能够传一个字典或者不传web

　　实例化出的Form对象有is_valid()、errors、cleaned_data等方法。接下来在配置好的tests.py文件中测试一下。ajax

　　测试用的.py文件中必须为如下格式：正则表达式

from django.test import TestCase

# Create your tests here.
import os
import sys

if __name__ == "__main__":
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "untitled1.settings")
    import django
    django.setup()
    # 这里开始写测试的代码，须要导入模块也要从这里开始写导入语法

　　测试结果以下，发现form_obj.errors打印为空。数据库

　　继续测试，将实例化时传入的字典修改一下：django

　　注意：

校验时Form中全部定义的字段默认都必须传值（字段设置required=False能够不传值），否则is_valid()返回确定为False，同时form_obj.errors中会有错误信息：This field is required.
校验时数据传多了不要紧，由于Form类中未定义的字段它根本不会理会，不会去校验。
必须先执行is_valid()方法，否则执行cleaned_data会报错，由于该属性是只有执行了is_valid()才会出现的！！！！！！！！

2. 渲染标签

　　了解了校验数据的方式以及错误信息存放处errors，接下来就是了解渲染标签了。

　　首先要实例化一个Form空对象，而后将其传至前端，使用模板语法进行渲染。

def register(request):
    # 实例化一个Form空对象
    form_obj = MyForm()
    return render(request, 'register.html', locals())


# 这是自定义的Form类
class MyForm(forms.Form):
    name = forms.CharField(max_length=6)
    password = forms.CharField(max_length=6, min_length=3)
    email = forms.EmailField()

　 Form组件三种渲染的方式：

　　第一种（封装性高，扩展性差）：

{{ form_obj.as_p }}

　　执行以上代码的效果：

　　执行{{ form_obj }}和{{ form_obj.as_table }}，发现结果一致，因此看来默认是as_table:

　　第二种渲染方式：

<form action="">
        <!--.label是取出字段属性lable的值，未设置时默认用首字母大写的字段名-->
    <p>{{ form_obj.name.label }}{{ form_obj.name }}</p>
    <p>{{ form_obj.password.label }}{{ form_obj.password }}</p>
    <p>{{ form_obj.email.label }}{{ form_obj.email }}</p>
    <input type="submit">
</form>

　　因此咱们能够给字段设置lable属性：

class MyForm(forms.Form):
    name = forms.CharField(max_length=6, label='用户名')
    password = forms.CharField(max_length=6, min_length=3, label='密码')
    email = forms.EmailField(label='邮箱')

　　如今看结果：

　　根据以上结果，能够大胆猜想Form类实例化出的对象form_obj是一个可迭代对象！！！

　　第三种渲染方式（建议使用该方式）：

<form action="">
       <!--这里的foo就是字段对象，好比form_obj.name-->
    {% for foo in form_obj %}
        <p>{{ foo.label }}{{ foo }}</p>
    {% endfor %}
</form>

　　注意：Form组件只会帮咱们渲染获取用户输入的标签，提交按钮须要咱们本身添加。

3. 校验数据

　　使用第三种渲染方式，手动添加提交按钮：

<form action="" method="post">
    {% for foo in form_obj %}
        <p>{{ foo.label }}{{ foo }}</p>
    {% endfor %}
    <input type="submit">
</form>

　　如今运行代码，发现前端随便输入数据，点击提交时会有提示了：

　　能够给form表单设置novalidate取消前端的校验：

<form action="" method="post" novalidate></form>

　　以前说后端的校验时必须的，接下来咱们一块儿看看后端校验（前提是要关闭前端校验，否则数据只要有错都提交不到后端）：

def register(request):
    form_obj = MyForm()
    if request.method == 'POST':
　　　print(request.POST)
        # 以前说Form类实例化能够传一个字典，而request.POST刚好是一个相似字典的对象
        form_obj = MyForm(request.POST)
        print(form_obj.is_valid())
        print(form_obj.cleaned_data)
        print(form_obj.errors)
    return render(request, 'register.html', locals())

　　输入数据，看一下后端校验的结果：

　　校验数据未经过时咱们须要将错误信息展现在相应位置，经过增长一个span来实现：

<form action="" method="post" novalidate>
    {% for foo in form_obj %}
        <p>{{ foo.label }}{{ foo }}</p>
         <!--foo是字段对象，能够经过.errors拿出错误信息，若是没有则为空-->
        <span>{{ foo.errors }}</span>
    {% endfor %}
    <input type="submit">
</form>

　　看相应结果：

　　结果不对对劲，错误信息通常是显示在对应输入框的后面，而此处错误信息显示的仍是ul列表的形式，修改代码{{ foo.errors.0 }}拿出第一个元素，同时将span标签页一块儿放入p标签中：

<form action="" method="post" novalidate>
    {% for foo in form_obj %}
        <p>{{ foo.label }}{{ foo }}<span>{{ foo.errors.0 }}</span></p>
    {% endfor %}
    <input type="submit">
</form>

　　接下来再看结果：

　　到这里，有没有疑惑为何点击提交后页面刷新了而数据却还在，其实这是由于后端将本来的form_obj替换了一个同名的，而里面的数据就是前段提交的数据。

　　修改后端视图函数代码：

def register(request):
    form_obj = MyForm()
    if request.method == 'POST':
        print(request.POST)
        # 以前说Form类实例化能够传一个字典，而request.POST刚好是一个相似字典的对象
        form_obj = MyForm(request.POST)
        # 若是校验所有经过，返回消息
        if form_obj.is_valid():
            return HttpResponse('校验所有经过')
    return render(request, 'register.html', locals())

　　3.1 自定义报错信息

　　到如今为止，咱们能够发现报错信息全是英文，咱们能够自定义报错信息，只须要经过在Form类定义的字段中增长error_messages={ “报错类型”：‘报错信息’ }：

class MyForm(forms.Form):
    name = forms.CharField(max_length=6, label='用户名', error_messages={
        'max_length': '用户名最多6位',
        'required': '用户名不能为空'
    })
    password = forms.CharField(max_length=6, min_length=3, label='密码',error_messages={
        'min_length': '密码不能小于3位',
        'max_length': '密码最多6位',
        'required': '密码不能为空'
    })
    email = forms.EmailField(label='邮箱')

　　试验结果：

　　要试验用户名超过6位的报错，必须执行如下操做（前端防护真的菜）：

　　3.2 密码实现密文

　　密码输入是明文简直不要太酸爽，将密码变为密文须要借助字段的widget属性（须要使用widgets模块）：

from django import forms
# 若是forms.widgets点不出来就须要导入widgets
from django.forms import widgets


password = forms.CharField(max_length=6, min_length=3, label='密码', 
　　　　　widget=widgets.PasswordInput())

　　3.2 实现注册功能，且名字不含66

　　大体思路以下：

注册通常须要输入两次密码，在刚刚代码的基础上增长一个字段re_password，同password同样设置为密文。
由于名字不能含有66，可使用Form组件提供的局部钩子函数。
两次密码须要校验一不一致，可使用全局钩子函数。

　　局部钩子函数与全局钩子函数：

　　在Form类中定义一个函数名为 clean_字段名的函数即为局部钩子函数，里面能够经过self.cleaned_data.get('字段名')来获取字段的值，随后在该函数中对该字段进行各类判断，对应的错误信息经过self.add_error('字段名', '错误信息')添加。

　　全局钩子函函数名为 clean 的函数，里面能够对多个字段进行操做，最后返回self.cleaned_data。

　　使用钩子函数时，咱们使用self.add_error是自定义异常，也能够选择主动抛出异常ValidationError，该异常抛出时会被Form组件检测到并将异常主动加入errors中，并不会影响到服务端的运行。

from django.core.exceptions import ValidationError

def clean_name(self):
    name = self.cleaned_data.get('name')
    if '666' in name:
        # 1.主动抛出异常
        raise ValidationError("光喊666是不行的")
        # 2.自定义异常
        self.add_error({'name','光喊666是不行的'})
    return name

　　最终代码以下：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>register</title>
    <script src="https://cdn.bootcss.com/jquery/3.4.1/jquery.min.js"></script>
    <script src="https://cdn.bootcss.com/twitter-bootstrap/3.4.1/js/bootstrap.min.js"></script>
    <link href="https://cdn.bootcss.com/twitter-bootstrap/3.4.1/css/bootstrap.min.css" rel="stylesheet">
</head>
<body>
<form action="" method="post" novalidate>
    {% for foo in form_obj %}
        <p>{{ foo.label }}{{ foo }}<span>{{ foo.errors.0 }}</span></p>
    {% endfor %}
    <input type="submit">
</form>
</body>
</html>

html代码

from django.shortcuts import render, HttpResponse, reverse, redirect
from app01 import models
from django import forms
from django.forms import widgets
# Create your views here.


def register(request):
    form_obj = MyForm()
    if request.method == 'POST':
        print(request.POST)
        # 以前说Form类实例化能够传一个字典，而request.POST刚好是一个相似字典的对象
        form_obj = MyForm(request.POST)
        if form_obj.is_valid():
            return HttpResponse('校验所有经过')
    return render(request, 'register.html', locals())


class MyForm(forms.Form):
    name = forms.CharField(max_length=6, label='用户名', error_messages={
        'max_length': '用户名最多6位',
        'required': '用户名不能为空'
    })
    password = forms.CharField(max_length=6, min_length=3, label='密码',error_messages={
        'min_length': '密码不能小于3位',
        'max_length': '密码最多6位',
        'required': '密码不能为空',
    }, widget=widgets.PasswordInput())

    re_password = forms.CharField(max_length=6, min_length=3, label='确认密码', widget=widgets.PasswordInput())
    email = forms.EmailField(label='邮箱', error_messages={'invalid': '格式错误'})

    def clean_name(self):
        name = self.cleaned_data.get('name')
        if '66' in name:
            self.add_error('name', '名字太6了可不行')
        return name

    def clean(self):
        password = self.cleaned_data.get('password')
        re_password = self.cleaned_data.get('re_password')
        if password != re_password:
            self.add_error('re_password', '两次密码不一致')
        return self.cleaned_data

views

　　注意：使用钩子函数时，只有钩子函数所需字段校验经过了才会去执行该钩子函数，也就是说钩子函数中self.add_error方法添加的错误信息显示优先级是低于字段中error_messages属性中定义的错误信息的。

　　舒适提示：

像邮箱等有固定格式的信息校验时，能够给字段设置error_messages={'invalid': ‘格式错误’}等，这样错误信息更具备提示性。
导入的forms模块使用forms.widgets没用时，应该再导入form forms import widgets，由于多是由于版本问题，forms包中的__init__.py中没有widgets的名字。
能够经过字段属性widget=widgets.输入类型(attr={'标签属性名': '属性值'})来给对应的渲染标签加属性（如：widget=widgets.PasswordInput(attrs={'class':'c1 form-control'})），多个样式的类继承时用空格隔开便可。

class LoginForm(forms.Form):
    username = forms.CharField(
        min_length=8,
        label="用户名",
        initial="张三",
        error_messages={
            "required": "不能为空",
            "invalid": "格式错误",
            "min_length": "用户名最短8位"
        }
    ...

    def __init__(self, *args, **kwargs):
        super(LoginForm, self).__init__(*args, **kwargs)
        for field in iter(self.fields):
            self.fields[field].widget.attrs.update({
                'class': 'form-control'
            })

批量设置样式

三. Form组件经常使用字段与插件

　　建立Form类时，主要涉及字段与插件，字段字段用于对用户请求数据的验证，插件用于自动生成HTML。

3.1 经常使用字段

　　1. initial

　　input框里的初始值

class LoginForm(forms.Form):
    username = forms.CharField(
        min_length=8,
        label="用户名",
        initial="张三"  # 设置默认值
    )
    pwd = forms.CharField(min_length=6, label="密码")

　　2. error_messages

　　自定义错误信息

class LoginForm(forms.Form):
    username = forms.CharField(
        min_length=8,
        label="用户名",
        initial="张三",
        error_messages={
            # '属性名': '错误信息'
            "required": "不能为空",
            "min_length": "用户名最短8位"
        }
    )
    pwd = forms.CharField(min_length=6, label="密码")

　　3. radioSelect

　　通常用于性别选择等。

class LoginForm(forms.Form):
    gender = forms.fields.ChoiceField(
        choices=((1, "男"), (2, "女"), (3, "保密")),
        label="性别",
        # 默认选择第3个
        initial=3,
        widget=forms.widgets.RadioSelect()
    )

　　4.单选Select

class LoginForm(forms.Form):
    hobby = forms.ChoiceField(
        choices=((1, "篮球"), (2, "足球"), (3, "双色球"), ),
        label="爱好",
        initial=3,
        widget=forms.widgets.Select()
    )

　　5.多选Select

class LoginForm(forms.Form):
    hobby = forms.MultipleChoiceField(
        choices=((1, "篮球"), (2, "足球"), (3, "双色球"), ),
        label="爱好",
        # 默认的选多个值时要用列表
        initial=[1, 3],
        widget=forms.widgets.SelectMultiple()
    )

　　6.单选checkbox

class LoginForm(forms.Form):
    keep = forms.ChoiceField(
        label="是否记住密码",
        initial="checked",
        widget=forms.widgets.CheckboxInput()
    )

　　6.多选checkbox

class LoginForm(forms.Form):
    hobby = forms.MultipleChoiceField(
        choices=((1, "篮球"), (2, "足球"), (3, "双色球"),),
        label="爱好",
        initial=[1, 3],
        widget=forms.widgets.CheckboxSelectMultiple()
    )

　　小提示：ChoiceFIeld实例化的字段对象，widget默认是forms.widgets.Select()，CharField实例化的字段对象默认是forms.widgets.Input()。

Field
    required=True,               是否容许为空
    widget=None,                 HTML插件
    label=None,                  用于生成Label标签或显示内容
    initial=None,                初始值
    help_text='',                帮助信息(在标签旁边显示)
    error_messages=None,         错误信息 {'required': '不能为空', 'invalid': '格式错误'}
    validators=[],               自定义验证规则
    localize=False,              是否支持本地化
    disabled=False,              是否能够编辑
    label_suffix=None            Label内容后缀
 
 
CharField(Field)
    max_length=None,             最大长度
    min_length=None,             最小长度
    strip=True                   是否移除用户输入空白
 
IntegerField(Field)
    max_value=None,              最大值
    min_value=None,              最小值
 
FloatField(IntegerField)
    ...
 
DecimalField(IntegerField)
    max_value=None,              最大值
    min_value=None,              最小值
    max_digits=None,             总长度
    decimal_places=None,         小数位长度
 
BaseTemporalField(Field)
    input_formats=None          时间格式化   
 
DateField(BaseTemporalField)    格式：2015-09-01
TimeField(BaseTemporalField)    格式：11:12
DateTimeField(BaseTemporalField)格式：2015-09-01 11:12
 
DurationField(Field)            时间间隔：%d %H:%M:%S.%f
    ...
 
RegexField(CharField)
    regex,                      自定制正则表达式
    max_length=None,            最大长度
    min_length=None,            最小长度
    error_message=None,         忽略，错误信息使用 error_messages={'invalid': '...'}
 
EmailField(CharField)      
    ...
 
FileField(Field)
    allow_empty_file=False     是否容许空文件
 
ImageField(FileField)      
    ...
    注：须要PIL模块，pip3 install Pillow
    以上两个字典使用时，须要注意两点：
        - form表单中 enctype="multipart/form-data"
        - view函数中 obj = MyForm(request.POST, request.FILES)
 
URLField(Field)
    ...
 
 
BooleanField(Field)  
    ...
 
NullBooleanField(BooleanField)
    ...
 
ChoiceField(Field)
    ...
    choices=(),                选项，如：choices = ((0,'上海'),(1,'北京'),)
    required=True,             是否必填
    widget=None,               插件，默认select插件
    label=None,                Label内容
    initial=None,              初始值
    help_text='',              帮助提示
 
 
ModelChoiceField(ChoiceField)
    ...                        django.forms.models.ModelChoiceField
    queryset,                  # 查询数据库中的数据
    empty_label="---------",   # 默认空显示内容
    to_field_name=None,        # HTML中value的值对应的字段
    limit_choices_to=None      # ModelForm中对queryset二次筛选
     
ModelMultipleChoiceField(ModelChoiceField)
    ...                        django.forms.models.ModelMultipleChoiceField
 
 
     
TypedChoiceField(ChoiceField)
    coerce = lambda val: val   对选中的值进行一次转换
    empty_value= ''            空值的默认值
 
MultipleChoiceField(ChoiceField)
    ...
 
TypedMultipleChoiceField(MultipleChoiceField)
    coerce = lambda val: val   对选中的每个值进行一次转换
    empty_value= ''            空值的默认值
 
ComboField(Field)
    fields=()                  使用多个验证，以下：即验证最大长度20，又验证邮箱格式
                               fields.ComboField(fields=[fields.CharField(max_length=20), fields.EmailField(),])
 
MultiValueField(Field)
    PS: 抽象类，子类中能够实现聚合多个字典去匹配一个值，要配合MultiWidget使用
 
SplitDateTimeField(MultiValueField)
    input_date_formats=None,   格式列表：['%Y--%m--%d', '%m%d/%Y', '%m/%d/%y']
    input_time_formats=None    格式列表：['%H:%M:%S', '%H:%M:%S.%f', '%H:%M']
 
FilePathField(ChoiceField)     文件选项，目录下文件显示在页面中
    path,                      文件夹路径
    match=None,                正则匹配
    recursive=False,           递归下面的文件夹
    allow_files=True,          容许文件
    allow_folders=False,       容许文件夹
    required=True,
    widget=None,
    label=None,
    initial=None,
    help_text=''
 
GenericIPAddressField
    protocol='both',           both,ipv4,ipv6支持的IP格式
    unpack_ipv4=False          解析ipv4地址，若是是::ffff:192.0.2.1时候，可解析为192.0.2.1， PS：protocol必须为both才能启用
 
SlugField(CharField)           数字，字母，下划线，减号（连字符）
    ...
 
UUIDField(CharField)           uuid类型


Django Form内置字段

Django Form内置字段

3.2 choice字段注意事项

　　在使用选择标签时，须要注意choices的选项能够配置从数据库中获取，可是因为是静态字段获取的值没法实时更新，须要重写构造方法从而实现choice实时更新。

　　方式一：

from django.forms import Form
from django.forms import widgets
from django.forms import fields

 
class MyForm(Form):
 
    user = fields.ChoiceField(
        # choices=((1, '上海'), (2, '北京'),),
        initial=2,
        widget=widgets.Select()
    )
 
    def __init__(self, *args, **kwargs):
        super(MyForm,self).__init__(*args, **kwargs)
        # self.fields['user'].choices = ((1, '上海'), (2, '北京'),)
        # 或
        self.fields['user'].choices = models.Classes.objects.all().values_list('id','caption')

　　方式二：

from django import forms
from django.forms import fields
from django.forms import models as form_model

 
class FInfo(forms.Form):
    authors = form_model.ModelMultipleChoiceField(queryset=models.NNewType.objects.all())  # 多选
    # authors = form_model.ModelChoiceField(queryset=models.NNewType.objects.all())  # 单选

3.3 ModelForm

　　一般在Django项目中，咱们编写的大部分都是与Django 的模型紧密映射的表单。举个例子，你也许会有个Book 模型，而且你还想建立一个form表单用来添加和编辑书籍信息到这个模型中。在这种状况下，在form表单中定义字段将是冗余的，由于咱们已经在模型中定义了那些字段。

　　基于这个缘由，Django 提供一个辅助类来让咱们能够从Django 的模型建立Form，这就是ModelForm。

　　ModelForm顾名思义就Form和Django的Model数据库模型结合体，能够简单、方便得对数据库进行增长、编辑操做和验证标签的生成。

　　ModelForm是Django Model.py和Form组件的结合体，能够简单/快速使用 Form验证和数据库操做功能，但不如Form组件灵活，若是在使用Django作web开发过程当中验证的数据和数据库字段相关（能够对表进行增、删、改操，注意 Many to many字段，也能够级联操做第3张关系表；），建议优先使用ModelForm，用起来更方便些，可是在使用ModelForm的时候慎用fields='__all__'，获取数据库全部字段势必形成性能损耗。

　　1. modelForm定义

class BookForm(forms.ModelForm):

    class Meta:
        model = models.Book
        fields = "__all__"
        labels = {
            "title": "书名",
            "price": "价格"
        }
        widgets = {
            "password": forms.widgets.PasswordInput(attrs={"class": "c1"}),
        }

　　2. class Meta下经常使用参数　　

model = models.Book  # 对应的Model中的类
fields = "__all__"  # 字段，若是是__all__,就是表示列出全部的字段
exclude = None  # 排除的字段
labels = None  # 提示信息
help_texts = None  # 帮助提示信息
widgets = None  # 自定义插件
error_messages = None  # 自定义错误信息

　　3. ModelForm的验证

　　与普通的Form表单验证类型相似，ModelForm表单的验证在调用is_valid() 或访问errors 属性时隐式调用。咱们能够像使用Form类同样自定义局部钩子方法和全局钩子方法来实现自定义的校验规则。若是咱们不重写具体字段并设置validators属性的话，ModelForm是按照模型中字段的validators来校验的。

　　4. save()方法

　　每一个ModelForm还具备一个save()方法。这个方法根据表单绑定的数据建立并保存数据库对象。 ModelForm的子类能够接受现有的模型实例做为关键字参数instance；若是提供此功能，则save()将更新该实例。若是没有提供，save() 将建立模型的一个新实例：

>>> from myapp.models import Book
>>> from myapp.forms import BookForm

# 根据POST数据建立一个新的form对象
>>> form_obj = BookForm(request.POST)

# 建立书籍对象
>>> new_ book = form_obj.save()

# 基于一个书籍对象建立form对象
>>> edit_obj = Book.objects.get(id=1)
# 使用POST提交的数据更新书籍对象
>>> form_obj = BookForm(request.POST, instance=edit_obj)
>>> form_obj.save()

　　举个小例子：

from app02 import models
from django.forms import ModelForm
class UserModalForm(ModelForm):
    class Meta:
        model=models.UserInfo #(该字段必须为 model  数据库中表)
        fields= '__all__'   #(该字段必须为 fields 数据库中表)

def add(request):
     # 实例化models_form
    if request.method=='GET':
        obj = UserModalForm()
        return render(request,'register.html',locals())
    else:
        obj=UserModalForm(request.POST)
        if obj.is_valid():
            data=obj.cleaned_data
            obj.save()  #form验证经过直接 添加用户信息到数据库
        return render(request, 'register.html', locals())

　　有兴趣能够百度自行学习。

3.4 字段校验（随便看看便可）

　　1. RegexValidator验证器

from django.forms import Form
from django.forms import widgets
from django.forms import fields
from django.core.validators import RegexValidator
 
class MyForm(Form):
    user = fields.CharField(
        validators=[RegexValidator(r'^[0-9]+$', '请输入数字'), RegexValidator(r'^159[0-9]+$', '数字必须以159开头')],
    )

View Code

　　2.自定义验证函数

import re
from django.forms import Form
from django.forms import widgets
from django.forms import fields
from django.core.exceptions import ValidationError
 
 
# 自定义验证规则
def mobile_validate(value):
    mobile_re = re.compile(r'^(13[0-9]|15[012356789]|17[678]|18[0-9]|14[57])[0-9]{8}$')
    if not mobile_re.match(value):
        raise ValidationError('手机号码格式错误')
 
 
class PublishForm(Form):
 
 
    title = fields.CharField(max_length=20,
                            min_length=5,
                            error_messages={'required': '标题不能为空',
                                            'min_length': '标题最少为5个字符',
                                            'max_length': '标题最多为20个字符'},
                            widget=widgets.TextInput(attrs={'class': "form-control",
                                                          'placeholder': '标题5-20个字符'}))
 
 
    # 使用自定义验证规则
    phone = fields.CharField(validators=[mobile_validate, ],
                            error_messages={'required': '手机不能为空'},
                            widget=widgets.TextInput(attrs={'class': "form-control",
                                                          'placeholder': u'手机号码'}))
 
    email = fields.EmailField(required=False,
                            error_messages={'required': u'邮箱不能为空','invalid': u'邮箱格式错误'},
                            widget=widgets.TextInput(attrs={'class': "form-control", 'placeholder': u'邮箱'}))

View Code