深入理解Django的Form表单

参考博文：
https://www.cnblogs.com/wupeiqi/articles/6144178.html
https://www.cnblogs.com/shenjianping/p/11548311.html

一、深入理解Django的Form表单

Django的Form主要具有一下几大功能：
- 生成HTML标签；
- 验证用户数据（显示错误信息）；
- HTML Form提交保留上次提交数据；
- 初始化页面显示内容；

1.1、话不多说，先看示例

1.1.1、创建Form类

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

1.1.2、创建View视图函数

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://top.toptops.top')

1.1.3、模板生成HTML

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
  <form action="/" method="POST" enctype="multipart/form-data">
      <p>{{ form.user }} {{ form.user.errors }}</p>
      <p>{{ form.gender }} {{ form.gender.errors }}</p>
      <p>{{ form.city }} {{ form.city.errors }}</p>
      <p>{{ form.pwd }} {{ form.pwd.errors }}</p>
      <input type="submit"/>
  </form>
</body>

至此很容易就完成了登录功能，并且也使用到了Form表单的作用；

1.2、forms字段和插件

在上述实例中，使用Form需要创建一个Form相关的类，并且在类中写入相关的forms字段，这里涉及到Field类，是所有forms字段最根本的基类，它位于django.forms.Field下;
创建Form类时，主要涉及到 【字段】 和 【插件】，字段用于对用户请求数据的验证，插件用于自动生成HTML;

1.2.1、字段的基本参数

在这个类中的__init__方法中有很多参数，这也就是字段参数；

  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内容后缀

1.2.2、字段的基本方法

在这个类中还有一些方法，也就是字段对象的方法；

1.2.2.1、clean

def clean(self, value):
    """
    Validate the given value and return its "cleaned" value as an
    appropriate Python object. Raise ValidationError for any errors.
    """
    value = self.to_python(value)
    self.validate(value)
    self.run_validators(value)
    return value

每个Field实例都有一个clean()方法，它接受一个参数并引发django.forms.ValidationError 异常或返回clean值;

$ python manage.py shell
In [1]: from django import forms
In [2]: f = forms.EmailField()
In [3]: f.clean('1284808408@.com')
Out[3]: '1284808408@qq.com'
...
In [4]: f.clean('1284808408')
ValidationError: ['Enter a valid email address.']

1.2.2.2、bound_data

它有两个参数，一个是request.POST提交的data，另一个是initial参数初始化的数据，这个方法返回的就是request.POST提交的那个字段值;

def bound_data(self, data, initial):
    """
    Return the value that should be shown for this field on render of a
    bound form, given the submitted POST data for the field and the initial
    data, if any.

    For most fields, this will simply be data; FileFields need to handle it
    a bit differently.
    """
    if self.disabled:
        return initial
    return data

1.2.2.3、has_changed

它有两个参数，一个是request.POST提交的data，另一个是initial参数初始化的数据，这个方法返回的是布尔值，如果提交的data与初始化数据不一样的话就返回True;

def has_changed(self, initial, data):
    """Return True if data differs from initial."""
    # Always return False if the field is disabled since self.bound_data
    # always uses the initial value in this case.
    if self.disabled:
        return False
    try:
        data = self.to_python(data)
        if hasattr(self, '_coerce'):
            return self._coerce(data) != self._coerce(initial)
    except ValidationError:
        return True
    # For purposes of seeing whether something has changed, None is
    # the same as an empty string, if the data or initial value we get
    # is None, replace it with ''.
    initial_value = initial if initial is not None else ''
    data_value = data if data is not None else ''
    return initial_value != data_value

1.2.2.4、get_bound_field

它有两个参数，一个是form实例，另一个是创建的Form类字段的字段名称field_name，而它的返回值是BoundField对象;

def get_bound_field(self, form, field_name):
    """
    Return a BoundField instance that will be used when accessing the form
    field in a template.
    """
    return BoundField(form, self, field_name)

1.2.3、字段的基本方法

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

一个字段可包含以下参数:

from django.forms import fields as ffields
from django.forms import widgets as fwidgets

