Django Form组件

Form介绍

我们在HTML页面中利用form表单向后端提交数据时，都会写一些获取用户输入的标签并且用form标签把它们包起来。

与此同时我们在好多场景下都需要对用户的输入做校验，比如校验用户是否输入，输入的长度和格式等正确与否。如果用户输入的内容有错误就需要在页面上相应的位置显示对应的错误信息.。

Django form组件就实现了上面所述的功能。

总结一下，其实form组件的主要功能如下:

渲染标签
对用户提交的数据进行校验
保留上次输入内容

普通方式手写注册功能

思路：

　　1.手写获取用户输入的前端页面代码渲染页面
　　2.后端获取用户数据并做合法性校验校验数据
　　3.将校验之后的结果渲染到前端页面展示信息

views.py

def register(request):
error_dict = {'username':'','password':''}
if request.method =='POST':
username = request.POST.get("username")
password = request.POST.get('password')
if "Jin瓶梅" in username:
#提示报错信息
error_dict['username'] = '不符合核心价值观'
if not password:
#提示报错信息
error_dict['password'] = '密码不能为空'
return render(request,'register.html',locals())

views.py

<body>
<form action="" method="post">
<p>用户名：
<input type="text" name="username">
<span style="color:red">{{ error_dict.username }}</span>
</p>

<p>密码：
<input type="text" name="password">
<span style="color:red">{{ error_dict.password }}</span>
</p>
<input type="submit">
</form>
</body>

使用form组件实现注册功能

views.py

#需要先写一个类
class MyRegForm(forms.Form):
    #用户名最少3位最多8位
    username = forms.CharField(max_length=8,min_length=3)
    password = forms.CharField(max_length=8,min_length=3)
    #email字段必须填写符合邮箱格式的数据
    email = forms.EmailField()

如何校验数据：

# 1.传入待校验的数据  用自己写的类 传入字典格式的待校验的数据
form_obj = views.MyRegForm({'username': 'hank', 'password': 123, 'email': '123456'})
# 2.判断数据是否符合校验规则
form_obj.is_valid() #False 该方法只有在所有的数据全部符合校验规则才会返回True
# 3.如何获取校验之后通过的数据
form_obj.cleaned_data  #{'username': 'hank', 'password': '123'}
# 4.如何获取校验失败及失败的原因
form_obj.errors  #{'email': ['Enter a valid email address.']}

注意：forms组件默认所有的字段都必须传值。

传少了肯定不行，而传多了则没有任何关系，只校验类里面写的字段多传的直接忽略了。如下图所示

如何渲染标签

forms组件只帮你渲染获取用户输入(输入选择下拉文件)的标签不渲染按钮和form表单标签
渲染出来的每一个input提示信息都是类中字段首字母大写

views.py

def reg(request):
# 1.先生成一个空的类对象
form_obj = MyRegForm()
# 2 获取用户数据并交给forms组件校验
if request.method == 'POST':
form_obj = MyRegForm(request.POST)
# 3 获取校验结果
if form_obj.is_valid():
return HttpResponse('数据没问题')
# return render(request, 'reg.html', locals())
else:
# 4 获取校验失败的字段和提示信息
print(form_obj.errors)

# 5.直接将该对象传给前端页面
return render(request,'reg.html',locals())

views.py

reg.html

