Django组件之Form表单

我们之前在HTML页面中利用form表单向后端提交数据时，都会写一些获取用户输入的标签并且用form标签把它们包起来。与此同时我们在好多场景下都需要对用户的输入做校验，比如校验用户是否输入，输入的长度和格式等正不正确。如果用户输入的内容有错误就需要在页面上相应的位置显示对应的错误信息.。Django form组件就实现了上面所述的功能：
生成页面可用的HTML标签
对用户提交的数据进行校验
保留上次输入内容

1、views.py

2、regirest.html

数据库
class UserInfo(models.Model):
username = models.CharField(max_length=12)
password = models.CharField(max_length=20)1、views.py
1.先定义好一个RegForm类
from django import forms# 按照Django form组件的要求自己写一个类
class RegForm(forms.Form):
name = forms.CharField(max_length=12, label="用户名")
pwd = forms.CharField(min_length=6, max_length=18, label="密码")2.再写一个视图函数

2、regirest.html

3、分析
form的功能：
前端页面是使用Django模板语言和form类的对象生成的 -->生成HTML标签功能
当用户名和密码输入为空或输错form组件会默认为我们设置错误信息 -->用户提交校验功能
当用户输错之后仍保留着上次输入的内容在input框 -->保留上次输入内容简析后端：
form_obj = RegForm(request.POST) 把POST提交的数据存到RegForm进行实例化
form_obj.is_valid() 自动帮我们去校验form_obj接收到的数据
form_obj.cleaned_data 如果校验通过，会把信息存到cleaned_data，在后端cleaned_data其实是一个字典
取值：form_obj.cleaned_data['name']或者form_obj.cleaned_data.get('name')
form_obj.errors 如果校验不通过，会把错误信息存到errors，在后端errors其实是一个字典
取值：form_obj.errors['name']或者form_obj.errors.get('name')简析_HTML：
name字段
{{ form_obj.name }} 自动生成一个input框，属性就是我们在views.py里面设置的form类的属性
{{ form_obj.name.id_for_label }} 关联自动生成的input框
{{ form_obj.name.label }} form对象的name的label属性的值
{{ form_obj.name.errors.0 }} 错误信息pwd字段
{{ form_obj.pwd }}
{{ form_obj.pwd.id_for_label }}
{{ form_obj.pwd.label }}
{{ form_obj.pwd.errors.0 }} 也可以使用循环
{% for field in form_obj %}
{{ field }}
{{ field.id_for_label }}
{{ field.label }}
{{ field.errors.0 }}
{% endfor %}