group_name = ffields.CharField(
        max_length=32,
        required=True,
        widget=fwidgets.TextInput(attrs={'class': 'form-control'}),
        error_messages={
            'required': '名称不能为空',
        })

1.2.4、常用插件

每一个字段都有一个默认的插件，这时为了在页面生成html标签时，生成该字段对应的html标签；

class CharField(Field):
    def __init__(self, *, max_length=None, min_length=None, strip=True, empty_value='', **kwargs):
        self.max_length = max_length
        self.min_length = min_length
        self.strip = strip
        self.empty_value = empty_value
        super().__init__(**kwargs)
        if min_length is not None:
            self.validators.append(validators.MinLengthValidator(int(min_length)))
        if max_length is not None:
            self.validators.append(validators.MaxLengthValidator(int(max_length)))
        self.validators.append(validators.ProhibitNullCharactersValidator())

    def to_python(self, value):
        """Return a string."""
        if value not in self.empty_values:
            value = str(value)
            if self.strip:
                value = value.strip()
        if value in self.empty_values:
            return self.empty_value
        return value

    def widget_attrs(self, widget):
        attrs = super().widget_attrs(widget)
        if self.max_length is not None and not widget.is_hidden:
            # The HTML attribute is maxlength, not max_length.
            attrs['maxlength'] = str(self.max_length)
        if self.min_length is not None and not widget.is_hidden:
            # The HTML attribute is minlength, not min_length.
            attrs['minlength'] = str(self.min_length)
        return attrs

在CharField中，它继承了Field，所以它的默认Widget是Field中TextInput，它在HTML 中生成一个<input type="text">
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

1.2.5、选择插件（常用选择插件）

# 单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的选项可以从数据库中获取，但是由于是静态字段 获取的值无法实时更新，那么需要自定义构造方法从而达到此目的。

　　city = fields.TypedChoiceField(
　　coerce=lambda x: int(x),
　　choices=[(1,'上海',),(2,'北京'),(3,'望京'),],
　　initial=2
　　)

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

from app01.models import *
from django.forms.models import ModelChoiceField  #方法二实时更新
class classesForm(forms.Form):
    #方法二，切记model类中需要有__str()__方法
    class_select_model =ModelChoiceField(
        queryset=classesAll.objects.all(),
        to_field_name = 'id',#指的是value值
    )
　　#方法一
    class_select = fields.ChoiceField(
        # choices=classesAll.objects.values_list('id','name'),可以省略
        widget=widgets.Select()
    )
    def __init__(self,*args,**kwargs):
        super(classesForm,self).__init__(*args,**kwargs)
        self.fields['class_select'].widget.choices=classesAll.objects.values_list('id','name')

示例：

class ProcessHours(models.Model):
    """
    工时库
    """
    create_user = models.ForeignKey(UserInfo, verbose_name='生产管理者', null=True, blank=True)
    process_hours_group = models.ForeignKey(ProcessGroup, verbose_name='组别名称',null=True,blank=True)
    process_hours_type = models.ForeignKey(ProcessPrice,verbose_name='工序类别',null=True,blank=True)
    process_hours_name = models.CharField(verbose_name='工序名称',null=True, max_length=128,blank=True)
    process_hours_all = models.DecimalField(verbose_name='工时',null=True, blank=True,decimal_places=2,max_digits=10)

    def __str__(self):
        return '%s-%s' % (self.process_hours_group, self.process_hours_name)

from django.forms import widgets as fwidgets
from django.forms import Form
from django.forms import fields as ffields

class ProcessHoursForm(Form):
    create_user_id = ffields.ChoiceField(
        widget=fwidgets.Select(attrs={'class': 'form-control'}),
        choices=[],

    )
    process_hours_group_id = ffields.ChoiceField(
        widget=fwidgets.Select(attrs={'class': 'form-control'}),
        choices=[],
    )
    process_hours_type_id = ffields.ChoiceField(
        widget = fwidgets.Select(attrs={'class': 'form-control'}),
        choices=[],
    )
    def __init__(self, *args, **kwargs):
        super(ProcessHoursForm, self).__init__(*args, **kwargs)
        self.fields['create_user_id'].choices = models.UserInfo.objects.values_list('id','nickname')
        self.fields['process_hours_group_id'].choices = models.ProcessGroup.objects.values_list('id','group_name')
        self.fields['process_hours_type_id'].choices = models.ProcessPrice.objects.values_list('id','process_type')

