Django开发-Form组件

第1章 Form介绍

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

1.1 form组件的主要功能

  1. 生成页面可用的HTML标签:要有一个注册的页面,里面有form表单
  2. 对用户提交的数据进行校验:form表单要能提交数据到后端,后端要做有效性校验
  3. 校验信息返回并展示,保存原来填写的内容:要把校验的提示信息展示在页面上

1.1.1 校验方式

  1. 前端通过JS代码做校验:最好有,可以减少服务器压力
  2. 后端做校验:必须要有,因为前端的校验可以被跳过

1.2 注册功能示例

1.2.1 普通方式手写注册功能

  • views.py
# 注册
def reg(request):
    error_msg = ""
    if request.method == "POST":
        username = request.POST.get("name")
        pwd = request.POST.get("pwd")
        # 对注册信息做校验
        if len(username) < 6:
            # 用户长度小于6位
            error_msg = "用户名长度不能小于6位"
        else:
            # 将用户名和密码存到数据库
            return HttpResponse("注册成功")
    return render(request, "reg.html", {"error_msg": error_msg})
  • reg.html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>注册页面</title>
</head>
<body>
<form action="/reg/" method="post">
    {% csrf_token %}
    <p>
        用户名:
        <input type="text" name="name">
    </p>
    <p>
        密码:
        <input type="password" name="pwd">
    </p>
    <p>
        <input type="submit" value="注册">
        <p style="color: red">{{ error_msg }}</p>
    </p>
</form>
</body>
</html>
  • urls.py
urlpatterns = [
   url(r'^reg/$', views.reg),
]

【运行结果】:

图片[1]|Django开发-Form组件|leon的博客

1.2.2 使用form组件实现注册功能

  • views.py
from django import forms
from django.forms import widgets

# 定义RegForm类
class RegForm(forms.Form):
    name = forms.CharField(
        # 校验规则相关
        max_length=16,
        label="用户名",
        error_messages={
            "required": "该字段不能为空",
        },
        # widget控制的是生成html代码相关的
        widget=widgets.TextInput(attrs={"class": "form-control"})
    )
    pwd = forms.CharField(
        label="密码",
        min_length=6,
        max_length=10,
        widget=widgets.PasswordInput(attrs={"class": "form-control"}, render_value=True),
        error_messages={
            "min_length": "密码不能少于6位!",
            "max_length": "密码最长10位!",
            "required": "该字段不能为空",
        }
)

# 使用form组件实现注册方式
def register(request):
    form_obj = RegForm()
    if request.method == "POST":
        form_obj = RegForm(request.POST)
        # 让form做校验
        if form_obj.is_valid():
            # 校验通过,把数据存到数据库
            # 所有经过校验的数据都保存在 form_obj.cleaned_data
            models.UserInfo.objects.create(**form_obj.cleaned_data)
            return HttpResponse("注册成功!")
    return render(request, "register.html", {"form_obj": form_obj})
  • register.html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <style>
        .c1 {
            list-style-type: none;
        }
    </style>
    <link rel="stylesheet" href="/static/bootstrap/css/bootstrap.min.css">
</head>
<body>

<div class="container">
    <div class="row">
        <div class="col-md-6 col-md-offset-3">
            <form action="/register/" method="post" novalidate>
                {% csrf_token %}
                <div class="form-group {% if form_obj.name.errors.0 %}has-error{% endif %}">
                    {{ form_obj.name.label }}
                    {{ form_obj.name }}
                    <span class="help-block">{{ form_obj.name.errors.0 }}</span>
                </div>
                <div class="form-group {% if form_obj.pwd.errors.0 %}has-error{% endif %}">
                    {{ form_obj.pwd.label }}
                    {{ form_obj.pwd }}
                    <span class="help-block">{{ form_obj.pwd.errors.0 }}</span>
                </div>
                <div class="form-group">
                    <input type="submit" class="btn btn-default">
                </div>
            </form>
        </div>
    </div>
</div>
</body>
</html>
  • urls.py
urlpatterns = [
    # 使用form组件的
    url(r'^register/$', views.register),
]

【运行结果】:

  • 校验失败时:

图片[2]|Django开发-Form组件|leon的博客

  • 校验成功时:

看网页效果发现也验证了form的功能:

图片[3]|Django开发-Form组件|leon的博客

  1. 前端页面是form类的对象生成的:生成HTML标签功能
  2. 当用户名和密码输入为空或输错之后页面都会提示:用户提交校验功能
  3. 当用户输错之后再次输入上次的内容还保留在input框:保留上次输入内容

第2章 Form使用

2.1 常用字段与插件

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

2.1.1 initial

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

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

2.1.2 error_messages

重写错误信息。

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

2.1.3 密码password

class LoginForm(forms.Form):
    pwd = forms.CharField(
        min_length=6,
        label="密码",
        # widget【插件】用于控制html代码相关样式等
        widget=forms.widgets.PasswordInput(attrs={'class': 'c1'}, render_value=True)
    )

