一个 Form 实例要么是 绑定 到一组数据，要么是 未绑定。
如果是 绑定 了一组数据，它就能够验证这些数据，并将表单渲染成 HTML，并在 HTML 中显示数据。
如果是 未绑定，它就不能进行验证（因为没有数据可验证！），但它仍然可以将空白表单渲染为 HTML。
要创建一个未绑定的 Form 实例，实例化类：
>>> f = ContactForm()\n要将数据绑定到表单中，将数据以字典的形式传递给你的 Form 类构造函数的第一个参数：
>>> data = {'subject': 'hello',\n... 'message': 'Hi there',\n... 'sender': 'foo@example.com',\n... 'cc_myself': True}\n>>> f = ContactForm(data)\n在这个字典中，键是字段名，对应于 Form 类中的属性。值是你要验证的数据。这些数据通常是字符串，但不要求它们是字符串；你传递的数据类型取决于 Field，我们稍后会看到。
如果你需要在运行时区分绑定和未绑定的表单实例，请检查表单的 is_bound 属性的值：
>>> f = ContactForm()\n>>> f.is_bound\nFalse\n>>> f = ContactForm({'subject': 'hello'})\n>>> f.is_bound\nTrue\n需要注意的是，传递一个空的字典会创建一个空数据的 绑定 表单：
\n>>> f = ContactForm({})\n>>> f.is_bound\nTrue\n如果你有一个绑定的 Form 实例，并想以某种方式改变数据，或者你想将一个未绑定的 Form 实例绑定到一些数据，请创建另一个 Form 实例。没有办法改变一个 Form 实例中的数据。一旦创建了一个 Form 实例，你应该认为它的数据是不可改变的，不管它是否有数据。
当你必须为相互依赖的字段添加自定义验证时，在你的 Form 上实现一个 clean() 方法。参见 清理和验证相互依赖的字段 的用法示例。
Form 对象的主要任务是验证数据。有了一个绑定的 Form 实例，调用 is_valid() 方法来运行验证，并返回一个布尔值，指定数据是否有效：
>>> data = {'subject': 'hello',\n... 'message': 'Hi there',\n... 'sender': 'foo@example.com',\n... 'cc_myself': True}\n>>> f = ContactForm(data)\n>>> f.is_valid()\nTrue\n让我们用一些无效的数据试试。在这种情况下，subject 是空白的（这是一个错误，因为所有的字段都是默认的），sender 不是一个有效的电子邮件地址：
>>> data = {'subject': '',\n... 'message': 'Hi there',\n... 'sender': 'invalid email address',\n... 'cc_myself': True}\n>>> f = ContactForm(data)\n>>> f.is_valid()\nFalse\n访问 errors 属性来获取错误信息的字典：
>>> f.errors\n{'sender': ['Enter a valid email address.'], 'subject': ['This field is required.']}\n在这个字典中，键是字段名，值是代表错误信息的字符串列表。错误信息存储在列表中，因为一个字段可以有多个错误信息。
\n你可以访问 errors，而不必先调用 is_valid()。无论是调用 is_valid() 还是访问 errors，表单的数据都会首先被验证。
验证例程只会被调用一次，无论你访问 errors 或调用 is_valid() 多少次。这意味着，如果验证有副作用，这些副作用将只被触发一次。
返回一个 dict，将字段映射到它们的原始 ValidationError 实例。
>>> f.errors.as_data()\n{'sender': [ValidationError(['Enter a valid email address.'])],\n'subject': [ValidationError(['This field is required.'])]}\n当你需要通过错误 code 来识别错误时，请使用此方法。这样就可以在给定的错误出现时，重写错误信息或在视图中编写自定义逻辑。它还可以用来以自定义格式（如 XML）将错误序列化；例如， as_json() 依赖于 as_data()。
需要使用 as_data() 方法是由于向后兼容性。以前，ValidationError 实例一旦被添加到 Form.errors 字典中，其 渲染的 错误信息就会丢失。理想情况下，Form.errors 会存储 ValidationError 实例，并且带有 as_ 前缀的方法可以渲染它们，但为了不破坏那些期望在 Form.errors 中渲染错误信息的代码，必须反过来做。
返回以 JSON 格式序列化的错误。
\n>>> f.errors.as_json()\n{"sender": [{"message": "Enter a valid email address.", "code": "invalid"}],\n"subject": [{"message": "This field is required.", "code": "required"}]}\n默认情况下，as_json() 不会转义其输出。如果你使用它来处理类似 AJAX 请求的表单视图，客户端解释响应并将错误插入到页面中，你会希望确保在客户端转义结果，以避免跨站点脚本攻击的可能性。你可以在 JavaScript 中使用 element.textContent = errorText 或者使用 jQuery 的 $(el).text(errorText) （而不是它的 .html() 函数）来实现。
如果出于某些原因你不想使用客户端转义，你也可以设置 escape_html=True，错误信息将被转义，这样你就可以直接在 HTML 中使用它们。
Form. errors.as_json() 将返回序列化的 JSON，而这个则是返回序列化之前的错误数据。
escape_html 参数的行为如 Form.errors.as_json() 中所述。
该方法允许在 Form.clean() 方法中添加错误到特定字段，或者从表单外部添加错误，例如从视图中添加。
field 参数是应该添加错误的字段名。如果它的值是 None，错误将被视为非字段错误，就像 Form.non_field_errors() 返回的那样。
error 参数可以是一个字符串，或者最好是 ValidationError 的实例。关于定义表单错误的最佳做法，请参见 引发 ValidationError。
注意，Form.add_error() 会自动从 cleaned_data 中删除相关字段。
本方法返回一个布尔值，表示一个字段是否有特定错误 code 的错误。如果 code 是 None，如果字段包含任何错误，它将返回 True。
要检查非字段错误，使用 NON_FIELD_ERRORS 作为 field 参数。
这个方法从 Form.errors 中返回没有与特定字段关联的错误列表。这包括在 Form.clean() 中引发的 ValidationError 和使用 Form.add_error(None, "...") 添加的错误。
在没有数据的情况下验证表单是没有意义的，但是，记录一下，以下是未绑定表单的情况：
\n>>> f = ContactForm()\n>>> f.is_valid()\nFalse\n>>> f.errors\n{}\n使用 initial 在运行时声明表单字段的初始值。例如，你可能想用当前会话的用户名来填写 username 字段。
要实现这一目标，请使用 initial 参数到 Form。如果给定这个参数，它应该是一个将字段名映射到初始值的字典。只包含你要指定初始值的字段，没有必要包含表单中的每个字段。例如：
>>> f = ContactForm(initial={'subject': 'Hi there!'})\n这些值只对未绑定的表单显示，如果没有提供特定的值，它们不会被用作后备值。
\n如果一个 Field 定义了 initial 并且 你在实例化 Form 时包含了 initial，那么后者 initial 将具有优先权。在这个例子中，initial 既在字段级别又在表单实例级别提供，后者具有优先权：
>>> from django import forms\n>>> class CommentForm(forms.Form):\n... name = forms.CharField(initial='class')\n... url = forms.URLField()\n... comment = forms.CharField()\n>>> f = CommentForm(initial={'name': 'instance'}, auto_id=False)\n>>> print(f)\n<tr><th>Name:</th><td><input type="text" name="name" value="instance" required></td></tr>\n<tr><th>Url:</th><td><input type="url" name="url" required></td></tr>\n<tr><th>Comment:</th><td><input type="text" name="comment" required></td></tr>\n返回一个表单字段的初始数据。如果存在的话，它从 Form.initial 检索数据，否则尝试 Field.initial。可调用的值将被执行。
我们推荐使用 BoundField.initial 而不是 get_initial_for_field() 因为 BoundField.initial 有一个更简单的接口。另外，不像 get_initial_for_field()， BoundField.initial 会缓存它的值。这在处理返回值是可能改变的可调用对象时尤其有用（例如，datetime.now 或 uuid.uuid4）：
>>> import uuid\n>>> class UUIDCommentForm(CommentForm):\n... identifier = forms.UUIDField(initial=uuid.uuid4)\n>>> f = UUIDCommentForm()\n>>> f.get_initial_for_field(f.fields['identifier'], 'identifier')\nUUID('972ca9e4-7bfe-4f5b-af7d-07b3aa306334')\n>>> f.get_initial_for_field(f.fields['identifier'], 'identifier')\nUUID('1b411fab-844e-4dec-bd4f-e9b0495f04d0')\n>>> # Using BoundField.initial, for comparison\n>>> f['identifier'].initial\nUUID('28a09c59-5f00-4ed9-9179-a3b074fa9c30')\n>>> f['identifier'].initial\nUUID('28a09c59-5f00-4ed9-9179-a3b074fa9c30')\n当你需要检查表单数据是否与初始数据发生变化时，请使用 has_changed() 方法。
>>> data = {'subject': 'hello',\n... 'message': 'Hi there',\n... 'sender': 'foo@example.com',\n... 'cc_myself': True}\n>>> f = ContactForm(data, initial=data)\n>>> f.has_changed()\nFalse\n当表单提交后，我们会重新构建表单，并提供原始数据，以便进行对比。
\n>>> f = ContactForm(request.POST, initial=data)\n>>> f.has_changed()\n如果来自 request.POST 的数据与 initial 中提供的数据不同，那么 has_changed() 将为 True，否则为 False。结果是通过调用 Field.has_changed() 对表单中的每个字段进行计算。
changed_data 属性返回表单绑定数据（通常是 request.POST）中与 initial 中提供的数据不同的字段名列表。如果没有不同的数据，则返回一个空列表。
>>> f = ContactForm(request.POST, initial=data)\n>>> if f.has_changed():\n... print("The following fields changed: %s" % ", ".join(f.changed_data))\n>>> f.changed_data\n['subject', 'message']\n你可以从 Form 实例的 fields 属性中访问其字段：
>>> for row in f.fields.values(): print(row)\n...\n<django.forms.fields.CharField object at 0x7ffaac632510>\n<django.forms.fields.URLField object at 0x7ffaac632f90>\n<django.forms.fields.CharField object at 0x7ffaac3aa050>\n>>> f.fields['name']\n<django.forms.fields.CharField object at 0x7ffaac6324d0>\n你可以改变 Form 实例的字段，以改变它在表单中的显示方式：
>>> f.as_table().split('\\n')[0]\n'<tr><th>Name:</th><td><input name="name" type="text" value="instance" required></td></tr>'\n>>> f.fields['name'].label = "Username"\n>>> f.as_table().split('\\n')[0]\n'<tr><th>Username:</th><td><input name="name" type="text" value="instance" required></td></tr>'\n请注意不要修改 base_fields 属性，因为这个修改会影响同一 Python 进程中所有后续的 ContactForm 实例：
>>> f.base_fields['name'].label = "Username"\n>>> another_f = CommentForm(auto_id=False)\n>>> another_f.as_table().split('\\n')[0]\n'<tr><th>Username:</th><td><input name="name" type="text" value="class" required></td></tr>'\nForm 类中的每个字段不仅负责验证数据，还负责“清理”数据——将其规范为一致的格式。这是一个很好的功能，因为它允许以各种方式输入特定字段的数据，并总是产生一致的输出。
例如， DateField 将输入规范化为 Python 的 datetime.date 对象。无论你传递给它的是格式为 '1994-07-15' 的字符串，还是 datetime.date 对象，或者其他一些格式，只要它是有效的，DateField 都会将它规范化为 datetime.date 对象。
当你用一组数据创建了一个 Form 实例并对其进行验证后，你就可以通过它的 cleaned_data 属性来访问干净的数据：
>>> data = {'subject': 'hello',\n... 'message': 'Hi there',\n... 'sender': 'foo@example.com',\n... 'cc_myself': True}\n>>> f = ContactForm(data)\n>>> f.is_valid()\nTrue\n>>> f.cleaned_data\n{'cc_myself': True, 'message': 'Hi there', 'sender': 'foo@example.com', 'subject': 'hello'}\n请注意，任何基于文本的字段——如 CharField 或 EmailField——总是将输入清理成一个字符串。我们将在本文档后面介绍编码的含义。
如果你的数据 没有 验证，cleaned_data 字典只包含有效字段：
>>> data = {'subject': '',\n... 'message': 'Hi there',\n... 'sender': 'invalid email address',\n... 'cc_myself': True}\n>>> f = ContactForm(data)\n>>> f.is_valid()\nFalse\n>>> f.cleaned_data\n{'cc_myself': True, 'message': 'Hi there'}\ncleaned_data 总是只包含 Form 中定义的字段的键，即使你在定义 Form 时传递了额外的数据。在这个例子中，我们传递了一堆额外的字段给 ContactForm 构造函数，但是 cleaned_data 只包含了表单的字段：
>>> data = {'subject': 'hello',\n... 'message': 'Hi there',\n... 'sender': 'foo@example.com',\n... 'cc_myself': True,\n... 'extra_field_1': 'foo',\n... 'extra_field_2': 'bar',\n... 'extra_field_3': 'baz'}\n>>> f = ContactForm(data)\n>>> f.is_valid()\nTrue\n>>> f.cleaned_data # Doesn't contain extra_field_1, etc.\n{'cc_myself': True, 'message': 'Hi there', 'sender': 'foo@example.com', 'subject': 'hello'}\n当 Form 有效时，cleaned_data 将包括 所有 字段的键和值，即使数据没有包括一些可选字段的值。在这个例子中，数据字典没有包含 nick_name 字段的值，但 cleaned_data 包含了它，并使用一个空值：
>>> from django import forms\n>>> class OptionalPersonForm(forms.Form):\n... first_name = forms.CharField()\n... last_name = forms.CharField()\n... nick_name = forms.CharField(required=False)\n>>> data = {'first_name': 'John', 'last_name': 'Lennon'}\n>>> f = OptionalPersonForm(data)\n>>> f.is_valid()\nTrue\n>>> f.cleaned_data\n{'nick_name': '', 'first_name': 'John', 'last_name': 'Lennon'}\n在上面这个例子中，nick_name 的 cleaned_data 值被设置为一个空字符串，因为 nick_name 是 CharField，而 CharField 将空值视为空字符串。每个字段类型都知道它的“空”值是什么——例如，对于 DateField，它是 None 而不是空字符串。关于每个字段在这种情况下的行为的全部细节，请参阅下面“内置 Field 类”一节中每个字段的“空值”说明。
你可以编写代码来对特定的表单字段（基于其名称）或整个表单（考虑各种字段的组合）进行验证。更多关于这方面的信息请参见 表单和字段验证。
\nForm 对象的第二个任务是将其本身渲染为 HTML。为此，print 对象：
>>> f = ContactForm()\n>>> print(f)\n<tr><th><label for="id_subject">Subject:</label></th><td><input id="id_subject" type="text" name="subject" maxlength="100" required></td></tr>\n<tr><th><label for="id_message">Message:</label></th><td><input type="text" name="message" id="id_message" required></td></tr>\n<tr><th><label for="id_sender">Sender:</label></th><td><input type="email" name="sender" id="id_sender" required></td></tr>\n<tr><th><label for="id_cc_myself">Cc myself:</label></th><td><input type="checkbox" name="cc_myself" id="id_cc_myself"></td></tr>\n如果表单与数据绑定，HTML 输出将适当地包含该数据。例如，如果一个字段用 <input type="text"> 表示，数据将在 value 属性中。如果一个字段用 <input type="checkbox"> 表示，那么 HTML 将适当地包括 checked：
>>> data = {'subject': 'hello',\n... 'message': 'Hi there',\n... 'sender': 'foo@example.com',\n... 'cc_myself': True}\n>>> f = ContactForm(data)\n>>> print(f)\n<tr><th><label for="id_subject">Subject:</label></th><td><input id="id_subject" type="text" name="subject" maxlength="100" value="hello" required></td></tr>\n<tr><th><label for="id_message">Message:</label></th><td><input type="text" name="message" id="id_message" value="Hi there" required></td></tr>\n<tr><th><label for="id_sender">Sender:</label></th><td><input type="email" name="sender" id="id_sender" value="foo@example.com" required></td></tr>\n<tr><th><label for="id_cc_myself">Cc myself:</label></th><td><input type="checkbox" name="cc_myself" id="id_cc_myself" checked></td></tr>\n这个默认输出是一个两列的 HTML 表单，每个字段都有一个 <tr>。请注意以下几点：
为灵活起见，输出 不 包括 <table> 和 </table> 标签，也不包括 <form> 和 </form> 标签或 <input type="submit"> 标签。这是你的工作。
每个字段类型都有一个默认的 HTML 表示。CharField 用 <input type="text"> 表示，EmailField 用 <input type="email"> 表示。BooleanField(null=False) 由一个 <input type="checkbox">。请注意，这些只是合理的默认值；你可以通过使用部件来指定一个给定字段使用的 HTML，我们将在后面解释。
每个标签的 HTML name 直接从 ContactForm 类中的属性名中提取。
每个字段的文本标签——例如 'Subject:'、'Message:' 和 'Cc myself:'，是根据字段名将所有下划线转换为空格并将第一个字母大写而产生的。同样，请注意这些只是合理的默认值；你也可以手动指定标签。
每个文本标签都被一个 HTML <label> 标签包围，该标签通过其 id 指向相应的表格字段。而它的 id 则是通过在字段名前加上 'id_' 生成的。id 属性和 <label> 标签默认包含在输出中，以遵循最佳实践，但你可以改变这种行为。
输出使用 HTML5 语法，目标是 <!DOCTYPE html>。例如，它使用布尔属性，如 checked 而不是 XHTML 风格的 checked='checked'。
虽然当你 print 表单时，<table> 输出是默认的输出样式，但还有其他的输出样式。每种样式都可以作为表单对象的一个方法，每个渲染方法都返回一个字符串。
template_nameLink to this heading#模板的名称，如果表单被转换成字符串，例如通过 print(form) 或者通过 {{form }} 在模板中被呈现。默认情况下，这个模板是 'django/forms/default.html'，它是 'django/forms/table.html' 的一个代理。模板可以通过覆盖 template_name 属性来改变每个表单，或者更广泛地通过覆盖默认模板来改变，参见 覆盖内置表单模板。
template_name_labelLink to this heading#用于渲染字段的模板 <label>，在调用 BoundField.label_tag() 时使用。可以通过覆盖这个属性来改变每个表单，或者更广泛地通过覆盖默认模板来改变，也可以参见 覆盖内置表单模板。
as_p()Link to this heading#as_p() 使用分配给表单 template_name_p 属性的模板渲染表单，默认这个模板是 'django/forms/p.html'。这个模板将表单渲染成一系列的 <p> 标签，每个 <p> 包含一个字段：
>>> f = ContactForm()\n>>> f.as_p()\n'<p><label for="id_subject">Subject:</label> <input id="id_subject" type="text" name="subject" maxlength="100" required></p>\\n<p><label for="id_message">Message:</label> <input type="text" name="message" id="id_message" required></p>\\n<p><label for="id_sender">Sender:</label> <input type="text" name="sender" id="id_sender" required></p>\\n<p><label for="id_cc_myself">Cc myself:</label> <input type="checkbox" name="cc_myself" id="id_cc_myself"></p>'\n>>> print(f.as_p())\n<p><label for="id_subject">Subject:</label> <input id="id_subject" type="text" name="subject" maxlength="100" required></p>\n<p><label for="id_message">Message:</label> <input type="text" name="message" id="id_message" required></p>\n<p><label for="id_sender">Sender:</label> <input type="email" name="sender" id="id_sender" required></p>\n<p><label for="id_cc_myself">Cc myself:</label> <input type="checkbox" name="cc_myself" id="id_cc_myself"></p>\nas_ul()Link to this heading#as_ul() 使用分配给表单 template_name_ul 属性的模板渲染表单，默认这个模板是 'django/forms/ul.html'。这个模板将表单渲染成一系列的 <li> 标签，每个 <li> 包含一个字段。它 不 包括 <ul> 或 </ul>，这样你就可以在 <ul> 上指定任何 HTML 属性，以获得灵活性：
>>> f = ContactForm()\n>>> f.as_ul()\n'<li><label for="id_subject">Subject:</label> <input id="id_subject" type="text" name="subject" maxlength="100" required></li>\\n<li><label for="id_message">Message:</label> <input type="text" name="message" id="id_message" required></li>\\n<li><label for="id_sender">Sender:</label> <input type="email" name="sender" id="id_sender" required></li>\\n<li><label for="id_cc_myself">Cc myself:</label> <input type="checkbox" name="cc_myself" id="id_cc_myself"></li>'\n>>> print(f.as_ul())\n<li><label for="id_subject">Subject:</label> <input id="id_subject" type="text" name="subject" maxlength="100" required></li>\n<li><label for="id_message">Message:</label> <input type="text" name="message" id="id_message" required></li>\n<li><label for="id_sender">Sender:</label> <input type="email" name="sender" id="id_sender" required></li>\n<li><label for="id_cc_myself">Cc myself:</label> <input type="checkbox" name="cc_myself" id="id_cc_myself"></li>\nas_table()Link to this heading#最后，as_table() 使用分配给表单 template_name_table 属性的模板渲染表单，默认这个模板是 'django/forms/table.html'。该模板将表单输出为HTML <table> ：
>>> f = ContactForm()\n>>> f.as_table()\n'<tr><th><label for="id_subject">Subject:</label></th><td><input id="id_subject" type="text" name="subject" maxlength="100" required></td></tr>\\n<tr><th><label for="id_message">Message:</label></th><td><input type="text" name="message" id="id_message" required></td></tr>\\n<tr><th><label for="id_sender">Sender:</label></th><td><input type="email" name="sender" id="id_sender" required></td></tr>\\n<tr><th><label for="id_cc_myself">Cc myself:</label></th><td><input type="checkbox" name="cc_myself" id="id_cc_myself"></td></tr>'\n>>> print(f)\n<tr><th><label for="id_subject">Subject:</label></th><td><input id="id_subject" type="text" name="subject" maxlength="100" required></td></tr>\n<tr><th><label for="id_message">Message:</label></th><td><input type="text" name="message" id="id_message" required></td></tr>\n<tr><th><label for="id_sender">Sender:</label></th><td><input type="email" name="sender" id="id_sender" required></td></tr>\n<tr><th><label for="id_cc_myself">Cc myself:</label></th><td><input type="checkbox" name="cc_myself" id="id_cc_myself"></td></tr>\nget_context()Link to this heading#返回模板中表单渲染的上下文。
\n可用的上下文：
\nform: 绑定表单
fields： 所有绑定字段，除了隐藏字段。
·hidden_fields`： 所有隐藏的绑定字段。
errors： 所有与字段无关的或与隐藏字段有关的表单错误。
render()Link to this heading#渲染方法被 __str__ 以及 Form.as_table()、Form.as_p() 和 Form.as_ul() 方法调用。所有的参数都是可选的，默认为：
template_name： Form.template_name
context：由 Form.get_context() 返回的值
renderer： 由 Form.default_renderer 返回的值
对必填或有错误的表单行和字段进行样式设计是很常见的。例如，你可能想用粗体显示必填的表格行，用红色突出显示错误。
\nForm 类有几个钩子，你可以用来给必填行或有错误的行添加 class 属性：设置 Form.error_css_class 和／或 Form.required_css_class 属性：
from django import forms\n\nclass ContactForm(forms.Form):\n error_css_class = 'error'\n required_css_class = 'required'\n\n # ... and the rest of your fields here\n一旦你这样做了，根据需要，行将被赋予 "error" 和／或 "required" 类。HTML 将看起来像：
>>> f = ContactForm(data)\n>>> print(f.as_table())\n<tr class="required"><th><label class="required" for="id_subject">Subject:</label> ...\n<tr class="required"><th><label class="required" for="id_message">Message:</label> ...\n<tr class="required error"><th><label class="required" for="id_sender">Sender:</label> ...\n<tr><th><label for="id_cc_myself">Cc myself:<label> ...\n>>> f['subject'].label_tag()\n<label class="required" for="id_subject">Subject:</label>\n>>> f['subject'].label_tag(attrs={'class': 'foo'})\n<label for="id_subject" class="foo required">Subject:</label>\n指定 渲染器 用于表单的渲染。默认值为 None，表示使用 FORM_RENDERER 设置中指定的默认渲染器。
你可以在声明你的表单时将其设置为一个类属性，或者使用 Form.__init__() 的 renderer 参数。例如：
from django import forms\n\nclass MyForm(forms.Form):\n default_renderer = MyRenderer()\n或者：
\nform = MyForm(renderer=MyRenderer())\n在 as_p()、as_ul() 和 as_table() 快捷方式中，字段是按照你在表单类中定义的顺序显示的。例如，在 ContactForm 的例子中，字段是按照 subject、message、sender、cc_myself 的顺序定义的。要调整 HTML 输出的顺序，改变这些字段在类中的排列顺序。
还有其他几种方式可以自定义顺序：
\n默认情况下 Form.field_order=None，它保留了你在表单类中定义字段的顺序。如果 field_order 是一个字段名的列表，则字段按列表指定的顺序排列，其余字段按默认顺序追加。列表中未知的字段名将被忽略。这使得在子类中可以通过将字段设置为 None 来禁用字段，而不必重新定义排序。
你也可以使用 Form 的 Form.field_order 参数来覆盖字段顺序。如果一个 Form 定义了 field_order，并且 你在实例化 Form 时包含了 field_order，那么后者的 field_order 将具有优先权。
你可以在任何时候使用 order_fields() 对字段进行重新排列，字段名列表如 field_order。
如果你渲染一个绑定的 Form 对象，渲染行为将自动运行表单的验证，如果它还没有发生，HTML 输出将包括验证错误，作为字段附近的 <ul class="errorlist">。错误信息的具体位置取决于你使用的输出方法：
>>> data = {'subject': '',\n... 'message': 'Hi there',\n... 'sender': 'invalid email address',\n... 'cc_myself': True}\n>>> f = ContactForm(data, auto_id=False)\n>>> print(f.as_table())\n<tr><th>Subject:</th><td><ul class="errorlist"><li>This field is required.</li></ul><input type="text" name="subject" maxlength="100" required></td></tr>\n<tr><th>Message:</th><td><input type="text" name="message" value="Hi there" required></td></tr>\n<tr><th>Sender:</th><td><ul class="errorlist"><li>Enter a valid email address.</li></ul><input type="email" name="sender" value="invalid email address" required></td></tr>\n<tr><th>Cc myself:</th><td><input checked type="checkbox" name="cc_myself"></td></tr>\n>>> print(f.as_ul())\n<li><ul class="errorlist"><li>This field is required.</li></ul>Subject: <input type="text" name="subject" maxlength="100" required></li>\n<li>Message: <input type="text" name="message" value="Hi there" required></li>\n<li><ul class="errorlist"><li>Enter a valid email address.</li></ul>Sender: <input type="email" name="sender" value="invalid email address" required></li>\n<li>Cc myself: <input checked type="checkbox" name="cc_myself"></li>\n>>> print(f.as_p())\n<p><ul class="errorlist"><li>This field is required.</li></ul></p>\n<p>Subject: <input type="text" name="subject" maxlength="100" required></p>\n<p>Message: <input type="text" name="message" value="Hi there" required></p>\n<p><ul class="errorlist"><li>Enter a valid email address.</li></ul></p>\n<p>Sender: <input type="email" name="sender" value="invalid email address" required></p>\n<p>Cc myself: <input checked type="checkbox" name="cc_myself"></p>\n默认情况下，表单使用 django.forms.utils.ErrorList 来格式化验证错误。ErrorList 是一个类似列表的对象，其中 initlist 是错误列表。此外，这个类有以下属性和方法。
渲染错误列表时要使用的 CSS 类。任何提供的类将被添加到默认的 errorlist 类中。
指定 渲染器 用于 ErrorList。默认为 None，即使用由 FORM_RENDER 配置指定的默认渲染器。
调用 __str__ 或 render() 时使用的模板名称。默认情况下，这是 'django/forms/errors/list/default.html'，它是 'ul.html' 模板的代理。
调用 as_text() 时使用的模板名称。默认是 'django/forms/errors/list/text.html'。该模板将错误显示为一个列表，其中包含了一些要点。
调用 as_ul() 时使用的模板名称。默认情况下，这是 'django/forms/errors/list/ul.html'。这个模板在 <li> 标签中渲染错误，并使用 error_class 所定义的 CSS 类来包装 <ul>。
返回模板中渲染错误的上下文。
\n可用的上下文：
\nerrors： 一个错误列表。
error_class：一个 CSS 类的字符串。
渲染方法被 __str__ 以及 as_ul() 方法所调用。
所有参数都是可选的，将默认为：
\ntemplate_name：由 template_name 返回的值。
context： 由 get_context() 返回的值
renderer： 由 renderer 返回的值
使用由 template_name_text 定义的模板渲染错误列表。
使用由 template_name_ul 定义的模板渲染错误列表。
如果你想自定义错误的渲染，这可以通过覆盖 template_name 属性来实现，或者更普遍地通过覆盖默认模板来实现，也可以参见 覆盖内置表单模板。
as_p()、as_ul() 和 as_table() 方法都是快捷方式——它们并不是显示表单对象的唯一方式。
用于显示 Form 实例的单个字段的 HTML 或访问属性。
该对象的 __str__() 方法显示该字段的 HTML。
要检索一个单一的 BoundField，在你的表单中使用字典查询语法，使用字段名作为键：
>>> form = ContactForm()\n>>> print(form['subject'])\n<input id="id_subject" type="text" name="subject" maxlength="100" required>\n要检索所有的 BoundField 对象，请迭代表单：
>>> form = ContactForm()\n>>> for boundfield in form: print(boundfield)\n<input id="id_subject" type="text" name="subject" maxlength="100" required>\n<input type="text" name="message" id="id_message" required>\n<input type="email" name="sender" id="id_sender" required>\n<input type="checkbox" name="cc_myself" id="id_cc_myself">\n特定字段的输出尊重表单对象的 auto_id 设置：
>>> f = ContactForm(auto_id=False)\n>>> print(f['message'])\n<input type="text" name="message" required>\n>>> f = ContactForm(auto_id='id_%s')\n>>> print(f['message'])\n<input type="text" name="message" id="id_message" required>\nBoundField 的属性Link to this heading#BoundField 的 HTML ID 属性。如果 Form.auto_id 是 False，则返回一个空字符串。
此属性返回由部件的 value_from_datadict() 方法提取的此 BoundField 的数据，如果没有给定则返回 None。
>>> unbound_form = ContactForm()\n>>> print(unbound_form['subject'].data)\nNone\n>>> bound_form = ContactForm(data={'subject': 'My Subject'})\n>>> print(bound_form['subject'].data)\nMy Subject\n一个 类似列表的对象，打印时显示为 HTML <ul class="errorlist">：
>>> data = {'subject': 'hi', 'message': '', 'sender': '', 'cc_myself': ''}\n>>> f = ContactForm(data, auto_id=False)\n>>> print(f['message'])\n<input type="text" name="message" required>\n>>> f['message'].errors\n['This field is required.']\n>>> print(f['message'].errors)\n<ul class="errorlist"><li>This field is required.</li></ul>\n>>> f['subject'].errors\n[]\n>>> print(f['subject'].errors)\n\n>>> str(f['subject'].errors)\n''\n这个 Field 封装的表单类中的表单 BoundField 实例。
这个 Form 实例与这个 BoundField 绑定。
字段的 help_text。
部件的 HTML name 属性中使用的名称。它考虑到了 prefix 的形式。
使用这个属性来渲染这个字段的 ID。例如，如果你在你的模板中手动构建一个 <label> （尽管事实上 label_tag() 将为你做这件事）：
<label for="{{ form.my_field.id_for_label }}">...</label>{{ my_field }}\n默认情况下，这将是字段的名称，前缀为 id_ （上面的例子为 "id_my_field"）。你可以通过设置 attrs 对字段的部件进行修改。例如，声明一个字段是这样的：
my_field = forms.CharField(widget=forms.TextInput(attrs={'id': 'myFIELD'}))\n并使用上面的模板，会呈现出这样的效果：
\n<label for="myFIELD">...</label><input id="myFIELD" type="text" name="my_field" required>\n使用 BoundField.initial 来检索一个表单字段的初始数据。如果存在，它从 Form.initial 检索数据，否则尝试 Field.initial。值为可调用对象将被执行。参见 初始表单值 获取更多的例子。
BoundField.initial 缓存了它的返回值，这在处理返回值可能改变的可调用对象时特别有用（例如 datetime.now 或 uuid.uuid4）：
>>> from datetime import datetime\n>>> class DatedCommentForm(CommentForm):\n... created = forms.DateTimeField(initial=datetime.now)\n>>> f = DatedCommentForm()\n>>> f['created'].initial\ndatetime.datetime(2021, 7, 27, 9, 5, 54)\n>>> f['created'].initial\ndatetime.datetime(2021, 7, 27, 9, 5, 54)\n建议使用 BoundField.initial 而不是 get_initial_for_field()。
如果这个 BoundField 的部件被隐藏，返回 True。
字段的 label。这在 label_tag() 中使用。
表单中该字段的名称：
\n>>> f = ContactForm()\n>>> print(f['subject'].name)\nsubject\n>>> print(f['message'].name)\nmessage\n返回包装字段的部件的小写类名，去掉后面的 input 或 widget。当构建表单时，布局取决于组件的类型时，可以使用这个方法。例如：
{% for field in form %}\n {% if field.widget_type == 'checkbox' %}\n # render one way\n {% else %}\n # render another way\n {% endif %}\n{% endfor %}\nBoundField 方法Link to this heading#返回将其表示为 <input type="hidden"> 的 HTML 字符串。
**kwargs 传递给 as_widget()。
这个方法主要在内部使用。你应该使用部件来代替。
\n通过渲染通过的部件来渲染该字段，并添加作为 attrs 传递的任何 HTML 属性。 如果没有指定部件，那么将使用该字段的默认部件。
only_initial 是 Django 内部使用的，不应该明确设置。
当你使用 Django 的渲染快捷方式时，CSS 类被用来指示必填的表单字段或包含错误的字段。如果你是手动渲染表单，你可以使用 css_classes 方法访问这些 CSS 类：
>>> f = ContactForm(data={'message': ''})\n>>> f['message'].css_classes()\n'required'\n如果你想在可能需要的错误和必要的类之外提供一些额外的类，你可以提供这些类作为参数：
\n>>> f = ContactForm(data={'message': ''})\n>>> f['message'].css_classes('foo bar')\n'foo bar required'\n使用 Form.template_name_label 指定的模板，为表单字段渲染一个标签。
可用的上下文：
\nfield：这个 BoundField 的实例。
contents：默认是 BoundField.label 和 Form.label_suffix （或者 Field.label_suffix, 如果设置的话）的连接字符串。这可以被 contents 和 label_suffix 参数所覆盖。
attrs：一个包含 for、Form.required_css_class 和 id 的 dict。id 是由字段的部件 attrs 或 BoundField.auto_id 产生的。其他的属性可以由 attrs 参数提供。
use_tag：一个布尔值，如果标签有一个 id，则为 True。如果 False，默认模板会省略 <label> 标签。
要单独呈现一个表单字段的标签，可以调用它的 label_tag() 方法：
>>> f = ContactForm(data={'message': ''})\n>>> print(f['message'].label_tag())\n<label for="id_message">Message:</label>\n如果你想自定义渲染，这可以通过覆盖 Form.template_name_label 属性来实现，或者更普遍地通过覆盖默认模板来实现，也可以参见 覆盖内置表单模板。
使用此方法渲染此字段的原始值，如同 Widget：
>>> initial = {'subject': 'welcome'}\n>>> unbound_form = ContactForm(initial=initial)\n>>> bound_form = ContactForm(data={'subject': 'hi'}, initial=initial)\n>>> print(unbound_form['subject'].value())\nwelcome\n>>> print(bound_form['subject'].value())\nhi\nBoundFieldLink to this heading#如果你需要访问模板中表单字段的一些附加信息，而使用 Field 的子类还不够，也可以考虑自定义 BoundField。
自定义表单字段可以覆盖 get_bound_field()。
取一个 Form 的实例和字段名。当在模板中访问该字段时，将使用返回值。它很可能是 BoundField 的一个子类的实例。
例如，如果你有一个 GPSCoordinatesField，并希望能够在模板中访问关于坐标的附加信息，可以按以下方式实现：
class GPSCoordinatesBoundField(BoundField):\n @property\n def country(self):\n """\n Return the country the coordinates lie in or None if it can't be\n determined.\n """\n value = self.value()\n if value:\n return get_country_from_coordinates(value)\n else:\n return None\n\nclass GPSCoordinatesField(Field):\n def get_bound_field(self, form, field_name):\n return GPSCoordinatesBoundField(form, self, field_name)\n现在你可以在模板中使用 {{form.coordinates.country }} 访问国家。
处理有 FileField 和 ImageField 字段的表单比普通表单要复杂一些。
首先，为了上传文件，你需要确保你的 <form> 元素正确地将 enctype 定义为 "multipart/form-data"：
<form enctype="multipart/form-data" method="post" action="/foo/">\n其次，当你使用表单时，你需要绑定文件数据。文件数据与普通的表单数据是分开处理的，所以当你的表单包含一个 FileField 和 ImageField 时，你需要在绑定表单时指定第二个参数。因此，如果我们扩展我们的 ContactForm，包含一个名为 mugshot 的 ImageField，我们需要绑定包含 mugshot 图片的文件数据：
# Bound form with an image field\n>>> from django.core.files.uploadedfile import SimpleUploadedFile\n>>> data = {'subject': 'hello',\n... 'message': 'Hi there',\n... 'sender': 'foo@example.com',\n... 'cc_myself': True}\n>>> file_data = {'mugshot': SimpleUploadedFile('face.jpg', <file data>)}\n>>> f = ContactFormWithMugshot(data, file_data)\n在实践中，你通常会指定 request.FILES 作为文件数据的来源（就像你使用 request.POST 作为表单数据的来源一样）：
# Bound form with an image field, data from the request\n>>> f = ContactFormWithMugshot(request.POST, request.FILES)\n构造非绑定表单的方法和以往一样——省略表单数据 和 文件数据：
\n# Unbound form with an image field\n>>> f = ContactFormWithMugshot()\n如果你正在编写可重用的视图或模板，你可能无法提前知道你的表单是否是一个多部分表单。is_multipart() 方法可以告诉你表单是否需要多部分编码来提交：
>>> f = ContactFormWithMugshot()\n>>> f.is_multipart()\nTrue\n下面是一个如何在模板中使用的例子：
\n{% if form.is_multipart %}\n <form enctype="multipart/form-data" method="post" action="/foo/">\n{% else %}\n <form method="post" action="/foo/">\n{% endif %}\n{{ form }}\n</form>\n如果你有多个共享字段的 Form 类，你可以使用子类来消除冗余。
当你将一个自定义的 Form 类子类化时，生成的子类将包括父类的所有字段，然后是你在子类中定义的字段。
在这个例子中，ContactFormWithPriority 包含了 ContactForm 的所有字段，加上一个额外的字段 priority。ContactForm 字段是按顺序排列的：
>>> class ContactFormWithPriority(ContactForm):\n... priority = forms.CharField()\n>>> f = ContactFormWithPriority(auto_id=False)\n>>> print(f.as_ul())\n<li>Subject: <input type="text" name="subject" maxlength="100" required></li>\n<li>Message: <input type="text" name="message" required></li>\n<li>Sender: <input type="email" name="sender" required></li>\n<li>Cc myself: <input type="checkbox" name="cc_myself"></li>\n<li>Priority: <input type="text" name="priority" required></li>\n可以对多个表单进行子类化，将表单视为混搭。在这个例子中，BeatleForm 同时对 PersonForm 和 InstrumentForm 进行子类化（按顺序），它的字段列表包括父类的字段：
>>> from django import forms\n>>> class PersonForm(forms.Form):\n... first_name = forms.CharField()\n... last_name = forms.CharField()\n>>> class InstrumentForm(forms.Form):\n... instrument = forms.CharField()\n>>> class BeatleForm(InstrumentForm, PersonForm):\n... haircut_type = forms.CharField()\n>>> b = BeatleForm(auto_id=False)\n>>> print(b.as_ul())\n<li>First name: <input type="text" name="first_name" required></li>\n<li>Last name: <input type="text" name="last_name" required></li>\n<li>Instrument: <input type="text" name="instrument" required></li>\n<li>Haircut type: <input type="text" name="haircut_type" required></li>\n可以通过在子类上将字段名称设置为 "None" 来声明性地删除从父类继承的 Field。例如：
>>> from django import forms\n\n>>> class ParentForm(forms.Form):\n... name = forms.CharField()\n... age = forms.IntegerField()\n\n>>> class ChildForm(ParentForm):\n... name = None\n\n>>> list(ChildForm().fields)\n['age']\n你可以在一个 <form> 标签中放入多个 Django 表单。
>>> mother = PersonForm(prefix="mother")\n>>> father = PersonForm(prefix="father")\n>>> print(mother.as_ul())\n<li><label for="id_mother-first_name">First name:</label> <input type="text" name="mother-first_name" id="id_mother-first_name" required></li>\n<li><label for="id_mother-last_name">Last name:</label> <input type="text" name="mother-last_name" id="id_mother-last_name" required></li>\n>>> print(father.as_ul())\n<li><label for="id_father-first_name">First name:</label> <input type="text" name="father-first_name" id="id_father-first_name" required></li>\n<li><label for="id_father-last_name">Last name:</label> <input type="text" name="father-last_name" id="id_father-last_name" required></li>\n也可以在表单类上指定前缀：
\n>>> class PersonForm(forms.Form):\n... ...\n... prefix = 'person'\n