<body>
<p>第一种渲染方式: 多个p标签本地测试方便封装程度太高不便于扩展</p>
{{ form_obj.as_p }}
{#{{ form_obj.as_ul }}#}
{#{{ form_obj.as_table }}#}

<p>第二种渲染方式: 扩展性较高书写较为繁琐</p>
<lable for="{{ form_obj.username.id_for_label }}">{{ form_obj.username.label }}</lable>
{{ form_obj.username }}
{{ form_obj.password.label }}{{ form_obj.password }}
{{ form_obj.email.label }}{{ form_obj.email }}

<p>第三种渲染方式（推荐使用）</p>
{% for form in form_obj %}
{{ form.label }}{{ form }}
{% endfor %}

</body>

reg.html

效果展示：

如何渲染错误信息

views.py

# 5.直接将该对象传给前端页面
return render(request,'reg.html',locals())

views.py

reg.html

<p>第三种渲染方式（推荐使用）</p>
<form action="" method="post" novalidate>
{% for form in form_obj %}
<p>
{{ form.label }}{{ form }}
<span>{{ form_obj.errors.0 }}</span>
</p>
{% endfor %}
<input type="submit">
</form>

reg.html

注意：

1.数据校验一个前后端都得有，但是前端的校验弱不禁风可有可无；而后端的校验则必须非常全面
2.form表单取消前端浏览器自动校验功能：

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

常见参数

创建Form类时，主要涉及到【字段】和【插件】，字段用于对用户请求数据的验证，插件用于自动生成HTML;

label    #input框的提示信息
error_messages    #自定义报错的提示信息
required     #设置字段是否允许为空
initial    #设置默认值
widget    #控制类型及属性 type/class 
    widget=forms.widgets.TextInput(attrs={'class':'form-control c1'}）
    widget=forms.widgets.PasswordInput(attrs={'class':'form-control'})

正则校验：

from django.core.validators import RegexValidator

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

单选Select：

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

多选Select：

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

单选Checkbox

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

多选Checkbox

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

补充：

Django Form所有内置字段

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所有内置字段

钩子函数

我们在Fom类中定义 clean_字段名() 方法，就能够实现对特定字段进行校验。

我们在Fom类中定义 clean() 方法，就能够实现对字段进行全局校验。

views.py

class MyRegForm(forms.Form):
#用户名最少3位最多8位
username = forms.CharField(max_length=8,min_length=3,label='用户名',
error_messages={
'max_length':'用户名最长8位',
'min_length':'用户名最短3位',
'required':'用户名不能位为空'
},
initial='hank')
password = forms.CharField(max_length=8,min_length=3,label='密码')
confirm_password = forms.CharField(max_length=8,min_length=3,label='确认密码')
#email字段必须填写符合邮箱格式的数据
email = forms.EmailField(label='邮箱',error_messages={
'required':'邮箱必填',
'invalid':'邮箱格式不正确'
})

# 全局钩子
def clean(self):
#校验密码和确认密码是否一致
password = self.cleaned_data.get('password')
confirm_password = self.cleaned_data.get('confirm_password')
if not password == confirm_password:
#展示错误提示信息
self.add_error('confirm_password','两次密码不一致')
return self.cleaned_data

# 局部钩子
def clean_username(self):
#校验用户名中不能包含666
username =self.cleaned_data.get('username')
if '666' in username:
self.add_error('username','有666是就行的')
return self.cleaned_data

views.py

如果想同时操作多个字段的数据，就用全局钩子
如果想操作单个字段的数据，就用局部钩子

## form组件

1 生成页面HTML标签

2 校验用户提交的数据合法性

3 保留用户输入的数据



### 生成标签

~~~

from django import forms #forms 里有fields，widgets，models等属性
from django.core.exceptions import ValidationError
from django.core validators import RegexValidator

def mobile_validate(value):  value是要被校验的数据
    mobile_re = re.compile(r'^13[0-9]{9}')
    if not mobile_re.match(value):
        raise ValidationError('手机号码格式错误')  #别忘了raise错误


class MyForm(forms.Form):
     name = forms.CharField(
        required=True,  #默认等于True，内容不能为空
        min_length=6,   #最小长度为6
        label='用户名',  #标识
        initial='高杰DSB', #初始值，默认值
        # validators=[RegexValidator(r'^jin瓶梅','没看过jin瓶梅，不能通过'),RegexValidator(r'红旭妹妹$','没看过红旭妹妹，不能通过'),], #写自定义校验规则，RegexValidator（正则，错误信息）
        # validators=[mobile_validate,], #写自定义校验规则
        help_text='这是输入用户名的地方，不能太短！',
        error_messages={'required':'不能为空！','min_length':'太短了！'},
        # widget=forms.widgets.TextInput(attrs={'class':'form-control'}),
        widget=forms.widgets.TextInput(),           #插件
    )
    password = forms.CharField(
        min_length=8,
        max_length=10,  #最大长度不能超过10位
        label='密码',
        widget=forms.widgets.PasswordInput(), #密文输入
    )
    
radio单选框：
     sex = forms.ChoiceField(
        label='性别',
        initial=3, #初始值
        choices=((1, "男"), (2, "女"), (3, "保密")), #
        widget=forms.widgets.RadioSelect(),

    )
select下拉单选框
    city = forms.ChoiceField(
        label='性别',
        initial=3,
        choices=((1, "北京"), (2, "上海"), (3, "东莞")),
        widget=forms.widgets.Select(),

    )

checkbox多选框
    hobby = forms.MultipleChoiceField(
        label='爱好',

        choices=((1, "抽烟"), (2, "喝酒"), (3, "烫头")),
        widget=forms.widgets.CheckboxSelectMultiple(),

    )
    
select下拉多选框
    girls = forms.MultipleChoiceField(
        label='爱好',

        choices=((1, "红旭妹妹"), (2, "相玺哥哥"), (3, "程根姐姐")),
        widget=forms.widgets.SelectMultiple(),

    )

单选checkbox
    status = forms.ChoiceField(
        label='remeber me!!',

        choices=(('True', "红旭妹妹"), ('False', "相玺哥哥")),
        widget=forms.widgets.CheckboxInput(),

    )

#给标签加属性
widget=forms.widgets.TextInput(attrs={'class':'c1','type':'date'}),
    
见代码
~~~

### 校验内容

~~~

def register(request):
    form_obj = LoginForm()
    if request.method == 'GET':
        return render(request,'register.html',{'form_obj':form_obj})
    
    else:
        # request.POST = name:'asdfasdf'
            form_obj = LoginForm(request.POST) {‘name’:}
            print(form_obj.fields) #拿到所有的form类中的字段
            print(form_obj.is_valid())
            if form_obj.is_valid(): #校验数据 ，全部通过校验，返回True，但凡有一个不对的，就返回False
                print(form_obj.cleaned_data)  #{'name': '13812312312', 'password': '11111111'}
                return HttpResponse('登录成功')
            else:

                print('xxxxxx')
                print(form_obj.errors)
                return render(request,'register.html',{'form_obj':form_obj})


~~~

html文件写法

~~~

{% load static %}
<!DOCTYPE html>
<html lang="zh-CN">
<head>
  <meta charset="utf-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <!-- 上述3个meta标签*必须*放在最前面，任何其他内容都*必须*跟随其后！ -->
  <title>Bootstrap 101 Template</title>
  <!-- Bootstrap -->
  <link href="{% static 'bootstrap-3.3.7-dist/css/bootstrap.min.css' %}" rel="stylesheet">
</head>
<body>
<h1>你好，世界！</h1>

<form action="" method="post" novalidate>
  {% csrf_token %}
{#  {{ form_obj.errors }}#}
{#  用户名： <input type="text" name="username"> #}
{#  密码： <input type="text" name="password"> #}
  <div>
    <label for="">{{ form_obj.name.label }}</label>
    {{ form_obj.name }}
    {{ form_obj.name.help_text }}
{#    {{ form_obj.errors }}#}
    <span style="color: red;font-size: 14px;">{{ form_obj.name.errors.0 }}</span>
  </div>
  <div>
    <label for="">{{ form_obj.password.label }}</label>
    {{ form_obj.password }}
    {{ form_obj.password.errors.0 }}
{#    {{ form_obj.errors }}#}
  </div>
  <div>
    <label for="">{{ form_obj.r_password.label }}</label>
    {{ form_obj.r_password }}
    {{ form_obj.r_password.errors.0 }}
{#    {{ form_obj.errors }}#}
  </div>
{#  <div>#}
{#    <label for="">{{ form_obj.password.label }}</label>#}
{#    {{ form_obj.password }}#}
{#  </div>#}
{#  <div>#}
{#    <label for="">{{ form_obj.sex.label }}</label>#}
{#    {{ form_obj.sex }}#}
{#  </div>#}
{#  <div>#}
{#    <label for="">{{ form_obj.city.label }}</label>#}
{#    {{ form_obj.city }}#}
{#  </div>#}
{#  <div>#}
{#    <label for="">{{ form_obj.hobby.label }}</label>#}
{#    {{ form_obj.hobby }}#}
{#  </div>#}
{#  <div>#}
{#    <label for="">{{ form_obj.girls.label }}</label>#}
{#    {{ form_obj.girls }}#}
{#  </div>#}
{#  <div>#}
{#    <label for="">{{ form_obj.status.label }}</label>#}
{#    {{ form_obj.status }}#}
{#  </div>#}

  <div>
    <label for="">{{ form_obj.brithday.label }}</label>
    {{ form_obj.brithday }}
  </div>

{#  {{ form_obj.as_p }}#}

  <input type="submit">
</form>


</body>
</html>

~~~



### 局部钩子和全局钩子

~~~
在定义的form类中写下面的方法：
#局部钩子  clean_字段名称 ，
    def clean_name(self):
        value = self.cleaned_data['name']
        if '大壮' in value:
            raise ValidationError('含有敏感词汇：大壮')
        else:
            return value



    #全局钩子
    def clean(self):
        value = self.cleaned_data
        p1 = value['password']
        p2 = value['r_password']
        if p1 == p2:
            return value
        else:
            # raise ValidationError('两次输入的密码不一致！')
            self.add_error('r_password','两次输入的密码不一致！') #给某个字段单独添加报错信息
            raise ValidationError('两次输入的密码不一致！')


循环所有字段进行验证，首先完成该字段实例化的时候的属性验证min_length=6，例如：Charfield（min_length=6）,然后通过反射执行该字段的局部钩子，然后进行下一次循环，完成该字段实例化的时候的属性验证min_length=6，例如：Charfield（min_length=6）,然后通过反射执行该字段的局部钩子，循环结束，self.clean_data里面有各个字段的数据，然后执行全局钩子


~~~

在使用选择标签时，需要注意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')
方式二：
'''forms.models.ModelChoiceField'''

使用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())zidi
自定义验证规则

方法二的补充：

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

 
class FInfo(forms.Form):　　
    authors = forms.ModelMultipleChoiceField(queryset=models.NNewType.objects.all())  # 多选    #或者下面这种方式，通过forms里面的models中提供的方法也是一样的。
    authors = form_model.ModelMultipleChoiceField(queryset=models.NNewType.objects.all())  # 多选
    #authors = form_model.ModelChoiceField(queryset=models.NNewType.objects.all())  # 单选    #或者，forms.ModelChoiceField(queryset=models.Publisth.objects.all(),widget=forms.widgets.Select()) 单选    #
   authors = forms.ModelMultipleChoiceField(    queryset=models.Author.objects.all(),    widget = forms.widgets.Select(attrs={'class': 'form-control'}   ))
   #如果用这种方式，别忘了model表中，NNEWType的__str__方法要写上，不然选择框里面是一个个的object对象

类forms.ModelForm forms.ModelChoiceField()/forms.models.ModelChoiceField()

modelform 通过model的属性自动翻译成form的属性，来进行form组件的工作

~~~
from django.core.exceptions import ValidationError
class BookModelForm(forms.ModelForm):
    # title=forms.CharField(max_length=15,min_length=6) form里的校验规则是自己写的
                                        #model form里面是根据model里生成的，改写的话如上
                                                title所示
    
    class Meta:
        model = models.Book
        # fields=['title','publishs',]
        fields='__all__'
        # exclude = ['title','xx',]

        labels = {
            'title':'书名',
            'publishDate':'出版日期',
        }
        widgets = {
            'publishDate':forms.widgets.TextInput(attrs={'type':'date'}),
        }
        error_messages = {
            'title':{'required':'不能为空',},
            'publishDate':{'required':'不能为空',}
        }
        #钩子
    # def clean_title(self):
    #     value = self.cleaned_data.get('title')
    #     if '666' in value:
    #         raise ValidationError('光喊6是不行的！！')
    #     else:
    #         return value
    # def clean(self):
    #     ...
    #批量添加标签样式
    def __init__(self,*args,**kwargs):
        super().__init__(*args,**kwargs)
        for field in self.fields.values():
            field.widget.attrs.update({'class':'form-control'})


~~~
instance=book_obj---update

前端模板 github adminLTE   图表：百度echart    图标 fontawesome/阿里的icon