创建Form类时，主要涉及到 【字段】 和 【插件】，字段用于对用户请求数据的验证，插件用于自动生成HTML;0、require
设置这个字段必须要填，默认也是True必填的class LoginForm(forms.Form):
username = forms.CharField(
min_length=8,
label="用户名",
required=False # 设置成不是必须要填
)
pwd = forms.CharField(min_length=6, label="密码")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
1.局部重写错误信息，哪个字段需要重写错误信息就在哪个字段设置class LoginForm(forms.Form):
username = forms.CharField(
min_length=8,
label="用户名",
initial="张三",
error_messages={
"required": "不能为空",
"invalid": "格式错误",
"min_length": "用户名最短8位"
}
)
pwd = forms.CharField(min_length=6, label="密码")2.设置全局错误信息(把默认的错误信息由英文改成中文)
在settings.py里面设置
# LANGUAGE_CODE = 'en-us'
LANGUAGE_CODE = 'zh-hans' # 把语言改成中文(汉字)# TIME_ZONE = 'UTC'
TIME_ZONE = 'Asia/Shanghai' # 时区改成亚洲上海3、widget
设置input框的type类型，默认类型是text，密码框的type应该设置为password
还可以设置input框的属性，比如class的样式class LoginForm(forms.Form):
...
pwd = forms.CharField(
min_length=6,
label="密码",
# 把密码框设置为password类型，并指定class为c1和c2的样式类
# 当出现出错时，其他类型的input框默认是保留你写的内容，只有密码框不会保存
# 想要密码框错误时也保留内容，就设置render_value=True
widget=forms.widgets.PasswordInput(attrs={'class': 'c1 c2'}, render_value=True)
)注意：在选择字段中
单选字段使用forms.fields.ChoiceField
也可以写成forms.ChoiceField
多选字段使用forms.fields.MultipleChoiceField4、radioSelect
单选框radio，值为字符串class LoginForm(forms.Form):
username = forms.CharField(
min_length=8,
label="用户名",
initial="张三",
error_messages={
"required": "不能为空",
"invalid": "格式错误",
"min_length": "用户名最短8位"
}
)
pwd = forms.CharField(min_length=6, label="密码")
gender = forms.fields.ChoiceField(
choices=((1, "男"), (2, "女"), (3, "保密")),
label="性别",
initial=3,
widget=forms.widgets.RadioSelect()
)5、单选Selectclass LoginForm(forms.Form):
...
hobby = forms.fields.ChoiceField(
choices=((1, "篮球"), (2, "足球"), (3, "双色球"), ),
label="爱好",
initial=3,
widget=forms.widgets.Select()
)6、多选Selectclass LoginForm(forms.Form):
...
hobby = forms.fields.MultipleChoiceField(
choices=((1, "篮球"), (2, "足球"), (3, "双色球"), ),
label="爱好",
initial=[1, 3],
widget=forms.widgets.SelectMultiple()
)7、单选checkboxclass LoginForm(forms.Form):
...
keep = forms.fields.ChoiceField(
label="是否记住密码",
initial="checked",
widget=forms.widgets.CheckboxInput()
)8、多选checkboxclass LoginForm(forms.Form):
...
hobby = forms.fields.MultipleChoiceField(
choices=((1, "篮球"), (2, "足球"), (3, "双色球"),),
label="爱好",
initial=[1, 3],
widget=forms.widgets.CheckboxSelectMultiple()
)

在使用选择标签时，需要注意choices的选项可以配置从数据库中获取，但是由于Form是懒加载模式的，获取的值无法实时更新，
就是说，你创建Form的时候从数据库加载到的值是什么，它就只显示那些值，即使数据库更新了，它也不会自动更新，如果需要实现实时更新，
需要重写构造方法从而实现choice实时更新。1、方式一
重写Form类的__init__，使其每次初始化都去查一次数据库
class RegForm(forms.Form):
hobby = forms.fields.MultipleChoiceField(
choices=Hobby.objects.all().values_list('id', 'name'),
label='爱好',
initial=[1, 3],
widget=forms.widgets.CheckboxSelectMultiple()
)
def __init__(self):
super(RegForm, self).__init__()
self.fields['hobby'].choices=Hobby.objects.all().values_list('id', 'name')2、方式二
使用From里面的models模块，这个模块是依赖于APP里面的models的(注意:两个models不是同一个)，得到的是一个个对象，
所有还要要操作APP里面的models，使其显示出具体的值
APP下的models.py
class Hobby(models.Model):
name = models.CharField(max_length=12) def __str__(self):
return self.nameviews.py
from django.forms import models as f_modelsclass RegForm(forms.Form):
hobby2 = f_models.ModelMultipleChoiceField(
queryset=Hobby.objects.all(),
label='第二爱好',
initial=[1, 2],
widget=forms.widgets.CheckboxSelectMultiple()
)

