06-03 form组件 - 图1

Form介绍

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

  • 生成页面可用的HTML标签
  • 对用户提交的数据进行校验
  • 保留上次输入内容

    普通方式手写注册功能

    views.py

    1. # 注册
    2. def register(request):
    3.   error_msg = ""
    4.   if request.method == "POST":
    5.       username = request.POST.get("name")
    6.       pwd = request.POST.get("pwd")
    7.       # 对注册信息做校验
    8.       if len(username) < 6:
    9.           # 用户长度小于6位
    10.           error_msg = "用户名长度不能小于6位"
    11.       else:
    12.           # 将用户名和密码存到数据库
    13.           return HttpResponse("注册成功")
    14.   return render(request, "register.html", {"error_msg": error_msg})

    login.html

    1. <!DOCTYPE html>
    2. <html lang="en">
    3. <head>
    4.   <meta charset="UTF-8">
    5.   <title>注册页面</title>
    6. </head>
    7. <body>
    8. <form action="/reg/" method="post">
    9.   {% csrf_token %}
    10.   <p>
    11.       用户名:
    12.       <input type="text" name="name">
    13.   </p>
    14.   <p>
    15.       密码：
    16.       <input type="password" name="pwd">
    17.   </p>
    18.   <p>
    19.       <input type="submit" value="注册">
    20.       <p style="color: red">{{ error_msg }}</p>
    21.   </p>
    22. </form>
    23. </body>
    24. </html>

    使用form组件实现注册功能

    views.py

    先定义好一个RegForm类： ```python from django import forms

按照Django form组件的要求自己写一个类

class RegForm(forms.Form): name = forms.CharField(label=”用户名”) pwd = forms.CharField(label=”密码”)

  1. 再写一个视图函数：
  2. ```python
  3. # 使用form组件实现注册方式
  4. def register2(request):
  5.     form_obj = RegForm()
  6.     if request.method == "POST":
  7.         # 实例化form对象的时候，把post提交过来的数据直接传进去
  8.         form_obj = RegForm(request.POST)
  9.         # 调用form_obj校验数据的方法
  10.         if form_obj.is_valid():
  11.             return HttpResponse("注册成功")
  12.     return render(request, "register2.html", {"form_obj": form_obj})

login2.html

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>注册2</title>
  6. </head>
  7. <body>
  8.     <form action="/reg2/" method="post" novalidate autocomplete="off">
  9.         {% csrf_token %}
  10.         <div>
  11.             <label for="{{ form_obj.name.id_for_label }}">{{ form_obj.name.label }}</label>
  12.             {{ form_obj.name }} {{ form_obj.name.errors.0 }}
  13.         </div>
  14.         <div>
  15.             <label for="{{ form_obj.pwd.id_for_label }}">{{ form_obj.pwd.label }}</label>
  16.             {{ form_obj.pwd }} {{ form_obj.pwd.errors.0 }}
  17.         </div>
  18.         <div>
  19.             <input type="submit" class="btn btn-success" value="注册">
  20.         </div>
  21.     </form>
  22. </body>
  23. </html>

看网页效果发现 也验证了form的功能：
• 前端页面是form类的对象生成的 —>生成HTML标签功能
• 当用户名和密码输入为空或输错之后 页面都会提示 —>用户提交校验功能
• 当用户输错之后 再次输入 上次的内容还保留在input框 —>保留上次输入内容

Form那些事儿

常用字段与插件

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

initial

初始值，input框里面的初始值。

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

error_messages

重写错误信息。

  1. class LoginForm(forms.Form):
  2.     username = forms.CharField(
  3.         min_length=8,
  4.         label="用户名",
  5.         initial="张三",
  6.         error_messages={
  7.             "required": "不能为空",
  8.             "invalid": "格式错误",
  9.             "min_length": "用户名最短8位"
  10.         }
  11.     )
  12.     pwd = forms.CharField(min_length=6, label="密码")

password

  1. class LoginForm(forms.Form):
  2.     ...
  3.     pwd = forms.CharField(
  4.         min_length=6,
  5.         label="密码",
  6.         widget=forms.widgets.PasswordInput(attrs={'class': 'c1'}, render_value=True)
  7.     )

radioSelect

单radio值为字符串

  1. class LoginForm(forms.Form):
  2.     username = forms.CharField(
  3.         min_length=8,
  4.         label="用户名",
  5.         initial="张三",
  6.         error_messages={
  7.             "required": "不能为空",
  8.             "invalid": "格式错误",
  9.             "min_length": "用户名最短8位"
  10.         }
  11.     )
  12.     pwd = forms.CharField(min_length=6, label="密码")
  13.     gender = forms.fields.ChoiceField(
  14.         choices=((1, "男"), (2, "女"), (3, "保密")),
  15.         label="性别",
  16.         initial=3,
  17.         widget=forms.widgets.RadioSelect()
  18.     )