2.1.4 单选radioSelect

单radio值为字符串
class LoginForm(forms.Form):
    gender = forms.fields.ChoiceField(
        choices=((1, "男"), (2, "女"), (3, "保密")),
        label="性别",
        initial=3,
        widget=forms.widgets.RadioSelect()
)

【运行结果】:

图片[4]|Django开发-Form组件|leon的博客

2.1.5 单选Select

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

【运行结果】:

图片[5]|Django开发-Form组件|leon的博客

2.1.6 多选Select

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

【运行结果】:

图片[6]|Django开发-Form组件|leon的博客

2.1.7 单选checkbox

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

【运行结果】:

图片[7]|Django开发-Form组件|leon的博客

2.1.8 多选checkbox

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

【运行结果】:

图片[8]|Django开发-Form组件|leon的博客

2.1.9 choice字段注意事项

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

2.1.9.1 方式一

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

class RegForm(forms.Form):
    city = forms.ChoiceField(
        # choices=((1,"哈尔滨"),(2,"长春"),(3,"沈阳"),),
        choices=models.City.objects.all().values_list("id", "name"),
        label="城市",
        initial=1,
        widget=forms.widgets.Select
    )

    # 重写父类的init方法
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        # self.fields["city"].widget.choices =((1,"哈尔滨"),(2,"长春"),(3,"沈阳"),(4,"北京"),(5,"天津"))
        self.fields["city"].widget.choices = models.City.objects.all().values_list("id", "name")

【运行结果】:

图片[9]|Django开发-Form组件|leon的博客

2.1.9.2 方式二

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

class RegForm(forms.Form):
# 多选
city = form_model.ModelMultipleChoiceField(models.City.objects.all().values_list("id", "name"))
# 单选
# city = form_model.ModelChoiceField(models.City.objects.all().values_list("id", "name"))

【运行结果】:

  • 多选:

图片[10]|Django开发-Form组件|leon的博客

  • 单选:

图片[11]|Django开发-Form组件|leon的博客

2.2 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类型

2.3 字段校验

2.3.1 RegexValidator验证器

from django.forms import Form
from django.forms import widgets
from django.core.validators import RegexValidator

class RegForm(forms.Form):
    mobile = forms.CharField(
        label="手机",
        # 自己定制校验规则
        validators=[
            RegexValidator(r'^[0-9]+$', '手机号必须是数字'),
            RegexValidator(r'^1[3-9][0-9]{9}$', '手机格式有误')
        ],
        widget=widgets.TextInput(attrs={"class": "form-control"}),
        error_messages={
            "required": "该字段不能为空",
        }
)

【运行结果】:

图片[12]|Django开发-Form组件|leon的博客 图片[13]|Django开发-Form组件|leon的博客

图片[14]|Django开发-Form组件|leon的博客

2.3.2 自定义验证函数

