V2AS问路
Django的Form表单验证
阅读原文时间：2023年07月09日阅读：3

Form（from django import forms）

简短理解：后端提供了一个类：from django import forms,继承此类定义子类。子类中定义和form表单中提交到name名称一样的字段。django就可以帮做验证。验证后返回三个信息：是否通过；所有正确信息；所有错误信息。

例如：

自己写前端html后端Form类进行验证

小试牛刀

views.py

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

class MyForm(Form):
user = fields.CharField(
widget=widgets.TextInput(attrs={'id': 'i1', 'class': 'c1'})
)

gender = fields.ChoiceField(  
    choices=((1, '男'), (2, '女'),),  
    initial=2,  
    widget=widgets.RadioSelect  
)

city = fields.CharField(  
    initial=2,  
    widget=widgets.Select(choices=((1,'上海'),(2,'北京'),))  
)

pwd = fields.CharField(  
    widget=widgets.PasswordInput(attrs={'class': 'c1'}, render\_value=True)  
)

views.py 函数处理

from django.shortcuts import render, redirect
from .forms import MyForm

def index(request):
if request.method == "GET":
obj = MyForm()
return render(request, 'index.html', {'form': obj})
elif request.method == "POST":
obj = MyForm(request.POST, request.FILES)
if obj.is_valid():
values = obj.clean()
print(values)
else:
errors = obj.errors
print(errors)
return render(request, 'index.html', {'form': obj})
else:
return redirect('http://www.google.com')

对应html

{{ form.user }} {{ form.user.errors }}

{{ form.gender }} {{ form.gender.errors }}

{{ form.city }} {{ form.city.errors }}

{{ form.pwd }} {{ form.pwd.errors }}

{% csrf\_token %} {{ form.xxoo.label }} {{ form.xxoo.id\_for\_label }} {{ form.xxoo.label\_tag }} {{ form.xxoo.errors }}

{{ form.user }} {{ form.user.errors }}

其它html标签

1、Django内置字段如下：

Field
required=True, 是否允许为空
widget=None, HTML插件
label=None, 用于生成Label标签或显示内容
initial=None, 初始值
help_text='', 帮助信息(在标签旁边显示)
error_messages=None, 错误信息 {'required': '不能为空', 'invalid': '格式错误'}
show_hidden_initial=False, 是否在当前插件后面再加一个隐藏的且具有默认值的插件（可用于检验两次输入是否一直）
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类型
…

注：UUID是根据MAC以及当前时间等创建的不重复的随机字符串

import uuid

# make a UUID based on the host ID and current time  
>>> uuid.uuid1()    # doctest: +SKIP  
UUID('a8098c1a-f86e-11da-bd1a-00112444be1e')

# make a UUID using an MD5 hash of a namespace UUID and a name  
>>> uuid.uuid3(uuid.NAMESPACE\_DNS, 'python.org')  
UUID('6fa459ea-ee8a-3ca4-894e-db77e160355e')

# make a random UUID  
>>> uuid.uuid4()    # doctest: +SKIP  
UUID('16fd2706-8baf-433b-82eb-8c7fada847da')

# make a UUID using a SHA-1 hash of a namespace UUID and a name  
>>> uuid.uuid5(uuid.NAMESPACE\_DNS, 'python.org')  
UUID('886313e1-3b8a-5372-9b90-0c9aee199e5d')

# make a UUID from a string of hex digits (braces and hyphens ignored)  
>>> x = uuid.UUID('{00010203-0405-0607-0809-0a0b0c0d0e0f}')

# convert a UUID to a string of hex digits in standard form  
>>> str(x)  
'00010203-0405-0607-0809-0a0b0c0d0e0f'

# get the raw 16 bytes of the UUID  
>>> x.bytes  
b'\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\t\\n\\x0b\\x0c\\r\\x0e\\x0f'

# make a UUID from a 16-byte string  
>>> uuid.UUID(bytes=x.bytes)  
UUID('00010203-0405-0607-0809-0a0b0c0d0e0f')

2、Django内置插件：

TextInput(Input)
NumberInput(TextInput)
EmailInput(TextInput)
URLInput(TextInput)
PasswordInput(TextInput)
HiddenInput(TextInput)
Textarea(Widget)
DateInput(DateTimeBaseInput)
DateTimeInput(DateTimeBaseInput)
TimeInput(DateTimeBaseInput)
CheckboxInput
Select
NullBooleanSelect
SelectMultiple
RadioSelect
CheckboxSelectMultiple
FileInput
ClearableFileInput
MultipleHiddenInput
SplitDateTimeWidget
SplitHiddenDateTimeWidget
SelectDateWidget