1.3、表单和字段验证

1.3.1、正则验证

from django.forms import Form
from django.forms import fields
from django.core.validators import RegexValidator
 
class TestForm(Form):

   v1= fields.CharField(
        disabled=True
    )
   v2= fields.CharField(
        validators=[RegexValidator(r'^[0-9]+$', '请输入数字')],
    )

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

1.3.2、对每个字段定义钩子函数

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

1.4、深入Form源码，探查高级方法

1.4.1、Form实例化

可以根据以下源码分析无论是GET还是POST请求都需要进行Form类的实例化时；

class BaseForm:
    """
    The main implementation of all the Form logic. Note that this class is
    different than Form. See the comments by the Form class for more info. Any
    improvements to the form API should be made to this class, not to the Form
    class.
    """
    default_renderer = None
    field_order = None
    prefix = None
    use_required_attribute = True

    def __init__(self, data=None, files=None, auto_id='id_%s', prefix=None,
                 initial=None, error_class=ErrorList, label_suffix=None,
                 empty_permitted=False, field_order=None, use_required_attribute=None, renderer=None):
        self.is_bound = data is not None or files is not None
        self.data = {} if data is None else data
        self.files = {} if files is None else files
        self.auto_id = auto_id
        if prefix is not None:
            self.prefix = prefix
        self.initial = initial or {}
        self.error_class = error_class
        # Translators: This is the default suffix added to form field labels
        self.label_suffix = label_suffix if label_suffix is not None else _(':')
        self.empty_permitted = empty_permitted
        self._errors = None  # Stores the errors after clean() has been called.

        # The base_fields class attribute is the *class-wide* definition of
        # fields. Because a particular *instance* of the class might want to
        # alter self.fields, we create self.fields here by copying base_fields.
        # Instances should always modify self.fields; they should not modify
        # self.base_fields.
        self.fields = copy.deepcopy(self.base_fields)
        self._bound_fields_cache = {}
        self.order_fields(self.field_order if field_order is None else field_order)

        if use_required_attribute is not None:
            self.use_required_attribute = use_required_attribute

        # Initialize form renderer. Use a global default if not specified
        # either as an argument or as self.default_renderer.
        if renderer is None:
            if self.default_renderer is None:
                renderer = get_default_renderer()
            else:
                renderer = self.default_renderer
                if isinstance(self.default_renderer, type):
                    renderer = renderer()
        self.renderer = renderer

1.4.2、is_valid

  def is_valid(self):
        """Return True if the form has no errors, or False otherwise."""
        return self.is_bound and not self.errors

源码说如果这个form没有错误就返回True，否则就是False;

self.is_bound = data #data是传入的request.POST

然而self.errors中

@property
    def errors(self):
        """Return an ErrorDict for the data provided for the form."""
        if self._errors is None:
            self.full_clean()
        return self._error

---
---

def full_clean(self):
    """
    Clean all of self.data and populate self._errors and self.cleaned_data.
    """
    self._errors = ErrorDict()
    if not self.is_bound:  # Stop further processing.
        return
    self.cleaned_data = {}
    # If the form is permitted to be empty, and none of the form data has
    # changed from the initial data, short circuit any validation.
    if self.empty_permitted and not self.has_changed():
        return

    self._clean_fields()
    self._clean_form()
    self._post_clean()

所以在验证通过的情况下：
- 初始化 self.cleaned_data = {}
- 执行每一个字段的自定义验证钩子函数 self._clean_fields()
- 执行全局验证的钩子函数 self._clean_form()
注意：在最后还预留了一个钩子，可用于扩展功能;

def _post_clean(self):
    """
    An internal hook for performing additional cleaning after form cleaning
    is complete. Used for model validation in model forms.
    """
    pass

1.4.3、self._clean_fields()