单选Select

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

多选Select

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

单选checkbox

  1. class LoginForm(forms.Form):
  2.     ...
  3.     keep = forms.ChoiceField(
  4.         label="是否记住密码",
  5.         initial="checked",
  6.         widget=forms.widgets.CheckboxInput()
  7.     )

多选checkbox

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

choice字段注意事项

在使用选择标签时，需要注意choices的选项可以配置从数据库中获取，但是由于是静态字段 获取的值无法实时更新，需要重写构造方法从而实现choice实时更新。
方式一：

  1. from django.forms import Form
  2. from django.forms import widgets
  3. from django.forms import fields
  6. class MyForm(Form):
  8.     user = fields.ChoiceField(
  9.         # choices=((1, '上海'), (2, '北京'),),
  10.         initial=2,
  11.         widget=widgets.Select
  12.     )
  14.     def __init__(self, *args, **kwargs):
  15.         super(MyForm,self).__init__(*args, **kwargs)
  16.         # self.fields['user'].choices = ((1, '上海'), (2, '北京'),)
  17.         # 或
  18.         self.fields['user'].choices = models.Classes.objects.all().values_list('id','caption')

方式二：

  1. from django import forms
  2. from django.forms import fields
  3. from django.forms import models as form_model
  6. class FInfo(forms.Form):
  7.     authors = form_model.ModelMultipleChoiceField(queryset=models.NNewType.objects.all())  # 多选
  8.     # authors = form_model.ModelChoiceField(queryset=models.NNewType.objects.all())  # 单选

Django Form所有内置字段

  1. Field
  2.     required=True,               是否允许为空
  3.     widget=None,                 HTML插件
  4.     label=None,                  用于生成Label标签或显示内容
  5.     initial=None,                初始值
  6.     help_text='',                帮助信息(在标签旁边显示)
  7.     error_messages=None,         错误信息 {'required': '不能为空', 'invalid': '格式错误'}
  8.     validators=[],               自定义验证规则
  9.     localize=False,              是否支持本地化
  10.     disabled=False,              是否可以编辑
  11.     label_suffix=None            Label内容后缀
  14. CharField(Field)
  15.     max_length=None,             最大长度
  16.     min_length=None,             最小长度
  17.     strip=True                   是否移除用户输入空白
  19. IntegerField(Field)
  20.     max_value=None,              最大值
  21.     min_value=None,              最小值
  23. FloatField(IntegerField)
  24.     ...
  26. DecimalField(IntegerField)
  27.     max_value=None,              最大值
  28.     min_value=None,              最小值
  29.     max_digits=None,             总长度
  30.     decimal_places=None,         小数位长度
  32. BaseTemporalField(Field)
  33.     input_formats=None          时间格式化   
  35. DateField(BaseTemporalField)    格式：2015-09-01
  36. TimeField(BaseTemporalField)    格式：11:12
  37. DateTimeField(BaseTemporalField)格式：2015-09-01 11:12
  39. DurationField(Field)            时间间隔：%d %H:%M:%S.%f
  40.     ...
  42. RegexField(CharField)
  43.     regex,                      自定制正则表达式
  44.     max_length=None,            最大长度
  45.     min_length=None,            最小长度
  46.     error_message=None,         忽略，错误信息使用 error_messages={'invalid': '...'}
  48. EmailField(CharField)      
  49.     ...
  51. FileField(Field)
  52.     allow_empty_file=False     是否允许空文件
  54. ImageField(FileField)      
  55.     ...
  56.     注：需要PIL模块，pip3 install Pillow
  57.     以上两个字典使用时，需要注意两点：
  58.         - form表单中 enctype="multipart/form-data"
  59.         - view函数中 obj = MyForm(request.POST, request.FILES)
  61. URLField(Field)
  62.     ...
  65. BooleanField(Field)  
  66.     ...
  68. NullBooleanField(BooleanField)
  69.     ...
  71. ChoiceField(Field)
  72.     ...
  73.     choices=(),                选项，如：choices = ((0,'上海'),(1,'北京'),)
  74.     required=True,             是否必填
  75.     widget=None,               插件，默认select插件
  76.     label=None,                Label内容
  77.     initial=None,              初始值
  78.     help_text='',              帮助提示
  81. ModelChoiceField(ChoiceField)
  82.     ...                        django.forms.models.ModelChoiceField
  83.     queryset,                  # 查询数据库中的数据
  84.     empty_label="---------",   # 默认空显示内容
  85.     to_field_name=None,        # HTML中value的值对应的字段
  86.     limit_choices_to=None      # ModelForm中对queryset二次筛选
  88. ModelMultipleChoiceField(ModelChoiceField)
  89.     ...                        django.forms.models.ModelMultipleChoiceField
  93. TypedChoiceField(ChoiceField)
  94.     coerce = lambda val: val   对选中的值进行一次转换
  95.     empty_value= ''            空值的默认值
  97. MultipleChoiceField(ChoiceField)
  98.     ...
  100. TypedMultipleChoiceField(MultipleChoiceField)
  101.     coerce = lambda val: val   对选中的每一个值进行一次转换
  102.     empty_value= ''            空值的默认值
  104. ComboField(Field)
  105.     fields=()                  使用多个验证，如下：即验证最大长度20，又验证邮箱格式
  106.                                fields.ComboField(fields=[fields.CharField(max_length=20), fields.EmailField(),])
  108. MultiValueField(Field)
  109.     PS: 抽象类，子类中可以实现聚合多个字典去匹配一个值，要配合MultiWidget使用
  111. SplitDateTimeField(MultiValueField)
  112.     input_date_formats=None,   格式列表：['%Y--%m--%d', '%m%d/%Y', '%m/%d/%y']
  113.     input_time_formats=None    格式列表：['%H:%M:%S', '%H:%M:%S.%f', '%H:%M']
  115. FilePathField(ChoiceField)     文件选项，目录下文件显示在页面中
  116.     path,                      文件夹路径
  117.     match=None,                正则匹配
  118.     recursive=False,           递归下面的文件夹
  119.     allow_files=True,          允许文件
  120.     allow_folders=False,       允许文件夹
  121.     required=True,
  122.     widget=None,
  123.     label=None,
  124.     initial=None,
  125.     help_text=''
  127. GenericIPAddressField
  128.     protocol='both',           both,ipv4,ipv6支持的IP格式
  129.     unpack_ipv4=False          解析ipv4地址，如果是::ffff:192.0.2.1时候，可解析为192.0.2.1， PS：protocol必须为both才能启用
  131. SlugField(CharField)           数字，字母，下划线，减号（连字符）
  132.     ...
  134. UUIDField(CharField)           uuid类型