1、使用RegexValidator验证器(正则表达式)
from django.core.validators import RegexValidator # 导入使用正则表达的模块class RegForm(forms.Form): phone = forms.CharField(
label='手机号',
widget=forms.widgets.TextInput(attrs={'class': 'form-control'}),
validators=[RegexValidator(r'^1[3-9]\d{9}$', '手机号码不正确')]
)validators=一个可迭代对象
可迭代对象里面调用RegexValidator方法
RegexValidator方法有两个参数，一个是用于校验的正则表达式，另一个是匹配失败时的错误提示2、自定义校验规则
from django.core.exceptions import ValidationError# 专门屏蔽'JPM'的校验规则
def check_jpm(value):
# value就是用户输入的值
if 'JPM' in value:
raise ValidationError('包含敏感词汇')class RegForm(forms.Form):
name = forms.CharField(
min_length=2,
max_length=12,
label="用户名",
widget=forms.widgets.TextInput(),
validators=[check_jpm] # 直接调用自定义的函数
)3、使用RegexField字段
class RegForm(forms.Form):
phone = forms.RegexField(
label='手机号码',
regex=r'^1[3-9]\d{9}$',
widget=forms.widgets.TextInput(attrs={'class': 'form-control'})
)

1、介绍
局部钩子函数：
在Form类里面实现以clean_开头，字段结尾的函数，例如clean_name，
在实例化对象调用is_valid()方法进行校验的时候，会自动执行clean_方法。 局部钩子函数：在实例化对象的时候，数据已经存在cleaned_data里面了
但是局部钩子函数是循环每一个具体的字段(例如：name, pwd等)，所以在局部钩子函数只能取到它本身的值
如果抛出错误，则把错误信息添加进errors字典里面
如果没有抛出错误，则把这个字段对应的cleaned_data的值修改成return返回的值(一般直接返回原本的值，不做修改)全局钩子函数：
在Form类里面实现以clean函数，
在实例化对象调用is_valid()方法进行校验的时候，会自动执行clean方法。 全局钩子：可以取到cleaned_data所有的数据
如果没有抛出错误，把返回值直接赋值给cleaned_data这个变量
如果抛出错误，需要手动调用add_error()方法，明确指定给哪个字段增加错误信息
注意：局部钩子函数没有抛出错误是修改cleaned_data字典里面的某个值
而全局钩子没有抛出错误是直接修改cleaned_data这个变量，可以把cleaned_data改成列表、数字等
一般没有抛出错误就直接把原来的cleaned_data字典重新赋值给cleaned_data变量2、示例

1、可通过重写form类的init方法来实现。
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'
}) # 重写方式二：
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
# self.fields是一个大字典，key是字段名，value是字段对象
for field in self.fields.values():
field.widget.attrs.update({'class': 'form-control'})

1、register.html

2、models.py

3、Form组件单独写一个py文件
forms.py

4、views.py