def _clean_fields(self):
    for name, field in self.fields.items():
        # value_from_datadict() gets the data from the data dictionaries.
        # Each widget type knows how to retrieve its own data, because some
        # widgets split data over several HTML fields.
        if field.disabled:
            value = self.get_initial_for_field(field, name)
        else:
            value = field.widget.value_from_datadict(self.data, self.files, self.add_prefix(name))
        try:
            if isinstance(field, FileField):
                initial = self.get_initial_for_field(field, name)
                value = field.clean(value, initial)
            else:
                value = field.clean(value)
            self.cleaned_data[name] = value
            if hasattr(self, 'clean_%s' % name):
                #执行每一个字段的钩子函数
                value = getattr(self, 'clean_%s' % name)()
                #将验证完毕的字段加入到self.cleaned_data
                self.cleaned_data[name] = value
        except ValidationError as e:
            self.add_error(name, e)

1.4.4、self._clean_form()

def _clean_form(self):
    try:
        #返回cleaned_data
        cleaned_data = self.clean()
    except ValidationError as e:
        self.add_error(None, e)
    else:
        if cleaned_data is not None:
            self.cleaned_data = cleaned_data

1.4.5、属性、方法

从源码中就可以看出，验证完毕后cleaned_data就有数据了，此时获取验证完毕的数据可以使用;

#获取所有验证成功的数据
form.cleaned_data
form.cleaned_data["username"]

错误信息使用;

form.errors
#每个字段错误信息
form.errors["username"]

1.4.6、页面渲染

#渲染username字段错误
{{ form.Username.errors }}

#渲染username字段标签
 {{ form.Username }}

二、深入扩展Form表单的BoundField类

2.1、BoundField类

BoundField类是什么呢？看个例子就知道了。

...

    form = LoginForm(data=request.POST)

    for field in form:
        print(type(field),field)

...

执行结果

<class 'django.forms.boundfield.BoundField'> <input type="text" name="username" value="admin" id="id_username" maxlength="32" required />
<class 'django.forms.boundfield.BoundField'> <input type="text" name="password" value="123" id="id_password" maxlength="32" required />

这个就是form对象中的字段将自定义Form类中的字段与form实例进行绑定联系，具体方法可以参考下面源码。