常用选择插件

# 单radio，值为字符串

user = fields.CharField(

initial=2,

widget=widgets.RadioSelect(choices=((1,'上海'),(2,'北京'),))

)

单radio，值为字符串

user = fields.ChoiceField(

choices=((1, '上海'), (2, '北京'),),

initial=2,

widget=widgets.RadioSelect

)

单select，值为字符串

user = fields.CharField(

initial=2,

widget=widgets.Select(choices=((1,'上海'),(2,'北京'),))

)

单select，值为字符串

user = fields.ChoiceField(

choices=((1, '上海'), (2, '北京'),),

initial=2,

widget=widgets.Select

)

多选select，值为列表

user = fields.MultipleChoiceField(

choices=((1,'上海'),(2,'北京'),),

initial=[1,],

widget=widgets.SelectMultiple

)

单checkbox

user = fields.CharField(

widget=widgets.CheckboxInput()

)

多选checkbox,值为列表

user = fields.MultipleChoiceField(

initial=[2, ],

choices=((1, '上海'), (2, '北京'),),

widget=widgets.CheckboxSelectMultiple

)

在使用选择标签时，需要注意choices的选项可以从数据库中获取，但是由于是静态字段 ***获取的值无法实时更新***，那么需要自定义构造方法从而达到此目的。

方式一：

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.ChoiceField(  
    # choices=((1, '上海'), (2, '北京'),),  
    initial=2,  
    widget=widgets.Select  
)

def \_\_init\_\_(self, \*args, \*\*kwargs):  
    super(MyForm,self).\_\_init\_\_(\*args, \*\*kwargs)  
    # self.fields\['user'\].widget.choices = ((1, '上海'), (2, '北京'),)  
    # 或  
    self.fields\['user'\].widget.choices = models.Classes.objects.all().value\_list('id','caption')

方式二：

使用django提供的ModelChoiceField和ModelMultipleChoiceField字段来实现

from django import forms
from django.forms import fields
from django.forms import widgets
from django.forms import models as form_model
from django.core.exceptions import ValidationError
from django.core.validators import RegexValidator

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

自定义验证规则

方式一：

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开头')],
)

方式二：

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

django2.1 Form验证大体流程：obj.is_vaild-->  self.is_bound-->  self.errors-->  self.full_clean-->  self._clean_fields-->  self._clean_form-->  slef._post_clean

"""
obj.is_vaild: 入口中self.is_bound代表数据不能为None和字段也是不能为None

self._errors: 默认是None,必执行self.full_clean（）方法-->self._errors = ErrorDict(),self.cleaned_data = {}，空字典赋值给错误信息

接着执行self._clean_fields() -->循环self.fields.items() 拿到字段名字和field正则匹配的规则，初步验证开始拿到用户提交的数据跟正则匹配，
----->重点环节（反射if hasattr(self, 'clean_%s' % name)，这里就可以根据定义的字段名字，我们可以开始自己定义这个函数自定义验证）如果没成功验证必须抛出ValidationError这个错（局部钩子）

接着执行self._clean_form() ---->self.clean()(返回self.cleaned_data)什么事都没干，这里又是一个钩子，我们自己定义可以对整个字段进行验证 ，否则报错抛出必须是ValidationError（全局钩子）

接着执行self._post_clean()----->直接pass了又是一个钩子，这里还可以再一次的进行验证，可以和self.clean()一样
"""

方法三：自定义方法clean_字段名 (验证后的钩子)

from django import forms
from django.forms import fields
from django.forms import widgets
from django.core.exceptions import ValidationError
from django.core.validators import RegexValidator

class FInfo(forms.Form):  
    username = fields.CharField(max\_length=5,  
                                validators=\[RegexValidator(r'^\[0-9\]+$', 'Enter a valid extension.', 'invalid')\], )  
    email = fields.EmailField()

    def clean\_username(self):  
        """  
        Form中字段中定义的格式匹配完之后，执行此方法进行验证  
        :return:  
        """  
        value = self.cleaned\_data\['username'\]  
        if "666" in value:  
            raise ValidationError('666已经被玩烂了...', 'invalid')  
        return value

方式四：同时生成多个标签进行验证

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

from django.core.validators import RegexValidator