1、介绍
我们在设计Form表单的时候，一般都会把字段名设置成和数据库(ORM)的字段名一模一样，因为这样设计的话，你后面设计的逻辑中，如果需要创建用户，
那么可以从表单的数据中提取出来，用关键字参数**kwargs直接创建，如果Form表单的字段和ORM的不一样，那么创建用户的时候就需要一个个指定，
比如username=name,password=pwd等。那么问题来了，Form表单的字段和ORM的字段一样，那么写Fomr表单的时候不就等于再写一次ORM的字段吗，有简单的方法吗？显然是有的，Django给我们考虑到了。用法是：
建Form表单类的时候继承ModelForm，在Meta类里面指定继承ORM的哪些字段，也可以新增你要的字段。2、示例
from django import forms
from crm.models import UserProfile # 导入UserProfile这张ORM表class RegForm(forms.ModelForm): # 继承ModelForm
# 新增的字段(UserProfile中并没有这个字段的)
re_password = forms.CharField(
label='确认密码',
widget=forms.widgets.PasswordInput()
) class Meta:
model = UserProfile # 表明使用UserProfile这张表作为模型
# fields = '__all__' # 展示UserProfile的所有字段
fields = ['email', 'password', 're_password', 'name', 'mobile'] # 按照顺序展示列表中的字段
# exclude = [''] # 把不需要的字段排查，其他字段展示出来
labels = {
'email': '邮箱'
} error_messages = {
'email': {
'max_length': '邮箱长度过长',
'unique': '邮箱不能为空'
}
} widgets = {
'password': forms.widgets.PasswordInput()
} # 重写init方法批量应用bootstrap样式
def __init__(self):
super().__init__()
# self.fields是一个大字典，key是字段名，value是字段对象
for field in self.fields.values():
field.widget.attrs.update({'class': 'form-control'})3、class Meta下的配置
1. model = 'ORM类名'2. 字段
1. fields = '__all__' # 展示ORM表的所有字段
2. fields = ['要展示的字段1', '字段2'] # 指定的字段显示出来，其他字段不显示
3. exclude = ['需要排除的字段1', ...] # 指定的字段不显示，其他字段都显示出来3. labels = {
'字段名1': 'label名1',
'字段名2': 'label名2',
}4. error_messages = {
'字段名': {
'min_length': '最小长度不能小于xx位',
'max_length': '最大长度不能超过xx位',
'required': '这个字段是必填项'
}
}5. widgets = {
'password': forms.widgets.PasswordInput()
}6.help_texts = None # 帮助提示信息7. 校验
1. 可以在model的字段中配置validators
2. 自己在Form类中重写字段，定义validators配置
3. 局部钩子方法和全局钩子方法 同Form的用法4、ModelForm中含有外键字段
创建ModelForm的时候，如果model中有含有外键字段，
那么这个外键字段在ModelForm默认是单选的select字段，label默认是model的verbose_name的值，如果没有则显示字段名，
或者可以在modelform的Meta里面通过labels设置，choices默认是这个外键关联的所有数据,HTML上的select标签的value默认这个外键关联的表对应的主键，
显示的文本默认是外键关联的表对应的对象。
注意：如果是多对多字段，则生成多选的select字段例如：
1.models.py
class ConsultRecord(models.Model):
customer = models.ForeignKey('Customer', verbose_name="所咨询客户")2.modelsform
class ConsultRecordForm(forms.ModelForm): class Meta:
model = ConsultRecord
fields = '__all__'上面的modelsform字段customer实际上等于下面这个普通的form
class ConsultRecordForm(forms.Form): customer = forms.fields.ChoiceField(
choices=Customer.objects.all().values_list('id', 'name'),
label="所咨询客户", # verbose_name
widget=forms.widgets.Select()
)5、save()方法
每个ModelForm还具有一个save()方法。 这个方法根据表单绑定的数据创建并保存数据库对象。
ModelForm的子类可以接受现有的模型实例作为关键字参数instance的值，如果提供instance参数，则save()将更新该实例。
如果没有提供，save()将创建模型的一个新实例。
注意：instance接收的是一个实例化对象，普通的Form并没有instance参数，且当modelform中含有多对多字段时，调用save方法后，
会自动帮你更新自己的表和多对多的第三张表，否则，你得自己手动更新自己的表，然后再通过多对多字段找到第三张表再次更新。1.没有提供参数instance，save()创建新的实例
def reg(request):
if request.method == 'POST':
form_obj = RegForm(request.POST)
# form_obj是一个ModelForm对象，它和数据库的Model类对应
form_obj.save() # 相当于UserProfile.objects.create(**form_obj.cleaned_data)
return redirect('/login/')2.提供参数instance，save()跟新这个实例
1.models.py
from django.db import models# Create your models here.class Publisher(models.Model):
name = models.CharField(max_length=12)
addr = models.CharField(max_length=255)2.forms.py
from django import forms
from myapp.models import Publisherclass PublisherForm(forms.ModelForm): class Meta:
model = Publisher
fields = '__all__'3.views.py
from django.shortcuts import render, redirect
from myapp.models import Publisher
from myapp.forms import PublisherForm
# Create your views here.def publisher_list(request):
data = Publisher.objects.all()
return render(request, 'publisher_list.html', {'publisher_list': data})def edit_publisher(request):
edit_id = request.GET.get('id')
publisher_obj = Publisher.objects.filter(id=edit_id).first()
# instance=某个对象：把这个对象的原始数据填到PublisherForm这个表单里面
form_obj = PublisherForm(instance=publisher_obj)
if request.method == 'POST':
# 把request.POST的数据更新到instance=这个对象里面
form_obj = PublisherForm(request.POST, instance=publisher_obj) # DRF框架的时候也会用到
if form_obj.is_valid():
# 去数据库编辑
# 方法一：
# new_name = form_obj.cleaned_data.get('name')
# new_addr = form_obj.cleaned_data.get('addr')
# publisher_obj.name = new_name
# publisher_obj.addr = new_addr
# publisher_obj.save() # 方法二：
form_obj.save()
return redirect('/publisher_list/')
return render(request, 'edit_publisher.html', {'form_obj': form_obj})