@html_safe
class BoundField:
    "A Field plus data"
    def __init__(self, form, field, name):
        self.form = form
        self.field = field
        self.name = name
        self.html_name = form.add_prefix(name)
        self.html_initial_name = form.add_initial_prefix(name)
        self.html_initial_id = form.add_initial_prefix(self.auto_id)
        if self.field.label is None:
            self.label = pretty_name(name)
        else:
            self.label = self.field.label
        self.help_text = field.help_text or ''

    def __str__(self):
        """Render this field as an HTML widget."""
        if self.field.show_hidden_initial:
            return self.as_widget() + self.as_hidden(only_initial=True)
        return self.as_widget()

    @cached_property
    def subwidgets(self):
        """
        Most widgets yield a single subwidget, but others like RadioSelect and
        CheckboxSelectMultiple produce one subwidget for each choice.

        This property is cached so that only one database query occurs when
        rendering ModelChoiceFields.
        """
        id_ = self.field.widget.attrs.get('id') or self.auto_id
        attrs = {'id': id_} if id_ else {}
        attrs = self.build_widget_attrs(attrs)
        return [
            BoundWidget(self.field.widget, widget, self.form.renderer)
            for widget in self.field.widget.subwidgets(self.html_name, self.value(), attrs=attrs)
        ]

    def __bool__(self):
        # BoundField evaluates to True even if it doesn't have subwidgets.
        return True

    def __iter__(self):
        return iter(self.subwidgets)

    def __len__(self):
        return len(self.subwidgets)

    def __getitem__(self, idx):
        # Prevent unnecessary reevaluation when accessing BoundField's attrs
        # from templates.
        if not isinstance(idx, (int, slice)):
            raise TypeError
        return self.subwidgets[idx]

    @property
    def errors(self):
        """
        Return an ErrorList (empty if there are no errors) for this field.
        """
        return self.form.errors.get(self.name, self.form.error_class())

    def as_widget(self, widget=None, attrs=None, only_initial=False):
        """
        Render the field by rendering the passed widget, adding any HTML
        attributes passed as attrs. If a widget isn't specified, use the
        field's default widget.
        """
        if not widget:
            widget = self.field.widget

        if self.field.localize:
            widget.is_localized = True

        attrs = attrs or {}
        attrs = self.build_widget_attrs(attrs, widget)
        auto_id = self.auto_id
        if auto_id and 'id' not in attrs and 'id' not in widget.attrs:
            if not only_initial:
                attrs['id'] = auto_id
            else:
                attrs['id'] = self.html_initial_id

        if not only_initial:
            name = self.html_name
        else:
            name = self.html_initial_name

        kwargs = {}
        if func_supports_parameter(widget.render, 'renderer') or func_accepts_kwargs(widget.render):
            kwargs['renderer'] = self.form.renderer
        else:
            warnings.warn(
                'Add the `renderer` argument to the render() method of %s. '
                'It will be mandatory in Django 2.1.' % widget.__class__,
                RemovedInDjango21Warning, stacklevel=2,
            )
        return widget.render(
            name=name,
            value=self.value(),
            attrs=attrs,
            **kwargs
        )

    def as_text(self, attrs=None, **kwargs):
        """
        Return a string of HTML for representing this as an <input type="text">.
        """
        return self.as_widget(TextInput(), attrs, **kwargs)

    def as_textarea(self, attrs=None, **kwargs):
        """Return a string of HTML for representing this as a <textarea>."""
        return self.as_widget(Textarea(), attrs, **kwargs)

    def as_hidden(self, attrs=None, **kwargs):
        """
        Return a string of HTML for representing this as an <input type="hidden">.
        """
        return self.as_widget(self.field.hidden_widget(), attrs, **kwargs)

    @property
    def data(self):
        """
        Return the data for this BoundField, or None if it wasn't given.
        """
        return self.field.widget.value_from_datadict(self.form.data, self.form.files, self.html_name)

    def value(self):
        """
        Return the value for this BoundField, using the initial value if
        the form is not bound or the data otherwise.
        """
        data = self.initial
        if self.form.is_bound:
            data = self.field.bound_data(self.data, data)
        return self.field.prepare_value(data)

    def label_tag(self, contents=None, attrs=None, label_suffix=None):
        """
        Wrap the given contents in a <label>, if the field has an ID attribute.
        contents should be mark_safe'd to avoid HTML escaping. If contents
        aren't given, use the field's HTML-escaped label.

        If attrs are given, use them as HTML attributes on the <label> tag.

        label_suffix overrides the form's label_suffix.
        """
        contents = contents or self.label
        if label_suffix is None:
            label_suffix = (self.field.label_suffix if self.field.label_suffix is not None
                            else self.form.label_suffix)
        # Only add the suffix if the label does not end in punctuation.
        # Translators: If found as last label character, these punctuation
        # characters will prevent the default label_suffix to be appended to the label
        if label_suffix and contents and contents[-1] not in _(':?.!'):
            contents = format_html('{}{}', contents, label_suffix)
        widget = self.field.widget
        id_ = widget.attrs.get('id') or self.auto_id
        if id_:
            id_for_label = widget.id_for_label(id_)
            if id_for_label:
                attrs = dict(attrs or {}, **{'for': id_for_label})
            if self.field.required and hasattr(self.form, 'required_css_class'):
                attrs = attrs or {}
                if 'class' in attrs:
                    attrs['class'] += ' ' + self.form.required_css_class
                else:
                    attrs['class'] = self.form.required_css_class
            attrs = flatatt(attrs) if attrs else ''
            contents = format_html('<label{}>{}</label>', attrs, contents)
        else:
            contents = conditional_escape(contents)
        return mark_safe(contents)

    def css_classes(self, extra_classes=None):
        """
        Return a string of space-separated CSS classes for this field.
        """
        if hasattr(extra_classes, 'split'):
            extra_classes = extra_classes.split()
        extra_classes = set(extra_classes or [])
        if self.errors and hasattr(self.form, 'error_css_class'):
            extra_classes.add(self.form.error_css_class)
        if self.field.required and hasattr(self.form, 'required_css_class'):
            extra_classes.add(self.form.required_css_class)
        return ' '.join(extra_classes)

    @property
    def is_hidden(self):
        """Return True if this BoundField's widget is hidden."""
        return self.field.widget.is_hidden

    @property
    def auto_id(self):
        """
        Calculate and return the ID attribute for this BoundField, if the
        associated Form has specified auto_id. Return an empty string otherwise.
        """
        auto_id = self.form.auto_id  # Boolean or string
        if auto_id and '%s' in str(auto_id):
            return auto_id % self.html_name
        elif auto_id:
            return self.html_name
        return ''

    @property
    def id_for_label(self):
        """
        Wrapper around the field widget's `id_for_label` method.
        Useful, for example, for focusing on this field regardless of whether
        it has a single widget or a MultiWidget.
        """
        widget = self.field.widget
        id_ = widget.attrs.get('id') or self.auto_id
        return widget.id_for_label(id_)

    @cached_property
    def initial(self):
        data = self.form.get_initial_for_field(self.field, self.name)
        # If this is an auto-generated default date, nix the microseconds for
        # standardized handling. See #22502.
        if (isinstance(data, (datetime.datetime, datetime.time)) and
                not self.field.widget.supports_microseconds):
            data = data.replace(microsecond=0)
        return data

    def build_widget_attrs(self, attrs, widget=None):
        if not widget:
            widget = self.field.widget
        attrs = dict(attrs)  # Copy attrs to avoid modifying the argument.
        if widget.use_required_attribute(self.initial) and self.field.required and self.form.use_required_attribute:
            attrs['required'] = True
        if self.field.disabled:
            attrs['disabled'] = True
        return attrs

