一篇文章搞懂Django中的form表单

orm介绍

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

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

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

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

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

普通的登录

views.py

def login(request):
    error_msg=""
    if request.method=="POST":
        username=request.POST.get("username")
        pwd=request.POST.get("pwd")
        if username=="SKS" and pwd=="1366768":
            return HttpResponse("OK")
        else:
            error_msg="用户名或密码错误"
    return render(request, "login.html", {"error_msg": error_msg})

login.html

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta http-equiv="x-ua-compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>login</title>
  <style>
    .error {
      color: red;
    }
  </style>
</head>
<body>
<form action="/login/" method="post">
  {% csrf_token %}
  <p>
    <label for="username">用户名</label>
    <input type="text" name="username" id="username">
  </p>
  <p>
    <label for="pwd">密码</label>
    <input type="password" name="pwd" id="pwd">
    <span class="error"></span>
  </p>
  <p>
    <input type="submit">
    <span class="error">{{ error_msg }}</span>
  </p>
</form>
</body>
</html>

使用form组件

views.py

先定义好一个LoginForm类。

# 定义一个form组件类
class LoginForm(forms.Form):
    # 验证的字段及条件
    username=forms.CharField(min_length=10, label="用户名")
    pwd=forms.CharField(min_length=10, label="密码")


def login(request):
    # 存储错误信息
    error_msg=""
   # 实例化对象
    form_obj=LoginForm()
     # 判断前端页面请求是否是POST请求
    if request.method=="POST":
        # 将数据传入form组件类中
        form_obj=LoginForm(request.POST)
        # 存储的正确信息
        if form_obj.is_valid():
            username=form_obj.cleaned_data.get("username")
            pwd=form_obj.cleaned_data.get("pwd")
            if username=="SKS" and pwd=="1866768":
                return HttpResponse("OK")
            else:
                error_msg="用户名或密码错误"
    return render(request, "login2.html", {"form_obj": form_obj, "error_msg": error_msg})

login2.html

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta http-equiv="x-ua-compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>login</title>
  <style>
    .error {
      color: red;
    }
  </style>
</head>
<body>
<form action="/login2/" method="post" novalidate>
  {% csrf_token %}
  <p>
    {{ form_obj.username.label }}
    {{ form_obj.username }}
    <span class="error">{{ form_obj.username.errors.0 }}</span>
  </p>
  <p>
    {{ form_obj.pwd.label }}
    {{ form_obj.pwd }}
    <span class="error">{{ form_obj.pwd.errors.0 }}</span>
  </p>
  <p>
    <input type="submit">
    <span class="error">{{ error_msg }}</span>
  </p>
</form>
</body>
</html>

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

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

Form组件

常用字段演示

initial

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

# 定义一个类继承forms.Form
class LoginForm(forms.Form):
    username=forms.CharField(
        min_length=10,
        label="用户名",
        initial="hewm"  # 设置默认值方法
    )
    pwd=forms.CharField(min_length=10, label="密码")

error_messages

重写错误信息。

class LoginForm(forms.Form):
    username=forms.CharField(
        min_length=10,
        label="用户名",
        initial="rum",
       # 重写错误提示信息
        error_messages={
            "required": "不能为空",
            "invalid": "格式错误",
            "min_length": "用户名最短10位"
        }
    )
    pwd=forms.CharField(min_length=10, label="密码")

password

class LoginForm(forms.Form):
    ...
    pwd=forms.CharField(
        min_length=10,
        label="密码",
         # 密文方法   参数attrs：样式类   render_value=验证失败是否回填

widget=forms.widgets.PasswordInput(attrs={'class': 'c1'}, render_value=True) )

radioSelect

单radio值为字符串

class LoginForm(forms.Form):
    username=forms.CharField(
        min_length=10,
        label="用户名",
        initial="rum",
        error_messages={
            "required": "不能为空",
            "invalid": "格式错误",
            "min_length": "用户名最短10位"
        }
    )
    pwd=forms.CharField(min_length=6, label="密码")
    gender=forms.fields.ChoiceField(
        choices=((1, "男"), (2, "女"), (3, "保密")),
        label="性别",
        initial=3,
        widget=forms.widgets.RadioSelect
    )