1.介绍
from django.forms import formset_factory
对于继承forms.Form的Form类，我们可以使用formset_factory。
注意：modelform类其实也继承了forms.Form的父类，因此modelform也可使用formset_factory2. 必填参数
1. form --> 继承了forms.form的form类3. 额外参数
extra：想要生成的空表单的数量
max_num：最多可以展示的表单数量
initial: 初始化formset的默认值(实例化formset时候的参数)
注意: max_num优先级高于extra，比如，我们想要显示5个空表单(extra=5)，但max_num=2，最后只会显示2个空表单4. 示例
FormSet = formset_factory(CourseForm) # 实例化一个formset_factory
formset_obj = FormSet(initial=[{}, {}...]) # formset_obj就可以跟form表单一样使用了5. 注意事项
1. 生成的FormSet在html页面中使用的时候，每一个form对象必须带上自己的form.id标识这是哪个对象的form，页面是会默认hidden这个参数(添加的时候不需要，编辑的时候需要)
2. 如果要提交这些form对象，则需要在html中的form表单为formset设置一个参数：{{ formset_obj.management_form }}，页面是会默认hidden这个参数
是告诉后端我这个formset有多少个小form
3. FormSet默认会给你多生成一个form对象，可以通过参数 extra 设置额外加多少个，0代表不额外加form对象
4. FormSet其实就是批量生成Form对象的操作，注意是Form对象
6. formset_factory和form一样，没有instance参数，所以也没有queryset参数
7. 其他操作和单个form操作是一样的，只是这个formset等于批量操作而已，一样有is_valid等(没有save，因为form是没有save的，modelform才有)
1. form表单
class CourseForm(forms.Form):
title = forms.CharField(max_length=32, label="课程名称")
score = forms.IntegerField(max_value=100, label="分数") 2. views.py
from django.forms import formset_factory def course(request):
FormSet = formset_factory(CourseForm, extra=1)
formset_obj = FormSet(initial=[{"title": "语文"}, {"title": "数学", "score": 59}])
if request.method == 'POST':
formset_obj = FormSet(request.POST)
if formset_obj.is_valid():
# 手动创建Course
objs = (Course(**item) for item in formset_obj.cleaned_data)
Course.objects.bulk_create(objs)
return redirect("/index/")
return render(request, "xx.html", {"formset_obj": formset_obj})
return render(request, 'xx.html', {'formset_obj': formset_obj}) 3.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
{% load my_filter%}
</head>
<body>
<form action="" method="post" novalidate>
{% csrf_token %}
{{ formset_obj.management_form }} <!--提交formset时必须要添加的参数-->
<div class="col-md-12">
<table class="table table-striped table-bordered">
<thead>
<tr>
<th>#</th>
<th>课程名称</th>
<th>分数</th>
</tr>
</thead>
<tbody>
{% for form_obj in formset_obj %}
<tr>
<!--每一个form对象必须带上自己的form.id标识这是哪个对象的form -->
{{ form_obj.id }}
<td>{{ forloop.counter }}</td>
<td>{{ form_obj.title }}</td>
<td>{{ form_obj.score }}</td>
</tr>
{% endfor %}
</tbody>
</table>
<button class="btn btn-success pull-right" type="submit">提交</button>
</div>
</form>
</body>
</html>