字段校验

RegexValidator验证器

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

自定义验证函数

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

Hook方法

除了上面两种方式，我们还可以在Form类中定义钩子函数，来实现自定义的验证功能。

局部钩子

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

  1. class LoginForm(forms.Form):
  2.     username = forms.CharField(
  3.         min_length=8,
  4.         label="用户名",
  5.         initial="张三",
  6.         error_messages={
  7.             "required": "不能为空",
  8.             "invalid": "格式错误",
  9.             "min_length": "用户名最短8位"
  10.         },
  11.         widget=forms.widgets.TextInput(attrs={"class": "form-control"})
  12.     )
  13.     ...
  14.     # 定义局部钩子，用来校验username字段
  15.     def clean_username(self):
  16.         value = self.cleaned_data.get("username")
  17.         if "666" in value:
  18.             raise ValidationError("光喊666是不行的")
  19.         else:
  20.             return value

全局钩子

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

  1. class LoginForm(forms.Form):
  2.     ...
  3.     password = forms.CharField(
  4.         min_length=6,
  5.         label="密码",
  6.         widget=forms.widgets.PasswordInput(attrs={'class': 'form-control'}, render_value=True)
  7.     )
  8.     re_password = forms.CharField(
  9.         min_length=6,
  10.         label="确认密码",
  11.         widget=forms.widgets.PasswordInput(attrs={'class': 'form-control'}, render_value=True)
  12.     )
  13.     ...
  14.     # 定义全局的钩子，用来校验密码和确认密码字段是否相同
  15.     def clean(self):
  16.         password_value = self.cleaned_data.get('password')
  17.         re_password_value = self.cleaned_data.get('re_password')
  18.         if password_value == re_password_value:
  19.             return self.cleaned_data
  20.         else:
  21.             self.add_error('re_password', '两次密码不一致')
  22.             raise ValidationError('两次密码不一致')

补充进阶

应用Bootstrap样式