import re
from django import forms
from django.forms import widgets
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 RegForm(forms.Form):
    title = forms.CharField(
        label="标题",
        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 = forms.CharField(
        label="手机",
        # 使用自定义验证规则
        validators=[
            mobile_validate,
        ],
        error_messages={
            'required': '手机不能为空'
        },
        widget=widgets.TextInput(attrs={"class": "form-control","placeholder": "手机号码"}))

    email = forms.EmailField(
        required=False,
        label="邮箱",
        error_messages={
            'required': '邮箱不能为空',
            'invalid': '邮箱格式错误'
        },
        widget=widgets.EmailInput(attrs={"class": "form-control","placeholder": "邮箱"}))

2.4 Hook方法

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

2.4.1 局部钩子

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

【示例】:

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

class RegForm(forms.Form):
    name = forms.CharField(
        max_length=16,
        label="用户名",
        error_messages={
            "required": "该字段不能为空",
        },
        widget=widgets.TextInput(attrs={"class": "form-control"})

    # 定义局部钩子,用来校验name字段
    def clean_name(self):
        value = self.cleaned_data.get("name")
        if "测试" in value:
            raise ValidationError("请换一个名字")
        return value

【运行结果】:

图片[15]|Django开发-Form组件|leon的博客

2.4.2 全局钩子

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

【示例】:校验两次输入的密码是否一致

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

class RegForm(forms.Form):
    pwd = forms.CharField(
        label="密码",
        min_length=6,
        max_length=10,
        widget=widgets.PasswordInput(attrs={"class": "form-control"}, render_value=True),
        error_messages={
            "min_length": "密码不能少于6位!",
            "max_length": "密码最长10位!",
            "required": "该字段不能为空",
        }
    )
    re_pwd = forms.CharField(
        label="确认密码",
        min_length=6,
        max_length=10,
        widget=widgets.PasswordInput(attrs={"class": "form-control"}, render_value=True),
        error_messages={
            "min_length": "密码不能少于6位!",
            "max_length": "密码最长10位!",
            "required": "该字段不能为空",
        }
)

    # 定义全局钩子,重写父类的clean方法校验两次密码一致
    def clean(self):
        # 此时通过检验的字段的数据都保存在self.cleaned_data
        pwd = self.cleaned_data.get("pwd")
        re_pwd = self.cleaned_data.get("re_pwd")
        if pwd != re_pwd:
            self.add_error("re_pwd", ValidationError("两次密码不一致"))
            raise ValidationError("两次密码不一致")
        return self.cleaned_data

【运行结果】:

图片[16]|Django开发-Form组件|leon的博客

2.5 补充进阶

2.5.1 应用Bootstrap样式

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <style>
        .c1 {
            list-style-type: none;
        }
    </style>
    <link rel="stylesheet" href="/static/bootstrap/css/bootstrap.min.css">
</head>
<body>

{#表单字段测试#}
{#<form action="/register/" method="post" novalidate>#}
{#    {% csrf_token %}#}
{#    {{ form_obj.as_p }}#}
{#    {{ form_obj.errors.pwd }}#}
{#    <p><input type="submit"></p>#}
{#</form>#}

<div class="container">
    <div class="row">
        <div class="col-md-6 col-md-offset-3">
            <form action="/register/" method="post" novalidate>
                {% csrf_token %}
                <div class="form-group {% if form_obj.name.errors.0 %}has-error{% endif %}">
                    {{ form_obj.name.label }}
                    {{ form_obj.name }}
                    <span class="help-block">{{ form_obj.name.errors.0 }}</span>
                </div>

                <div class="form-group {% if form_obj.pwd.errors.0 %}has-error{% endif %}">
                    {{ form_obj.pwd.label }}
                    {{ form_obj.pwd }}
                    <span class="help-block">{{ form_obj.pwd.errors.0 }}</span>
                </div>
            <div class="form-group {% if form_obj.re_pwd.errors.0 %}has-error{% endif %}">
                    {{ form_obj.re_pwd.label }}
                    {{ form_obj.re_pwd }}
                    <span class="help-block">{{ form_obj.re_pwd.errors.0 }}</span>
                </div>
            <div class="form-group {% if form_obj.email.errors.0 %}has-error{% endif %}">
                    {{ form_obj.email.label }}
                    {{ form_obj.email }}
                    <span class="help-block">{{ form_obj.email.errors.0 }}</span>
                </div>
            <div class="form-group {% if form_obj.mobile.errors.0 %}has-error{% endif %}">
                    {{ form_obj.mobile.label }}
                    {{ form_obj.mobile }}
                    <span class="help-block">{{ form_obj.mobile.errors.0 }}</span>
                </div>
            <div class="form-group {% if form_obj.city.errors.0 %}has-error{% endif %}">
                    {{ form_obj.city.label }}
                    {{ form_obj.city }}
                    <span class="help-block">{{ form_obj.city.errors.0 }}</span>
                </div>

{#            自定义校验测试#}
{#            <div class="form-group {% if form_obj.title.errors.0 %}has-error{% endif %}">#}
{#                    {{ form_obj.title.label }}#}
{#                    {{ form_obj.title }}#}
{#                    <span class="help-block">{{ form_obj.title.errors.0 }}</span>#}
{#                </div>#}
{#            <div class="form-group {% if form_obj.email.errors.0 %}has-error{% endif %}">#}
{#                    {{ form_obj.email.label }}#}
{#                    {{ form_obj.email }}#}
{#                    <span class="help-block">{{ form_obj.email.errors.0 }}</span>#}
{#                </div>#}
{#            <div class="form-group {% if form_obj.phone.errors.0 %}has-error{% endif %}">#}
{#                    {{ form_obj.phone.label }}#}
{#                    {{ form_obj.phone }}#}
{#                    <span class="help-block">{{ form_obj.phone.errors.0 }}</span>#}
{#                </div>#}
                <div class="form-group">
                    <input type="submit" class="btn btn-default">
                </div>
            </form>
        </div>
    </div>

</div>
</body>
</html>

2.5.2 批量添加样式

可通过重写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'
            })

第3章 ModelForm

通常在Django项目中我们编写的大部分都是与Django 的模型紧密映射的表单。举个例子,有个Book 模型,并且还想创建一个form表单用来添加和编辑书籍信息到这个模型中。在这种情况下在form表单中定义字段将是冗余的,因为我们已经在模型中定义了那些字段。

基于这个原因Django提供一个辅助类来让我们可以从Django的模型创建Form,这就是ModelForm。

3.1 modelForm定义

form与model的终极结合。

class BookForm(forms.ModelForm):

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

3.2 class Meta下常用参数

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

3.3 ModelForm的验证

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

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

第4章 参考资料

https://www.cnblogs.com/liwenzhou/p/8747872.html

温馨提示:本文最后更新于2022-12-20 20:57:43,已超过483天没有更新。某些文章具有时效性,若文章内容或图片资源有错误或已失效,请联系站长。谢谢!
转载请注明本文链接:https://blog.leonshadow.cn/763482/1707.html
© 版权声明
THE END
喜欢就支持一下吧
点赞0 分享