1. 介绍
from django.forms import modelformset_factory
对于继承forms.ModelForm的Form类，我们可以使用modelformset_factory2. 必填参数
1. model --> 数据库中的某个表
2. modelform --> 继承了forms.ModelForm的类3. 其他参数
extra：想要生成的空表单的数量
max_num：最多可以展示的表单数量
queryset:初始化modelformset(实例化modelformset时候的参数)4. 示例
# 生成一个formset类
FormSet = modelformset_factory(Book, BookForm, extra=0) # extra=0默认不给我生成额外的form对象
# 拿到所有书的实例(多个Book实例组成的query_set)
query_set = Book.objects.all()
# 从query_set中取出每一个Book实例生成form表单，存到formset里面
formset_obj = FormSet(queryset=query_set) # formset_obj是一个可迭代对象，里面是一个个小form5. 注意事项
1. 生成的FormSet在html页面中使用的时候，每一个modelform对象必须带上自己的modelform.id标识这是哪个对象的modelform，页面是会默认hidden这个参数(添加的时候不需要，编辑的时候需要)
2. 如果要提交这些modelform对象，则需要在html中的modelform表单为formset设置一个参数：{{ formset_obj.management_form }}，页面是会默认hidden这个参数
是告诉后端我这个modelformset有多少个小modelform
3. FormSet默认会给你多生成一个modelform对象，可以通过参数 extra 设置额外加多少个，0代表不额外加modelform对象
4. FormSet其实就是批量生成ModelForm对象的操作，注意是ModelForm对象
5. modelformset_factory实例设置默认值用queryset而不是instance，queryset相当于为每个modelform设置instance
6. 在html页面仍然可以使用具体的某个modelform对象的instance参数拿到传进来的对象，但是如果使用的不是自己的modelform对象的字段，提交数据时并不生效
7. 其他操作和单个modelform操作是一样的，只是这个modelformset等于批量操作而已，一样有is_valid,save等
8. 示例
1. modelform
class BookForm(forms.ModelForm): class Meta:
model = Book
fields = ["title", "price", "publisher"] 2. views.py
from django.forms import modelformset_factory def book(request):
# 生成一个formset类
FormSet = modelformset_factory(Book, BookForm, extra=0) # extra=0默认不给我生成额外的form对象
# 拿到所有书的实例(多个Book实例组成的query_set)
query_set = Book.objects.all()
# 从query_set中取出每一个Book实例生成form表单，存到formset里面
formset_obj = FormSet(queryset=query_set) # formset_obj是一个可迭代对象，里面是一个个小form
# 上面的代码相当于：
# form_obj1 = BookForm(instance=query_set[0])
# form_obj2 = BookForm(instance=query_set[1]) ...
# 然后把这些form_obj存到formset_obj里面
if request.method == 'POST':
formset_obj = FormSet(request.POST, queryset=query_set)
if formset_obj.is_valid():
# formset_obj.save()
return redirect('/index/')
return render(request, 'tem1.html', {'formset_obj': formset_obj})
return render(request, 'tem1.html', {'formset_obj': formset_obj}) 3. html代码
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
{% load my_filter%}
</head>
<body>
<form action="" method="post" novalidate>
{% csrf_token %}
{{ formset_obj.management_form }} <!--提交formset时必须要添加的参数-->
<div class="col-md-12">
<table class="table table-striped table-bordered">
<thead>
<tr>
<th>#</th>
<th>书名</th>
<th>价格</th>
<th>出版社</th>
</tr>
</thead>
<tbody>
{% for form_obj in formset_obj %}
<tr>
<!--每一个form对象必须带上自己的form.id标识这是哪个对象的form -->
{{ form_obj.id }}
<td>{{ forloop.counter }}</td>
<td>{{ form_obj.title }}</td>
<td>{{ form_obj.price }}</td>
<td>{{ form_obj.publisher }}</td>
</tr>
{% endfor %}
</tbody>
</table>
<button class="btn btn-success pull-right" type="submit">提交</button>
</div>
</form>
</body>
</html>