ModelFormLink to this heading#如果您正在构建一个数据库驱动的应用程序，那么您很有可能会用到与Django模型密切相关的表单。例如，您可能有一个 BlogComment 模型，并且您想创建一个让用户提交评论的表单。在这种情况下，在表单中定义字段类型是多余的，因为您已经在模型中定义了字段。
因此，Django 提供了一个辅助类让你可以从一个 Django 模型创建一个 Form 类。
例如：
\n>>> from django.forms import ModelForm\n>>> from myapp.models import Article\n\n# Create the form class.\n>>> class ArticleForm(ModelForm):\n... class Meta:\n... model = Article\n... fields = ["pub_date", "headline", "content", "reporter"]\n...\n\n# Creating a form to add an article.\n>>> form = ArticleForm()\n\n# Creating a form to change an existing article.\n>>> article = Article.objects.get(pk=1)\n>>> form = ArticleForm(instance=article)\n生成的 Form 类将按照 fields 属性中指定的顺序为每个指定的模型字段设置一个表单字段。
每个模型字段都有一个对应的默认表单字段。例如，模型中的 CharField 在表单中被表现为 CharField 。 ManyToManyField 则表现为 MultipleChoiceField 。以下是完整的转化清单：
模型字段 | \n表单字段 | \n
|---|---|
| \n | 不呈现在表单中 | \n
| \n | 不呈现在表单中 | \n
| \n |
| \n
| \n | \n |
| \n |
| \n
| \n |
| \n
| \n | \n |
| \n | \n |
| \n | \n |
| \n | \n |
| \n | \n |
| \n | \n |
| \n | \n |
| \n | \n |
| \n |
| \n
| \n | \n |
| \n | \n |
| \n
| \n
| \n | \n |
| \n | \n |
| \n |
| \n
| \n | \n |
| \n | \n |
| \n | \n |
| \n | \n |
| \n | 不呈现在表单中 | \n
| \n | \n |
| \n |
| \n
| \n | \n |
| \n | \n |
| \n | \n |
如您所料， ForeignKey 和 ManyToManyField 模型字段类型是特殊情况：
ForeignKey 由 django.forms.ModelChoiceField 表示， 它是一个 ChoiceField ，其选项是一个模型的 QuerySet 。
ManyToManyField 由 django.forms.ModelMultipleChoiceField 表示，它是一个 MultipleChoiceField ，其选项为一个模型 QuerySet 。
另外，每个生成的表单字段的属性设置如下：
\n如果模型字段设置了 blank=True ，那么表单字段的 required 属性被设置为 False ，否则 required=True 。
表单字段的 label 设置为模型字段的 verbose_name ，并且首字母大写。
表单字段的 help_text 设置为模型字段的 help_text 。
如果模型字段设置了 choices ，那么表单字段的 widget 会被设置为 Select ，其选项来自模型字段的 choices 。这些选项通常包含一个默认选中的空选项。如果字段设置了必填，则会强制用户进行选择。如果模型字段设置了 blank=False 以及一个明确的 default 值，则表单字段中不会包含空选项（默认会选中 default 值）。
最后，请注意，您可以覆盖给定模型字段对应的表单字段。参见下文 覆盖默认字段 。
\n思考下下面这组模型：
\nfrom django.db import models\nfrom django.forms import ModelForm\n\nTITLE_CHOICES = {\n "MR": "Mr.",\n "MRS": "Mrs.",\n "MS": "Ms.",\n}\n\n\nclass Author(models.Model):\n name = models.CharField(max_length=100)\n title = models.CharField(max_length=3, choices=TITLE_CHOICES)\n birth_date = models.DateField(blank=True, null=True)\n\n def __str__(self):\n return self.name\n\n\nclass Book(models.Model):\n name = models.CharField(max_length=100)\n authors = models.ManyToManyField(Author)\n\n\nclass AuthorForm(ModelForm):\n class Meta:\n model = Author\n fields = ["name", "title", "birth_date"]\n\n\nclass BookForm(ModelForm):\n class Meta:\n model = Book\n fields = ["name", "authors"]\n通过这些模型，上面的 ModelForm 子类将大致等同于（唯一的区别是 save() 方法，这我们稍后会讨论）：
from django import forms\n\n\nclass AuthorForm(forms.Form):\n name = forms.CharField(max_length=100)\n title = forms.CharField(\n max_length=3,\n widget=forms.Select(choices=TITLE_CHOICES),\n )\n birth_date = forms.DateField(required=False)\n\n\nclass BookForm(forms.Form):\n name = forms.CharField(max_length=100)\n authors = forms.ModelMultipleChoiceField(queryset=Author.objects.all())\nModelFormLink to this heading#验证 ModelForm 主要涉及两个步骤：
Just like normal form validation, model form validation is triggered implicitly\nwhen calling is_valid() or accessing the\nerrors attribute and explicitly when calling\nfull_clean(), although you will typically not use the latter method in\npractice.
Model validation is triggered from within the form validation step right\nafter the form's clean() method is called. First, the model's\nfull_clean() is called with\nvalidate_unique=False and validate_constraints=False, then the model's\nvalidate_unique() and\nvalidate_constraints() methods are called in\norder.
clean() 方法Link to this heading#您可以重写模型表单上的 clean() 方法来提供额外的验证，方式和普通的表单一样。
访问模型对象对应的表单实例包含一个 instance 属性，让它可以访问对应的模型实例。
作为验证过程的一部分， ModelForm 将调用模型上与表单字段对应的每个字段的 clean() 方法。如果您排除了一些模型字段，则验证将不会在这些字段上运行。更多有关字段clean及验证是如何工作的内容，请参阅 表单验证 文档。
The model's clean() method will be called before any uniqueness or\nconstraint checks are made. See Validating objects\nfor more information on the model's clean() hook.
error_messages 的注意事项Link to this heading#在 表单字段 级别或者 表单 Meta 级别定义的错误信息优先级总是高于在 模型字段 级别定义的。
在 模型字段 上定义的错误信息只有在 模型验证 步骤引发 ValidationError 时才会使用，并且没有在表单级定义相应的错误信息。
您可以通过添加 NON_FIELD_ERRORS 键到 ModelForm 内部的 Meta 类的 error_messages 中来覆盖模型验证引发的 NON_FIELD_ERRORS 错误信息。
from django.core.exceptions import NON_FIELD_ERRORS\nfrom django.forms import ModelForm\n\n\nclass ArticleForm(ModelForm):\n class Meta:\n error_messages = {\n NON_FIELD_ERRORS: {\n "unique_together": "%(model_name)s's %(field_labels)s are not unique.",\n }\n }\nsave() 方法Link to this heading#每个 ModelForm 还有一个 save() 方法。此方法根据绑定到表单的数据创建并保存数据库对象。 ModelForm 的子类可接受一个现有的模型实例作为关键字参数 instance ；如果提供了，则 save() 会更新这个实例。如果没有，则 save() 会创建一个对应模型的新实例。
>>> from myapp.models import Article\n>>> from myapp.forms import ArticleForm\n\n# Create a form instance from POST data.\n>>> f = ArticleForm(request.POST)\n\n# Save a new Article object from the form's data.\n>>> new_article = f.save()\n\n# Create a form to edit an existing Article, but use\n# POST data to populate the form.\n>>> a = Article.objects.get(pk=1)\n>>> f = ArticleForm(request.POST, instance=a)\n>>> f.save()\n请注意，如果表单 尚未验证 ，调用 save() 将通过检查 form.errors 来实现验证。如果表单验证不过，则会引发 ValueError —— 比如，如果 form.errors 返回 True 。
如果一个可选字段没有出现在表单的数据中，并且您给这个模型字段设置了 default ，那么对应的模型实例会使用这个值作为结果。此行为不适用于使用以下组件的字段： CheckboxInput 、 CheckboxSelectMultiple 或者 SelectMultiple （或者所有其 value_omitted_from_data() 方法总是返回 False 的组件），因为未勾选的复选框和未选中的 <select multiple> 不会出现在HTML表单提交的数据中。如果您正在设计API并且希望使用这些组件之一的字段有默认回退行为，请使用自定义表单字段或组件。
save() 方法接受一个可选参数 commit ，它的值是 True 或者 False 。如果调用 save() 的时候使用 commit=False ，那么它会返回一个尚未保存到数据库的对象。在这种情况下，需要您自己在生成的模型实例上调用 save() 。如果要在保存对象之前对对象执行自定义操作，或者要使用其中一个专用的 模型保存选项 ，这很有用。 commit 的值默认为 True 。
另一个使用 commit=False 的作用，您可以在模型与另一个模型有多对多关系的时候看到。如果您的模型具有多对多关系，并且在保存表单时指定了 commit=False ，Django无法立即保存多对多关系的表单数据。这是因为实例的多对多数据只有实例在数据库中存在时才能保存。
要解决这个问题，Django会在您每次使用 commit=False 保存表单时，向 ModelForm 子类添加一个 save_m2m() 方法。在您手动保存表单生成的实例后，可以调用 save_m2m() 来保存多对多的表单数据。例如：
# Create a form instance with POST data.\n>>> f = AuthorForm(request.POST)\n\n# Create, but don't save the new author instance.\n>>> new_author = f.save(commit=False)\n\n# Modify the author in some way.\n>>> new_author.some_field = "some_value"\n\n# Save the new instance.\n>>> new_author.save()\n\n# Now, save the many-to-many data for the form.\n>>> f.save_m2m()\nCalling save_m2m() is only required if you use save(commit=False).\nWhen you use a save() on a form, all data -- including many-to-many data --\nis saved without the need for any additional method calls. For example:
# Create a form instance with POST data.\n>>> a = Author()\n>>> f = AuthorForm(request.POST, instance=a)\n\n# Create and save the new author instance. There's no need to do anything else.\n>>> new_author = f.save()\n除了 save() 和 save_m2m() 方法之外，ModelForm 与普通的表单工作方式一样。例如，用 is_valid() 方法来检查合法性，用 is_multipart() 方法来确定表单是否需要multipart文件上传（之后是否必须将 request.FILES 传递给表单），等等。更多相关信息，请参阅 将上传的文件绑定到表单中 。
强烈建议您使用 fields 属性来显式设置所有应在表单中编辑的字段。如果不这样做，当一张表单不慎允许用户设置某些字段，尤其是在将新字段添加到模型中时，很容易导致安全问题。根据表单渲染方式的不同，甚至可能不会在网页上显示问题。
The alternative approach would be to include all fields automatically, or\nremove only some. This fundamental approach is known to be much less secure and\nhas led to serious exploits on major websites (e.g. GitHub\n).
\n但是，有两种简单的方法保证你不会出现这些安全问题：
\n将 fields 属性设置为特殊值 '__all__' 以表明需要使用模型中的所有字段。例如：
from django.forms import ModelForm\n\n\nclass AuthorForm(ModelForm):\n class Meta:\n model = Author\n fields = "__all__"\n将 ModelForm 中Meta类的 exclude 属性设置为表单中需要排除的字段列表。
例如：
\nclass PartialAuthorForm(ModelForm):\n class Meta:\n model = Author\n exclude = ["title"]\n由于 Author 模型有三个字段 name、 title 和 birth_date ，上例的结果是字段 name 和 birth_date 会呈现在表单中。
不管使用哪一种，字段会按模型中定义的顺序在表单中出现， ManyToManyField 会排在最后。
另外，Django有个规则：如果您在模型字段中定义了 editable=False ， 任何 使用 ModelForm 给该模型创建的表单都不会包含这个字段。
之前在 字段类型 表格中介绍的默认字段类型都是相对合适的。如果您的模型中有一个 DateField ，您可能希望在表单中将它展示为 DateField 。但 ModelForm 可以让您灵活地改变给定模型的表单字段。
要为字段指定自定义组件，请使用内部 Meta 类的 widgets 属性。它应该是一个映射字段名到组建类或组件实例的字典。
例如，如果您希望 Author 的 name 属性的 CharField 由 <textarea> 代替默认的 <input type="text"> 来表示，您可以重写字段的部件：
from django.forms import ModelForm, Textarea\nfrom myapp.models import Author\n\n\nclass AuthorForm(ModelForm):\n class Meta:\n model = Author\n fields = ["name", "title", "birth_date"]\n widgets = {\n "name": Textarea(attrs={"cols": 80, "rows": 20}),\n }\nwidgets 字典接受任何 widget 实例（例如 Textarea(...) ）或类（例如 Textarea）。注意，对于具有非空 choices 属性的模型字段，widgets 字典会被忽略。在这个例子里，你必须覆盖表单字段来使用不同的 widget 。
同样的，如果您想进一步自定义一个字段，还可以指定内部Meta类的 labels 、 help_texts 和 error_messages 属性。
例如您想自定义 name 字段中所有面向用户的字符文本：
from django.utils.translation import gettext_lazy as _\n\n\nclass AuthorForm(ModelForm):\n class Meta:\n model = Author\n fields = ["name", "title", "birth_date"]\n labels = {\n "name": _("Writer"),\n }\n help_texts = {\n "name": _("Some useful help text."),\n }\n error_messages = {\n "name": {\n "max_length": _("This writer's name is too long."),\n },\n }\n你还可以指定 field_classes 或 formfield_callback 来自定义表单实例化的字段类型。
例如，如果您想对 slug 字段使用 MySlugFormField ，您可以这样做：
from django.forms import ModelForm\nfrom myapp.models import Article\n\n\nclass ArticleForm(ModelForm):\n class Meta:\n model = Article\n fields = ["pub_date", "headline", "content", "reporter", "slug"]\n field_classes = {\n "slug": MySlugFormField,\n }\n或者：
\nfrom django.forms import ModelForm\nfrom myapp.models import Article\n\n\ndef formfield_for_dbfield(db_field, **kwargs):\n if db_field.name == "slug":\n return MySlugFormField()\n return db_field.formfield(**kwargs)\n\n\nclass ArticleForm(ModelForm):\n class Meta:\n model = Article\n fields = ["pub_date", "headline", "content", "reporter", "slug"]\n formfield_callback = formfield_for_dbfield\n最后，如果您想完全控制一个字段（包括它的类型，验证，必填等等），您可以通过声明指定字段来做到这一点，就像在一个普通的 Form 中那样声明。
如果您想指定一个字段的验证器，可以通过声明定义该字段并设置其 validators 参数来实现：
from django.forms import CharField, ModelForm\nfrom myapp.models import Article\n\n\nclass ArticleForm(ModelForm):\n slug = CharField(validators=[validate_slug])\n\n class Meta:\n model = Article\n fields = ["pub_date", "headline", "content", "reporter", "slug"]\n默认情况下， ModelForm 中的字段不会本地化他们的数据。要为字段启用本地化，您可以在 Meta 类中使用 localized_fields 属性。
>>> from django.forms import ModelForm\n>>> from myapp.models import Author\n>>> class AuthorForm(ModelForm):\n... class Meta:\n... model = Author\n... localized_fields = ['birth_date']\n如果 localized_fields 设置为特殊值 '__all__' ，则所有字段都将被本地化。
As with basic forms, you can extend and reuse ModelForm classes by\ninheriting them. This is useful if you need to declare extra fields or extra\nmethods on a parent class for use in a number of forms derived from models.\nFor example, using the previous ArticleForm class:
>>> class EnhancedArticleForm(ArticleForm):\n... def clean_pub_date(self): ...\n...\n这会创建一个与 ArticleForm 行为相同的表单，除了 pub_date 字段会有一些额外的验证和cleaning。
你还可以继承父类的 Meta 内部类，如果你想要更改 Meta.fields 或 Meta.exclude 列表：
>>> class RestrictedArticleForm(EnhancedArticleForm):\n... class Meta(ArticleForm.Meta):\n... exclude = ["body"]\n...\n这相比 EnhancedArticleForm 增加了额外方法，并修改了原始的 ArticleForm.Meta 以删除一个字段。
然而，有几项需要注意。
\n适用于普通的Python名称解析规则。如果您有多个声明 Meta 内部类的基类，就是说如果声明了子类的 Meta 就会使用它，否则就用第一个父类的 Meta 。
可以同时继承 Form 和 ModelForm ，但是，您必须确保 ModelForm 在MRO中出现在首位。这是因为这些类依赖于不同的元类，而一个类只能有一个元类。
通过在子类上将名称设置为 None ，可以声明性地移除从父类继承的 Field 。
您只能使用这种技术排除父类中声明定义的字段；它不会阻止 ModelForm 元类生成默认字段。要排除默认字段，请参阅 选择要使用的字段 。
与常规表单一样，可以通过在实例化表单时指定一个 initial 参数来为表单指定初始数据。以这种方式提供的初始值将覆盖表单字段的初始值和附加的模型实例的值。例如：
>>> article = Article.objects.get(pk=1)\n>>> article.headline\n'My headline'\n>>> form = ArticleForm(initial={"headline": "Initial headline"}, instance=article)\n>>> form["headline"].value()\n'Initial headline'\n你可以使用独立函数 modelform_factory() 来从给定的模型创建表单，而不是使用类定义。如果你没有太多自定义需求，这可能会更方便：
>>> from django.forms import modelform_factory\n>>> from myapp.models import Book\n>>> BookForm = modelform_factory(Book, fields=["author", "title"])\n这也可以用于对现有表单进行修改，例如通过指定要用于特定字段的小部件：
\n>>> from django.forms import Textarea\n>>> Form = modelform_factory(Book, form=BookForm, widgets={"title": Textarea()})\n要包含的字段可以使用 fields 和 exclude 关键字参数或 ModelForm 内部的 Meta 类中相应的属性来指定。请参阅 ModelForm 选择要使用的字段 文档。
... 或者为特定字段启用本地化：
\n>>> Form = modelform_factory(Author, form=AuthorForm, localized_fields=["birth_date"])\n与 常规表单集 一样，Django 提供了一些增强的表单集类，以更方便地处理 Django 模型。让我们重用上面提到的 Author 模型：
>>> from django.forms import modelformset_factory\n>>> from myapp.models import Author\n>>> AuthorFormSet = modelformset_factory(Author, fields=["name", "title"])\n使用 fields 限制了表单集只使用给定的字段。或者，你可以采用 "排除" 的方式，指定要排除哪些字段：
>>> AuthorFormSet = modelformset_factory(Author, exclude=["birth_date"])\n这将创建一个能够处理与 Author 模型相关数据的表单集。它的工作方式与常规表单集一样：
>>> formset = AuthorFormSet()\n>>> print(formset)\n<input type="hidden" name="form-TOTAL_FORMS" value="1" id="id_form-TOTAL_FORMS"><input type="hidden" name="form-INITIAL_FORMS" value="0" id="id_form-INITIAL_FORMS"><input type="hidden" name="form-MIN_NUM_FORMS" value="0" id="id_form-MIN_NUM_FORMS"><input type="hidden" name="form-MAX_NUM_FORMS" value="1000" id="id_form-MAX_NUM_FORMS">\n<div><label for="id_form-0-name">Name:</label><input id="id_form-0-name" type="text" name="form-0-name" maxlength="100"></div>\n<div><label for="id_form-0-title">Title:</label><select name="form-0-title" id="id_form-0-title">\n<option value="" selected>---------</option>\n<option value="MR">Mr.</option>\n<option value="MRS">Mrs.</option>\n<option value="MS">Ms.</option>\n</select><input type="hidden" name="form-0-id" id="id_form-0-id"></div>\n默认情况下，当你从一个模型创建一个表单集时，表单集将使用包含模型中所有对象的查询集 (例如，Author.objects.all())。你可以通过使用 queryset 参数来覆盖这种行为：
>>> formset = AuthorFormSet(queryset=Author.objects.filter(name__startswith="O"))\n或者，您可以创建一个子类，然后在 __init__ 中设置 self.queryset ：
from django.forms import BaseModelFormSet\nfrom myapp.models import Author\n\n\nclass BaseAuthorFormSet(BaseModelFormSet):\n def __init__(self, *args, **kwargs):\n super().__init__(*args, **kwargs)\n self.queryset = Author.objects.filter(name__startswith="O")\n然后，将你的 BaseAuthorFormSet 类传递给工厂函数：
>>> AuthorFormSet = modelformset_factory(\n... Author, fields=["name", "title"], formset=BaseAuthorFormSet\n... )\n如果你想返回一个不包含 任何 预先存在的模型实例的表单集，你可以指定一个空的查询集：
\n>>> AuthorFormSet(queryset=Author.objects.none())\n默认情况下，当您使用 modelformset_factory 时，程序会用 modelform_factory() 创建一个模型表单。这通常在指定自定义模型表单时很有用。例如，您可以创建一个具有自定义验证的自定义模型表单：
class AuthorForm(forms.ModelForm):\n class Meta:\n model = Author\n fields = ["name", "title"]\n\n def clean_name(self):\n # custom validation for the name field\n ...\n然后，将您的模型表单传递给工厂函数：
\nAuthorFormSet = modelformset_factory(Author, form=AuthorForm)\n并不是总需要自定义模型表单。 modelformset_factory 函数有几个参数传递给 modelform_factory ，如下所述。
widgets 指定部件。Link to this heading#使用 widgets 参数，你可以指定一个字典的值，以自定义特定字段的 ModelForm 的小部件类。这与 ModelForm 内部 Meta 类上的 widgets 字典的工作方式相同：
>>> AuthorFormSet = modelformset_factory(\n... Author,\n... fields=["name", "title"],\n... widgets={"name": Textarea(attrs={"cols": 80, "rows": 20})},\n... )\nlocalized_fields 来启用字段本地化Link to this heading#您可以使用 localized_fields 参数为表单中的字段启用本地化。
>>> AuthorFormSet = modelformset_factory(\n... Author, fields=['name', 'title', 'birth_date'],\n... localized_fields=['birth_date'])\n如果 localized_fields 设置为特殊值 '__all__' ，则所有字段都将被本地化。
与常规表单集(formset)一样，在实例化 modelformset_factory() 返回的模型表单集类时，可以通过指定初始参数来指定表单集中表单的初始数据。然而，对于模型表单集，初始值只适用于额外的表单，不会附加到已存在的模型实例。如果 initial 的长度超过了额外表单的数量，多余的初始值会被忽略。如果带有初始值的额外表单没有通过用户去改变，它们不会被验证或保存。
和 ModelForm 一样，你可以将数据保存为模型对象。这是通过表单集的 save() 方法来完成的：
# Create a formset instance with POST data.\n>>> formset = AuthorFormSet(request.POST)\n\n# Assuming all is valid, save the data.\n>>> instances = formset.save()\nsave() 方法返回已经保存到数据库的实例。如果一个给定实例的数据没有在绑定数据中改变，那么实例不会被保存到数据库，也不会包含在返回值里（上述例子中的 instances ）。
When fields are missing from the form (for example because they have been\nexcluded), these fields will not be set by the save() method. You can find\nmore information about this restriction, which also holds for regular\nmodel forms, in Selecting the fields to use.
传递 commit=False，返回未保存的模型实例：
# don't save to the database\n>>> instances = formset.save(commit=False)\n>>> for instance in instances:\n... # do something with instance\n... instance.save()\n...\n这会你在保存它们到数据库之前，附加数据给实例。如果你的表单集包含 ManyToManyField ，你也将需要调用 formset.save_m2m() 来确保正确保存了多对多关系。
在调用 save() 之后，你的模型表单集将会有三个包含表单集更改的新属性：
和普通表单集一样，你可以使用 max_num 和 extra 参数来 modelformset_factory() 来让 modelformset_factory() 限制显示的额外表单数量。
max_num 不会阻止显示现有对象：
>>> Author.objects.order_by("name")\n<QuerySet [<Author: Charles Baudelaire>, <Author: Paul Verlaine>, <Author: Walt Whitman>]>\n\n>>> AuthorFormSet = modelformset_factory(Author, fields=["name"], max_num=1)\n>>> formset = AuthorFormSet(queryset=Author.objects.order_by("name"))\n>>> [x.name for x in formset.get_queryset()]\n['Charles Baudelaire', 'Paul Verlaine', 'Walt Whitman']\n此外，extra=0 并不会阻止创建新的模型实例，因为你可以通过 JavaScript 添加额外的表单 或发送额外的 POST 数据来实现。请参阅 防止创建新对象 以了解如何做到这一点。
如果 max_num 的值大于现有相关对象的数量，那么会添加最多 extra 个额外的空白表单到表单集中，只要总表单数不超过 max_num 即可：
>>> AuthorFormSet = modelformset_factory(Author, fields=["name"], max_num=4, extra=2)\n>>> formset = AuthorFormSet(queryset=Author.objects.order_by("name"))\n>>> for form in formset:\n... print(form)\n...\n<div><label for="id_form-0-name">Name:</label><input id="id_form-0-name" type="text" name="form-0-name" value="Charles Baudelaire" maxlength="100"><input type="hidden" name="form-0-id" value="1" id="id_form-0-id"></div>\n<div><label for="id_form-1-name">Name:</label><input id="id_form-1-name" type="text" name="form-1-name" value="Paul Verlaine" maxlength="100"><input type="hidden" name="form-1-id" value="3" id="id_form-1-id"></div>\n<div><label for="id_form-2-name">Name:</label><input id="id_form-2-name" type="text" name="form-2-name" value="Walt Whitman" maxlength="100"><input type="hidden" name="form-2-id" value="2" id="id_form-2-id"></div>\n<div><label for="id_form-3-name">Name:</label><input id="id_form-3-name" type="text" name="form-3-name" maxlength="100"><input type="hidden" name="form-3-id" id="id_form-3-id"></div>\nmax_num 的值 None (默认值)，它限制最多显示(1000)张表单，其实这相当于没有限制。
使用 edit_only 参数，你可以防止创建任何新对象：
>>> AuthorFormSet = modelformset_factory(\n... Author,\n... fields=["name", "title"],\n... edit_only=True,\n... )\n在这里，表单集只会编辑现有的 Author 实例。不会创建或编辑其他对象。
模型表单集与表单集非常相似。假设我们想要一个表单集来编辑 Author 模型实例：
from django.forms import modelformset_factory\nfrom django.shortcuts import render\nfrom myapp.models import Author\n\n\ndef manage_authors(request):\n AuthorFormSet = modelformset_factory(Author, fields=["name", "title"])\n if request.method == "POST":\n formset = AuthorFormSet(request.POST, request.FILES)\n if formset.is_valid():\n formset.save()\n # do something.\n else:\n formset = AuthorFormSet()\n return render(request, "manage_authors.html", {"formset": formset})\n像你看到的那样，模型表单集的视图逻辑与普通的表单集并没有太大的不同。唯一的不同是我们调用 formset.save() 来保存数据到数据库里。（这已在上面的 在表单集中保存对象 中描述。）
ModelFormSet 上的 clean()Link to this heading#Just like with a ModelForm, by default the clean() method of a\nModelFormSet will validate that none of the items in the formset violate\nthe unique constraints on your model (either unique, unique_together or\nunique_for_date|month|year). If you want to override the clean() method\non a ModelFormSet and maintain this validation, you must call the parent\nclass's clean method:
from django.forms import BaseModelFormSet\n\n\nclass MyModelFormSet(BaseModelFormSet):\n def clean(self):\n super().clean()\n # example custom validation across forms in the formset\n for form in self.forms:\n # your custom formset validation\n ...\n还要注意的是，到达此步时，已经为每个表单创建了独立模型实例。在 form.cleaned_data 里修改值不足以影响已保存的值。如果你想在 ModelFormSet.clean() 中修改值，你必须修改 form.instance ：
from django.forms import BaseModelFormSet\n\n\nclass MyModelFormSet(BaseModelFormSet):\n def clean(self):\n super().clean()\n\n for form in self.forms:\n name = form.cleaned_data["name"].upper()\n form.cleaned_data["name"] = name\n # update the instance value.\n form.instance.name = name\n如前所述，你可以覆盖模型表单集使用的默认查询集：
\nfrom django.forms import modelformset_factory\nfrom django.shortcuts import render\nfrom myapp.models import Author\n\n\ndef manage_authors(request):\n AuthorFormSet = modelformset_factory(Author, fields=["name", "title"])\n queryset = Author.objects.filter(name__startswith="O")\n if request.method == "POST":\n formset = AuthorFormSet(\n request.POST,\n request.FILES,\n queryset=queryset,\n )\n if formset.is_valid():\n formset.save()\n # Do something.\n else:\n formset = AuthorFormSet(queryset=queryset)\n return render(request, "manage_authors.html", {"formset": formset})\n注意我们在这个例子里的 POST and GET 情况下传递了 queryset 参数。
有三种办法在 Django 模板中渲染表单集。
\n首先，你可以让表单集完成大部分工作：
\n<form method="post">\n {{ formset }}\n</form>\n其次，你可以手动渲染表单集，但让表单自己处理自己：
\n<form method="post">\n {{ formset.management_form }}\n {% for form in formset %}\n {{ form }}\n {% endfor %}\n</form>\n当你手工渲染表单时，确保渲染了如上所述的管理表单。请查看文档的“管理”部分 （management form documentation ）
\n第三，你可以手动渲染每个字段：
\n<form method="post">\n {{ formset.management_form }}\n {% for form in formset %}\n {% for field in form %}\n {{ field.label_tag }} {{ field }}\n {% endfor %}\n {% endfor %}\n</form>\n如果你选择使用这第三种方法，并且没有使用 {% for %} 循环迭代字段，你需要渲染主键字段。例如，如果你要渲染模型的 name 和 age 字段：
<form method="post">\n {{ formset.management_form }}\n {% for form in formset %}\n {{ form.id }}\n <ul>\n <li>{{ form.name }}</li>\n <li>{{ form.age }}</li>\n </ul>\n {% endfor %}\n</form>\n注意我们需要显式地渲染 {{ form.id }} 。这将确保在 POST 情况下，模型表单集正确工作。（这个例子假设主键名是 id 。如果你已经显式定义了不是名为 id 的主键，那你需要确保它正确地渲染。）
内联表单集是在模型表单集上一个很小的抽象层。这些表单集通过外键简化了处理相关对象的情况。假设你有两个模型：
\nfrom django.db import models\n\n\nclass Author(models.Model):\n name = models.CharField(max_length=100)\n\n\nclass Book(models.Model):\n author = models.ForeignKey(Author, on_delete=models.CASCADE)\n title = models.CharField(max_length=100)\n如果你想创建一个允许你编辑属于特定作者的书籍的表单集，你可以这样做：
\n>>> from django.forms import inlineformset_factory\n>>> BookFormSet = inlineformset_factory(Author, Book, fields=["title"])\n>>> author = Author.objects.get(name="Mike Royko")\n>>> formset = BookFormSet(instance=author)\nBookFormSet's prefix is 'book_set' (<model name>_set ). 如果 Book 的 指向 Author 的 ForeignKey 有一个 related_name ，则使用它。
InlineFormSet 上的方法Link to this heading#当覆盖 InlineFormSet 上的方法时，你可以继承 BaseInlineFormSet 而不是 BaseModelFormSet 。
比如，如果你想覆盖 clean() ：
from django.forms import BaseInlineFormSet\n\n\nclass CustomInlineFormSet(BaseInlineFormSet):\n def clean(self):\n super().clean()\n # example custom validation across forms in the formset\n for form in self.forms:\n # your custom formset validation\n ...\n也可以看 覆盖 ModelFormSet 上的 clean() 。
\n然后当你创建内联表单集时，传递可选参数 formset：
>>> from django.forms import inlineformset_factory\n>>> BookFormSet = inlineformset_factory(\n... Author, Book, fields=["title"], formset=CustomInlineFormSet\n... )\n>>> author = Author.objects.get(name="Mike Royko")\n>>> formset = BookFormSet(instance=author)\n如果你的模型包含多个外键，你需要解决使用 fk_name 来解决歧义。比如下面的模型：
class Friendship(models.Model):\n from_friend = models.ForeignKey(\n Friend,\n on_delete=models.CASCADE,\n related_name="from_friends",\n )\n to_friend = models.ForeignKey(\n Friend,\n on_delete=models.CASCADE,\n related_name="friends",\n )\n length_in_months = models.IntegerField()\n要解决这个问题，你可以使用 fk_name 参数传递给 inlineformset_factory()：
>>> FriendshipFormSet = inlineformset_factory(\n... Friend, Friendship, fk_name="from_friend", fields=["to_friend", "length_in_months"]\n... )\n你可以提供一个视图来允许用户编辑模型的相关对象。这里是相关做法：
\ndef manage_books(request, author_id):\n author = Author.objects.get(pk=author_id)\n BookInlineFormSet = inlineformset_factory(Author, Book, fields=["title"])\n if request.method == "POST":\n formset = BookInlineFormSet(request.POST, request.FILES, instance=author)\n if formset.is_valid():\n formset.save()\n # Do something. Should generally end with a redirect. For example:\n return HttpResponseRedirect(author.get_absolute_url())\n else:\n formset = BookInlineFormSet(instance=author)\n return render(request, "manage_books.html", {"formset": formset})\n请注意我们如何将 instance 传递给 POST 和 GET 的。
inlineformset_factory 使用 modelformset_factory，并传递大部分参数给 modelformset_factory 。这意味着你可以使用 widgets 参数，就像将它传递给 modelformset_factory 一样。请查看 Specifying widgets to use in the form with widgets 。