BoundField

其中有一些方法可以参考，像errors方法，这也就解释了为什么字段可以直接调用该方法;

2.2、自定义BaseForm

有些时候Form类中需要request或者其它参数，此时需要自定义BaseForm：

2.2.1、BaseRequestForm

class BaseRequestForm(object):
    def __init__(self, request, *args, **kwargs):
        self.request = request
        super(BaseRequestForm, self).__init__(*args, **kwargs)

2.2.2、BaseForm

class BaseForm(BaseRequestForm,forms.Form):

    def __init__(self, request,*args, **kwargs):
        super(BaseForm, self).__init__(request,*args, **kwargs)
        # 统一给Form生成字段添加样式
        for name, field in self.fields.items():
            field.widget.attrs['class'] = 'form-control'

2.2.3、Form使用

from django.core.exceptions import ValidationError
from django import forms 
from django.forms import fields 

class LoginForm(BaseForm):

    username = fields.CharField()
    password = fields.CharField()
    code = django_fields.CharField(
        error_messages={'required': '验证码不能为空.'}
    )

 #从request的session中取出验证码进行验证    
    def clean_code(self):
        if self.request.session.get('CheckCode').upper() != self.request.POST.get('code').upper():
            raise ValidationError(message='验证码错误', code='invalid')

在视图中进行LoginForm实例化时传入request参数即可：

form = LoginForm(request=request, data=request.POST)

posted @ 2021-07-14 23:56 SRE运维充电站阅读(155) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

SRE运维充电站

深入理解Django的Form表单

一、深入理解Django的Form表单

1.1、话不多说，先看示例

1.1.1、创建Form类

1.1.2、创建View视图函数

1.1.3、模板生成HTML

1.2、forms字段和插件

1.2.1、字段的基本参数

1.2.2、字段的基本方法

1.2.2.1、clean

1.2.2.2、bound_data

1.2.2.3、has_changed

1.2.2.4、get_bound_field

1.2.3、字段的基本方法

1.2.4、常用插件

1.2.5、选择插件（常用选择插件）

1.3、表单和字段验证

1.3.1、正则验证

1.3.2、对每个字段定义钩子函数

1.4、深入Form源码，探查高级方法

1.4.1、Form实例化

1.4.2、is_valid

1.4.3、self._clean_fields()

1.4.4、self._clean_form()

1.4.5、属性、方法

1.4.6、页面渲染

二、深入扩展Form表单的BoundField类

2.1、BoundField类

2.2、自定义BaseForm

2.2.1、BaseRequestForm

2.2.2、BaseForm

2.2.3、Form使用

公告