############## 自定义字段 ##############
class PhoneField(fields.MultiValueField):
def __init__(self, *args, **kwargs):
# Define one message for all fields.
error_messages = {
'incomplete': 'Enter a country calling code and a phone number.',
}
# Or define a different message for each field.
f = (
fields.CharField(
error_messages={'incomplete': 'Enter a country calling code.'},
validators=[
RegexValidator(r'^[0-9]+$', 'Enter a valid country calling code.'),
],
),
fields.CharField(
error_messages={'incomplete': 'Enter a phone number.'},
validators=[RegexValidator(r'^[0-9]+$', 'Enter a valid phone number.')],
),
fields.CharField(
validators=[RegexValidator(r'^[0-9]+$', 'Enter a valid extension.')],
required=False,
),
)
super(PhoneField, self).__init__(error_messages=error_messages, fields=f, require_all_fields=False, *args,
**kwargs)

def compress(self, data\_list):  
    """  
    当用户验证都通过后，该值返回给用户  
    :param data\_list:  
    :return:  
    """  
    return data\_list

############## 自定义插件 ##############
class SplitPhoneWidget(widgets.MultiWidget):
def __init__(self):
ws = (
widgets.TextInput(),
widgets.TextInput(),
widgets.TextInput(),
)
super(SplitPhoneWidget, self).__init__(ws)

def decompress(self, value):  
    """  
    处理初始值，当初始值initial不是列表时，调用该方法  
    :param value:  
    :return:  
    """  
    if value:  
        return value.split(',')  
    return \[None, None, None\]

初始化数据

在Web应用程序中开发编写功能时，时常用到获取数据库中的数据并将值初始化在HTML中的标签上。

views.py

# Form

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()

city = fields.ChoiceField(  
    choices=((1, '上海'), (2, '北京'),),  
    widget=widgets.Select  
)

View

from django.shortcuts import render, redirect
from .forms import MyForm

def index(request):
if request.method == "GET":
values = {'user': 'root', 'city': 2}
obj = MyForm(values)

    return render(request, 'index.html', {'form': obj})  
elif request.method == "POST":  
    return redirect('http://www.google.com')  
else:  
    return redirect('http://www.google.com')

html

{% csrf\_token %}

{{ form.user }} {{ form.user.errors }}

{{ form.city }} {{ form.city.errors }}

verify_obj = MyFm(request.POST)

django中的Form一般有两种功能：

  • 生成html标签
  • 验证用户输入内容

Form 对象生成html标签写法

views.py

from django.shortcuts import render, HttpResponse
from django.views import View

Create your views here.

from django import forms

用来验证前端post提交过来数据的类

class MyFm(forms.Form):
username = forms.CharField()
pwd = forms.CharField()
email = forms.EmailField()

请求处理

class FormTest(View):
def get(self, request):
verify_obj = MyFm()
return render(request, 'fm.html', {'verify_obj':verify_obj})

fm.html

<form action="/formtest/" method="post">  
    {% csrf\_token %}  
    <p>{{ verify\_obj.username }} {{ verify\_obj.errors.username.0 }}</p>  
    <p>{{ verify\_obj.pwd }} {{ verify\_obj.errors.pwd.0 }}</p>  
    <p>{{ verify\_obj.email }} {{ verify\_obj.errors.email.0 }}</p>  
    <input type="submit" value="提交">  
</form>

django渲染后html

<form action="/formtest/" method="post">  
    <input type="hidden" name="csrfmiddlewaretoken" value="WhvU9JWIRIuk8Mjq0JJ1xCnId1ek6Rbee8kVgzyA0oHhUSIK3qZPu76opft70DPa">  
    <p><input type="text" name="username" required id="id\_username"> </p>  
    <p><input type="text" name="pwd" required id="id\_pwd"> </p>  
    <p><input type="email" name="email" required id="id\_email"> </p>  
    <input type="submit" value="提交">  
</form>

Form中 自定义中文错误提示信息

error_messages= {'错误类型':'中文提示字符串'}

views.py

# 用来验证前端post提交过来数据的类
class MyFm(forms.Form):
username = forms.CharField(error_messages={'required':'用户名不允许为空'})
pwd = forms.CharField(
max_length=16,
min_length=8,
error_messages={'required': '密码不能为空', 'min_length': '密码长度不能小于8', 'max_length': '密码长度不能大于16'}
)
email = forms.EmailField(error_messages={'required': '邮箱不能为空', 'invalid': '邮箱格式错误'})