Django form应用Bootstrap样式简单示例

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.   <meta charset="UTF-8">
  5.   <meta http-equiv="x-ua-compatible" content="IE=edge">
  6.   <meta name="viewport" content="width=device-width, initial-scale=1">
  7.   <link rel="stylesheet" href="/static/bootstrap/css/bootstrap.min.css">
  8.   <title>login</title>
  9. </head>
  10. <body>
  11. <div class="container">
  12.   <div class="row">
  13.     <form action="/login2/" method="post" novalidate class="form-horizontal">
  14.       {% csrf_token %}
  15.       <div class="form-group">
  16.         <label for="{{ form_obj.username.id_for_label }}"
  17.                class="col-md-2 control-label">{{ form_obj.username.label }}</label>
  18.         <div class="col-md-10">
  19.           {{ form_obj.username }}
  20.           <span class="help-block">{{ form_obj.username.errors.0 }}</span>
  21.         </div>
  22.       </div>
  23.       <div class="form-group">
  24.         <label for="{{ form_obj.pwd.id_for_label }}" class="col-md-2 control-label">{{ form_obj.pwd.label }}</label>
  25.         <div class="col-md-10">
  26.           {{ form_obj.pwd }}
  27.           <span class="help-block">{{ form_obj.pwd.errors.0 }}</span>
  28.         </div>
  29.       </div>
  30.       <div class="form-group">
  31.       <label class="col-md-2 control-label">{{ form_obj.gender.label }}</label>
  32.         <div class="col-md-10">
  33.           <div class="radio">
  34.             {% for radio in form_obj.gender %}
  35.               <label for="{{ radio.id_for_label }}">
  36.                 {{ radio.tag }}{{ radio.choice_label }}
  37.               </label>
  38.             {% endfor %}
  39.           </div>
  40.         </div>
  41.       </div>
  42.       <div class="form-group">
  43.         <div class="col-md-offset-2 col-md-10">
  44.           <button type="submit" class="btn btn-default">注册</button>
  45.         </div>
  46.       </div>
  47.     </form>
  48.   </div>
  49. </div>
  51. <script src="/static/jquery-3.2.1.min.js"></script>
  52. <script src="/static/bootstrap/js/bootstrap.min.js"></script>
  53. </body>
  54. </html>

批量添加样式

可通过重写form类的init方法来实现。

  1. class LoginForm(forms.Form):
  2.     username = forms.CharField(
  3.         min_length=8,
  4.         label="用户名",
  5.         initial="张三",
  6.         error_messages={
  7.             "required": "不能为空",
  8.             "invalid": "格式错误",
  9.             "min_length": "用户名最短8位"
  10.         }
  11.     ...
  13.     def __init__(self, *args, **kwargs):
  14.         super(LoginForm, self).__init__(*args, **kwargs)
  15.         for field in iter(self.fields):
  16.             self.fields[field].widget.attrs.update({
  17.                 'class': 'form-control'
  18.             })

ModelForm

通常在Django项目中，我们编写的大部分都是与Django 的模型紧密映射的表单。 举个例子，你也许会有个Book 模型，并且你还想创建一个form表单用来添加和编辑书籍信息到这个模型中。 在这种情况下，在form表单中定义字段将是冗余的，因为我们已经在模型中定义了那些字段。
基于这个原因，Django 提供一个辅助类来让我们可以从Django 的模型创建Form，这就是ModelForm。

modelForm定义

form与model的终极结合。

  1. class BookForm(forms.ModelForm):
  3.     class Meta:
  4.         model = models.Book
  5.         fields = "__all__"
  6.         labels = {
  7.             "title": "书名",
  8.             "price": "价格"
  9.         }
  10.         widgets = {
  11.             "password": forms.widgets.PasswordInput(attrs={"class": "c1"}),
  12.         }

class Meta下常用参数：

  1. model = models.Book  # 对应的Model中的类
  2. fields = "__all__"  # 字段，如果是__all__,就是表示列出所有的字段
  3. exclude = None  # 排除的字段
  4. labels = None  # 提示信息
  5. help_texts = None  # 帮助提示信息
  6. widgets = None  # 自定义插件
  7. error_messages = None  # 自定义错误信息

ModelForm的验证

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

save()方法

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

  1. >>> from myapp.models import Book
  2. >>> from myapp.forms import BookForm
  4. # 根据POST数据创建一个新的form对象
  5. >>> form_obj = BookForm(request.POST)
  7. # 创建书籍对象
  8. >>> new_ book = form_obj.save()
  10. # 基于一个书籍对象创建form对象
  11. >>> edit_obj = Book.objects.get(id=1)
  12. # 使用POST提交的数据更新书籍对象
  13. >>> form_obj = BookForm(request.POST, instance=edit_obj)
  14. >>> form_obj.save()