单选Select

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

多选Select

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

单选checkbox

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

多选checkbox

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

关于choice的注意事项：

在使用选择标签时，需要注意choices的选项可以从数据库中获取，但是由于是静态字段 ***获取的值无法实时更新***，那么需要自定义构造方法从而达到此目的。

方式一：

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

 
class MyForm(Form):
 
    user=fields.ChoiceField(
        # choices=((1, '上海'), (2, '北京'),),
        initial=2,
        widget=widgets.Select
    )
 # 初始化init方法 （执行时间为类实例化时执行）
    def __init__(self, *args, **kwargs):
        super(MyForm,self).__init__(*args, **kwargs)
        # self.fields['user'].widget.choices=((1, '上海'), (2, '北京'),)
        # 或
        self.fields['user'].widget.choices=models.Classes.objects.all().values_list('id','caption')

方式二：

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

 
class FInfo(forms.Form):
    authors=form_model.ModelMultipleChoiceField(queryset=models.NNewType.objects.all())
    # authors=form_model.ModelChoiceField(queryset=models.NNewType.objects.all())

内置字段

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

Django form内置字段

校验

方式一：

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

补充进阶

应用Bootstrap样式

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta http-equiv="x-ua-compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <link rel="stylesheet" href="/static/bootstrap/css/bootstrap.min.css">
  <title>login</title>
</head>
<body>
<div class="container">
  <div class="row">
    <form action="/login2/" method="post" novalidate class="form-horizontal">
      {% csrf_token %}
      <div class="form-group">
        <label for="{{ form_obj.username.id_for_label }}"
               class="col-md-2 control-label">{{ form_obj.username.label }}</label>
        <div class="col-md-10">
          {{ form_obj.username }}
          <span class="help-block">{{ form_obj.username.errors.0 }}</span>
        </div>
      </div>
      <div class="form-group">
        <label for="{{ form_obj.pwd.id_for_label }}" class="col-md-2 control-label">{{ form_obj.pwd.label }}</label>
        <div class="col-md-10">
          {{ form_obj.pwd }}
          <span class="help-block">{{ form_obj.pwd.errors.0 }}</span>
        </div>
      </div>
      <div class="form-group">
      <label class="col-md-2 control-label">{{ form_obj.gender.label }}</label>
        <div class="col-md-10">
          <div class="radio">
            {% for radio in form_obj.gender %}
              <label for="{{ radio.id_for_label }}">
                {{ radio.tag }}{{ radio.choice_label }}
              </label>
            {% endfor %}
          </div>
        </div>
      </div>
      <div class="form-group">
        <div class="col-md-offset-2 col-md-10">
          <button type="submit" class="btn btn-default">注册</button>
        </div>
      </div>
    </form>
  </div>
</div>

<script src="/static/jquery-3.2.1.min.js"></script>
<script src="/static/bootstrap/js/bootstrap.min.js"></script>
</body>
</html>

批量添加样式

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

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

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

源码简易剖析

views.py文件

def register(request):
    if request.method=="POST":
        res={"user": None, "error_dict": None}
        form=RegForm(request.POST)
        # 存储验证通过的信息.is_valid()（源码剖析开始点）
        if form.is_valid():
            user=form.cleaned_data.get("user")
            pwd=form.cleaned_data.get("pwd")
            email=form.cleaned_data.get("email")
            avatar=request.FILES.get("avatar")
            print(user,pwd,email,avatar)
            if avatar:
                user=UserInfo.objects.create_user(username=user, password=pwd, email=email, avatar=avatar)
            else:
                user=UserInfo.objects.create_user(username=user, password=pwd, email=email)

            res["user"]=user.username
        else:
            print(form.errors)
            res["error_dict"]=form.errors
        return JsonResponse(res)
    form=RegForm()
    return render(request, 'register.html', locals())