# 请求处理
class FormTest(View):
def get(self, request):
verify_obj = MyFm()
return render(request, 'fm.html', {'verify_obj':verify_obj})
def post(self, request):
# 获取所有数据
# 每条数据请求的验证
# 成功显示正确信息
# 失败，给出错误提示
# 验证时将request.POST 传递给验证类，实例化验证对象
verify_obj = MyFm(request.POST)

    verify\_result = verify\_obj.is\_valid()               # 验证是否通过，返回True/False(所验证的字段内置了相关正则表达式，然后执行clean\_字段，clean(\_\_all\_\_),post\_clean)  
    post\_dict = verify\_obj.clean()                      # 将获取到到的key value 转换为字典 必须在执行is\_valid()以后调用  
    cleaned\_data = verify\_obj.cleaned\_data              # 将获取到到的符合要求的信息(也是字典) 必须在执行is\_valid()以后调用  
                                                        # 如果是注册，向数据库内写入时，直接传参给Modle \*\*cleaned\_data 即可  
    verify\_errors = verify\_obj.errors                   # 获取所有错误信息(html标签字符串) 示例：<ul class="errorlist"><li>email<ul class="errorlist"><li>Enter a valid email address.</li></ul></li></ul>  
    verify\_errors\_json = verify\_obj.errors.as\_json()    # 获取所有错误信息(html标签字符串) 示例：{"email": \[{"message": "Enter a valid email address.", "code": "invalid"}\]}  
    print(verify\_errors\_json)                           # code 表示错误类型，如无效、不许为空....message 表示对应code的提示字符串  
                                                        # code : invalid/required .....

    # return HttpResponse(verify\_result)  
    if not verify\_result:  
        return render(request, 'fm.html', {'verify\_obj': verify\_obj})

<form action="/formtest/" method="post">  
    {% csrf\_token %}

{# #}

{{ verify_obj.username }} {{ verify_obj.errors.username.0 }}


{{ verify_obj.pwd }} {{ verify_obj.errors.pwd.0 }}


{{ verify_obj.email }} {{ verify_obj.errors.email.0 }}



出错提示

html中也可以根据Form 对象自动生成table ul p 等html标签，直接将验证字段全部生成

    {{ verify\_obj.as\_p }}  
    {{ verify\_obj.as\_ul }}  
    <table>  
     {{ verify\_obj.as\_table }}  
    </table>

---------------------------------------------------------------------------------

原理：

Form表单本身(本例：class MyFm(forms.Form):)只做输入的值是否合法，

生成html标签是里面插件功能实现的。例如

forms.CharField(xxx…)的父类 Field中的父类里面有TextInput等方法生成

自定义生成表单字段的标签类型：widgets

from django import forms
from django.forms import widgets

用来验证前端post提交过来数据的类

class MyFm(forms.Form):
username = forms.CharField(
error_messages={'required':'用户名不允许为空'},
widget=widgets.Textarea(attrs={'class': 'form_username',
'placeholder': '用户名'})
)
pwd = forms.CharField(
max_length=16,
min_length=8,
error_messages={'required': '密码不能为空', 'min_length': '密码长度不能小于8', 'max_length': '密码长度不能大于16'},
widget=widgets.PasswordInput(attrs={})
)
email = forms.EmailField(error_messages={'required': '邮箱不能为空', 'invalid': '邮箱格式错误'})

自动更新字段设置

重写父类Form 构造方法，增加更新外键字段时，选项自动更新。

class UserInfoForm(forms.Form):
username = fields.CharField(max_length=32)
email = fields.EmailField()
user_type = fields.ChoiceField(
choices=models.UserType.objects.values_list('id', 'caption')
)

def \_\_init\_\_(self, \*args, \*\*kwargs):  
    super(UserInfoForm, self).\_\_init\_\_(\*args, \*\*kwargs)  
    self.fields\['user\_type'\].choices = models.UserType.objects.values\_list('id', 'caption')

当UserType里面的数据更新的时候，生成字段会自动更新

手机扫一扫

移动阅读更方便

阿里云服务器
腾讯云服务器
七牛云服务器

你可能感兴趣的文章

Python Django Web开发实战
Django系列---开发一
第四章：Django表单 - 3：Django表单字段汇总

4

13、form组件

5

《Python编程：从入门到实践》第19章笔记：用户/用户注册/身份验证

6

Django之Hook函数

7

Django 之 ModelForm

8

12月21日内容总结——forms组件渲染标签、展示信息、校验数据的一些补充，forms组件参数和源码剖析，modelform组件，Django中间件

9

第四章：Django表单 - 5：模型表单ModelForm

10

Django CSRF验证失败. 请求被中断.