点击进入forms.py文件

def is_valid(self):
        """
        Returns True if the form has no errors. Otherwise, False. If errors are
        being ignored, returns False.
        """
        # 含义：返回布尔值，只要有数据并且没有错误信息就返回True
        return self.is_bound and not self.errors

点击self.errors进入forms.py文件中

# 静态方法
@property
    def errors(self):
        "Returns an ErrorDict for the data provided for the form"
       # 判断self._errors是否为空
        if self._errors is None:
            self.full_clean()
        return self._errors

点击._errors进入forms.py文件中

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=data or {}
        self.files=files or {}
        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

       
        # 默认值为None
        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)

返回def errors(self)

@property
    def errors(self):
        "Returns an ErrorDict for the data provided for the form"
        if self._errors is None:
            self.full_clean()  # 这个方法才是真正帮忙执行效验操作
        return self._errors

点击full_clean方法

def full_clean(self):
        """
        Cleans all of self.data and populates 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._clean_fields()进入

def _clean_fields(self):
        for name, field in self.fields.items():
              # self.fields：类似一个字典
              #for name, field in self.fields.items():解释分别获取self.fields的键和值分别赋值给 name, field
            # 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:  #   field.clean(value) 之后Dbug运行检查，为循环判断错误
                    value=field.clean(value)
                self.cleaned_data[name]=value
                if hasattr(self, 'clean_%s' % name):
                    value=getattr(self, 'clean_%s' % name)()
                    self.cleaned_data[name]=value
            except ValidationError as e:
                self.add_error(name, e)

#科技##python##一起学python##Python 语言##Python入门推荐#

单的工作过程

表单的信息发送与处理过程可以简单的进行图示，如下图。

以注册会员为例，用户在自己的电脑上打开相应的注册表单页面填写信息，完成填写后点击提交按钮，也就是图中1所示过程。

这时浏览器会将这些信息发送给处理这些信息的服务器，服务器上有使用类似asp或php写成的相应的处理程序，处理完成后，生成一个反馈信息，也就是2到3的过程。

然后服务器将处理后的信息发送给个人电脑，个人电脑在浏览器上通过一个新页面来提示用户处理结果。

这里就涉及到一个问题，一个网站会有针对不同用户的信息注册表单以及相应的信息处理程序，比如我们注册头条号就有"个人"、"企业"、"媒体"和"国家机构"的区分。如何使不同的表单找到相应的处理程序呢？在<form>标签中，有一个action属性就是为这个表单信息指定处理程序的。

<form>中的action属性

调用程序

<form>的action属性实际上就是为表单提示处理程序所在的路径，如果程序和页面在一个服务器中存储，那使用相对路径即可，如果在其他服务器，则要使用绝对路径。示例代码如下：

<form action="form_action.asp" method="get">
<p>First name: <input type="text" name="fname" /></p> 
<p>Last name: <input type="text" name="lname" /></p> 
<input type="submit" value="Submit" />
</form>

这段代码中的"form_action.asp"程序和这个表单页面在一个文件夹中，故直接写名称即可调用。

发送邮件

action属性除了调用程序外，也可以发送邮件，示例代码如下：

<form action="MAILTO:someone@w3school.com.cn" method="post" enctype="text/plain">
<h3>这个表单会把电子邮件发送到 W3School。</h3>
姓名：<br />
<input type="text" name="name" value="yourname" size="20"><br />
电邮：<br /><input type="text" name="mail" value="yourmail" size="20"><br />
内容：<br /><input type="text" name="comment" value="yourcomment" size="40"><br /><br />
<input type="submit" value="发送">
<input type="reset" value="重置">
</form>

这段代码中。发送邮件的写法是这样的：action="MAILTO:someone@w3school.com.cn"，通过MAILTO:告诉浏览器，这里要发送邮件！然后输入相应的邮箱地址，这样就会把表单中的信息以邮件的形式发送到相应的邮箱中了。

大家可以把邮箱地址改成自己的邮箱试一下，浏览器会让大家选择发送邮件的程序。如图所示：

使用这个功能我们可以写一个简单的邮件发送页面，示例代码如下：

<form action="mailto:yourname@domain.com" method="post" enctype="text/plain">
主题：<input name="subject" type="text"><br>
抄送：<input name="cc" type="text"><br>
密送：<input name="bcc" type="text"><br>
正文：<textarea name="body"></textarea><br>
<input type="submit">
</form>

这样的写法大家可能会发现问题，即如果一个网站注册用户超过100人以后，靠这种手动输入用户邮箱的方法发送邮件简直就是折磨人啊！

实际上，在网站中，我们会把会员或注册用户的邮箱存在数据库中，通过调用数据库中的用户邮箱的程序语句来替换action中的具体邮箱地址即可，再通过程序，可以针对全部用户或部分用户进行群发信息。

其中，enctype属性是向服务器声明上传信息的形式，也就是向服务器说明发送的数据到底是数字还是英文还是中文还是编程语句。专业一些的说法是"规定在发送表单数据之前如何对其进行编码。"

全部属性值有三个，如图所示，大家可以简要理解一下。

除此之外，我们还发现一个属性叫做method（方法），通过上面的示例代码可知，method属性有两个属性值，一个是get一个是post，这是什么意思呢？

信息上传的两种方法

<form>中的method标签即为表单信息指定相应的发送方法。

方法有两种，一种叫get，这种方法通常用来发送简短的且低安全要求的信息，特点是速度比较快。

post经常用来发送体积较大的信息，如果发送一些对安全性要求高的信息，html的官方说明中建议使用post方法。

我个人认为，现阶段大家能记住这两个方法的主要特点即可。这一篇的内容实际上也是前端学习者对服务器端的运行的了解内容。

下面为大家附上更为专业的讲解，看不懂也没关系，尽量读，至少能被专业词汇洗礼一下!

method 属性

浏览器使用 method 属性设置的方法将表单中的数据传送给服务器进行处理。共有两种方法：POST 方法和 GET 方法。

如果采用 POST 方法，浏览器将会按照下面两步来发送数据。首先，浏览器将与 action 属性中指定的表单处理服务器建立联系，一旦建立连接之后，浏览器就会按分段传输的方法将数据发送给服务器。

在服务器端，一旦 POST 样式的应用程序开始执行时，就应该从一个标志位置读取参数，而一旦读到参数，在应用程序能够使用这些表单值以前，必须对这些参数进行解码。用户特定的服务器会明确指定应用程序应该如何接受这些参数。

另一种情况是采用 GET 方法，这时浏览器会与表单处理服务器建立连接，然后直接在一个传输步骤中发送所有的表单数据：浏览器会将数据直接附在表单的 action URL 之后。这两者之间用问号进行分隔。

一般浏览器通过上述任何一种方法都可以传输表单信息，而有些服务器只接受其中一种方法提供的数据。可以在 <form> 标签的 method （方法）属性中指明表单处理服务器要用方法来处理数据，使 POST 还是 GET。

POST 还是 GET？

如果表单处理服务器既支持 POST 方法又支持 GET 方法，那么你该选择哪种方法呢？下面是有关这方面的一些规律：

如果希望获得最佳表单传输性能，可以采用 GET 方法发送只有少数简短字段的小表单。

一些服务器操作系统在处理可以立即传递给应用程序的命令行参数时，会限制其数目和长度，在这种情况下，对那些有许多字段或是很长的文本域的表单来说，就应该采用 POST 方法来发送。

如果你在编写服务器端的表单处理应用程序方面经验不足，应该选择 GET 方法。如果采用 POST 方法，就要在读取和解码方法做些额外的工作，也许这并不很难，但是也许你不太愿意去处理这些问题。

如果安全性是个问题，那么我们建议选用 POST 方法。GET 方法将表单参数直接放在应用程序的 URL 中，这样网络窥探者可以很轻松地捕获它们，还可以从服务器的日志文件中进行摘录。如果参数中包含了信用卡帐号这样的敏感信息，就会在不知不觉中危及用户的安全。而 POST 应用程序就没有安全方面的漏洞，在将参数作为单独的事务传输给服务器进行处理时，至少还可以采用加密的方法。

如果想在表单之外调用服务器端的应用程序，而且包括向其传递参数的过程，就要采用 GET 方法，因为该方法允许把表单这样的参数包括进来作为 URL 的一部分。而另一方面，使用 POST 样式的应用程序却希望在 URL 后还能有一个来自浏览器额外的传输过程，其中传输的内容不能作为传统 <a> 标签的内容。

以上内容来自W3school

今天的内容结束了，这一篇内容实践的东西比较少，主要是阅读与了解。

至此，HTML表单部分的讲解就算告于段落了，如果您有任何疑问请给我留言，如有问题或错误请予以斧正！

如果您喜欢我的教程请关注我，点赞也能让我充满动力！

HTML完整学习目录

HTML序章（学习目的、对象、基本概念）——零基础自学网页制作

HTML是什么？——零基础自学网页制作

第一个HTML页面如何写？——零基础自学网页制作

HTML页面中head标签有啥用？——零基础自学网页制作

初识meta标签与SEO——零基础自学网页制作

HTML中的元素使用方法1——零基础自学网页制作

HTML中的元素使用方法2——零基础自学网页制作

HTML元素中的属性1——零基础自学网页制作

HTML元素中的属性2（路径详解）——零基础自学网页制作

使用HTML添加表格1（基本元素）——零基础自学网页制作

使用HTML添加表格2（表格头部与脚部）——零基础自学网页制作

使用HTML添加表格3（间距与颜色）——零基础自学网页制作

使用HTML添加表格4（行颜色与表格嵌套）——零基础自学网页制作

16进制颜色表示与RGB色彩模型——零基础自学网页制作

HTML中的块级元素与内联元素——零基础自学网页制作

初识HTML中的<div>块元素——零基础自学网页制作

在HTML页面中嵌入其他页面的方法——零基础自学网页制作

封闭在家学网页制作！为页面嵌入PDF文件——零基础自学网页制作

HTML表单元素初识1——零基础自学网页制作

HTML表单元素初识2——零基础自学网页制作

HTML表单3（下拉列表、多行文字输入）——零基础自学网页制作

HTML表单4（form的action、method属性）——零基础自学网页制作

HTML列表制作讲解——零基础自学网页制作

为HTML页面添加视频、音频的方法——零基础自学网页制作

音视频格式转换神器与html视频元素加字幕——零基础自学网页制作

HTML中使用<a>标签实现文本内链接——零基础自学网页制作

个表单的form标签是必不可少的，所有的表单元素都应该被他包含。一个页面可能有多个表单，就需要对每个表单的区域进行分组，防止表单信息混杂。

目标

表单的完整结构？
表单内如何进行元素分组？

表单

可以在一个网页中收集用户的数据，比如填写用户注册数据、留言板、评论等内容。

Form标签

一个表单的form标签是必不可少的，所有的表单元素都应该被他包含。

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

一个网页可能会有多个表单，就需要声明每个表单的区域，防止表单信息混杂。

以下就是两个表单，他们之间的表单元素就会跟随自己的表单。

两个表单

分组

有时候，表单内的元素过多，就需要将他们进行分类。

fieldset标签可以将表单内的相关元素分组。

legend标签是为 fieldset元素定义标题。

<fieldset >
	<legend>学生信息</legend>
	姓名：<input type="text" /><br>
	班级：<input type="text" /><br>			
</fieldset>

分组

分组完成

总结

思维导图

在线咨询

上一篇：怎样使用requests模块抓取网页？
下一篇：Python 爬虫正则表达式和re库，及re库的基本

您的项目需求

*请认真填写需求信息，我们会在24小时内与您取得联系。

整合营销服务商