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# 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 |
如您所料， 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\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\nclass Book(models.Model):\n name = models.CharField(max_length=100)\n authors = models.ManyToManyField(Author)\n\nclass AuthorForm(ModelForm):\n class Meta:\n model = Author\n fields = ['name', 'title', 'birth_date']\n\nclass BookForm(ModelForm):\n class Meta:\n model = Book\n fields = ['name', 'authors']\n通过这些模型，上面的 ModelForm 子类将大致等同于（唯一的区别是 save() 方法，这我们稍后会讨论）：
from django import forms\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\nclass BookForm(forms.Form):\n name = forms.CharField(max_length=100)\n authors = forms.ModelMultipleChoiceField(queryset=Author.objects.all())\nModelFormLink to this heading#验证 ModelForm 主要涉及两个步骤：
和普通的表单验证一样，模型表单验证在调用 is_valid() 或访问 errors 属性时隐式触发，在调用 full_clean() 时显式触发，尽管在实际应用中你不大会用到后一种方法。
模型 验证（ Model.full_clean() ）在表单验证步骤中紧随表单的 clean() 方法被调用后触发。
您可以重写模型表单上的 clean() 方法来提供额外的验证，方式和普通的表单一样。
访问模型对象对应的表单实例包含一个 instance 属性，让它可以访问对应的模型实例。
作为验证过程的一部分， ModelForm 将调用模型上与表单字段对应的每个字段的 clean() 方法。如果您排除了一些模型字段，则验证将不会在这些字段上运行。更多有关字段clean及验证是如何工作的内容，请参阅 表单验证 文档。
模型的 clean() 方法会在所有唯一性检查之前被调用。有关模型 clean() 钩子的更多信息，请参阅 验证对象 。
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\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()\n只有在您使用 save(commit=False) 的时候才需要调用 save_m2m() 。当您在表单上使用普通的 save() 时，无需调用其他方法，所有数据（包括多对多数据）都会被保存。例如：
# 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 传递给表单），等等。更多相关信息，请参阅 Binding uploaded files to a form 。
强烈建议您使用 fields 属性来显式设置所有应在表单中编辑的字段。如果不这样做，当一张表单不慎允许用户设置某些字段，尤其是在将新字段添加到模型中时，很容易导致安全问题。根据表单渲染方式的不同，甚至可能不会在网页上显示问题。
另一种方法是自动包含所有字段，其他放入黑名单。据了解，这种基本方法不太安全，并已导致大型网站上出现严重漏洞（例如， GitHub ）。
\n但是，有两种简单的方法保证你不会出现这些安全问题：
\n将 fields 属性设置为特殊值 '__all__' 以表明需要使用模型中的所有字段。例如：
from django.forms import ModelForm\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\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 字典接受组件实例（例如， Textarea(...) ）或者类（例如， Textarea ）。
同样的，如果您想进一步自定义一个字段，还可以指定内部Meta类的 labels 、 help_texts 和 error_messages 属性。
例如您想自定义 name 字段中所有面向用户的字符文本：
from django.utils.translation import gettext_lazy as _\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 来自定义表单实例化的字段类型：
例如，如果您想对 slug 字段使用 MySlugFormField ，您可以这样做：
from django.forms import ModelForm\nfrom myapp.models import Article\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最后，如果您想完全控制一个字段（包括它的类型，验证，必填等等），您可以通过声明指定字段来做到这一点，就像在一个普通的 Form 中那样声明。
如果您想指定一个字段的验证器，可以通过声明定义该字段并设置其 validators 参数来实现：
from django.forms import CharField, ModelForm\nfrom myapp.models import Article\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__' ，则所有字段都将被本地化。
与普通表单一样，您可以通过继承它们来扩展和重用 ModelForms 。如果您需要在父类中声明额外字段或额外方法以用于从模型派生的多个表单中，则此方法非常有用。例如，使用之前的 ArticleForm 类。
>>> class EnhancedArticleForm(ArticleForm):\n... def clean_pub_date(self):\n... ...\n这会创建一个与 ArticleForm 行为相同的表单，除了 pub_date 字段会有一些额外的验证和cleaning。
如果要更改 Meta.fields 或 Meta.exclude 列表，您也可以继承父类的内部 Meta 类：
>>> class RestrictedArticleForm(EnhancedArticleForm):\n... class Meta(ArticleForm.Meta):\n... exclude = ('body',)\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,\n... widgets={"title": Textarea()})\n要包含的字段可以使用 fields 和 exclude 关键字参数或 ModelForm 内部的 Meta 类中相应的属性来指定。请参阅 ModelForm 选择要使用的字段 文档。
... 或者为个别字段启用本地化功能：
\n>>> Form = modelform_factory(Author, form=AuthorForm, localized_fields=("birth_date",))\n和 普通表单集 一样，Django提供了几个增强的formset类，可以很方便地配合Django模型使用。让我们重用下上面的 Author 模型：
>>> from django.forms import modelformset_factory\n>>> from myapp.models import Author\n>>> AuthorFormSet = modelformset_factory(Author, fields=('name', 'title'))\n使用 fields 参数限制formset仅使用给定的字段。或者，您可以使用排除法，指定排除哪些字段：
>>> AuthorFormSet = modelformset_factory(Author, exclude=('birth_date',))\n这将创建一个能够处理与 Author 模型相关数据的formset。它运行起来就像一个普通的formset：
>>> 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-MAX_NUM_FORMS" id="id_form-MAX_NUM_FORMS">\n<tr><th><label for="id_form-0-name">Name:</label></th><td><input id="id_form-0-name" type="text" name="form-0-name" maxlength="100"></td></tr>\n<tr><th><label for="id_form-0-title">Title:</label></th><td><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"></td></tr>\n默认情况下，当您创建一个模型ormset时，formset将使用一个包含模型中所有对象（例如 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\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如果您想返回一个不包含 任何 已存在模型实例的formset，您可以指定一个空的QuerySet：
\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, fields=('name', 'title'),\n... widgets={'name': Textarea(attrs={'cols': 80, 'rows': 20})})\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__' ，则所有字段都将被本地化。
As with regular formsets, it's possible to specify initial data for forms in the formset by specifying an initial\nparameter when instantiating the model formset class returned by\nmodelformset_factory(). However, with model\nformsets, the initial values only apply to extra forms, those that aren't\nattached to an existing model instance. If the length of initial exceeds\nthe number of extra forms, the excess initial data is ignored. If the extra\nforms with initial data aren't changed by the user, they won't be validated or\nsaved.
As with a ModelForm, you can save the data as a model object. This is done\nwith the formset's save() method:
# 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()\nThe save() method returns the instances that have been saved to the\ndatabase. If a given instance's data didn't change in the bound data, the\ninstance won't be saved to the database and won't be included in the return\nvalue (instances, in the above example).
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\nModelForms, in Selecting the fields to use.
Pass commit=False to return the unsaved model instances:
# 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()\nThis gives you the ability to attach data to the instances before saving them\nto the database. If your formset contains a ManyToManyField, you'll also\nneed to call formset.save_m2m() to ensure the many-to-many relationships\nare saved properly.
After calling save(), your model formset will have three new attributes\ncontaining the formset's changes:
As with regular formsets, you can use the max_num and extra parameters\nto modelformset_factory() to limit the number of\nextra forms displayed.
max_num does not prevent existing objects from being displayed:
>>> 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']\nAlso, extra=0 doesn't prevent creation of new model instances as you can\nadd additional forms with JavaScript\nor just send additional POST data. Formsets don't yet provide functionality for an "edit only" view that\nprevents creation of new instances.
If the value of max_num is greater than the number of existing related\nobjects, up to extra additional blank forms will be added to the formset,\nso long as the total number of forms does not exceed 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.as_table())\n<tr><th><label for="id_form-0-name">Name:</label></th><td><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"></td></tr>\n<tr><th><label for="id_form-1-name">Name:</label></th><td><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"></td></tr>\n<tr><th><label for="id_form-2-name">Name:</label></th><td><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"></td></tr>\n<tr><th><label for="id_form-3-name">Name:</label></th><td><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"></td></tr>\nmax_num 的值 None (默认值)，它限制最多显示(1000)张表单，其实这相当于没有限制。
Model formsets are very similar to formsets. Let's say we want to present a\nformset to edit Author model instances:
from django.forms import modelformset_factory\nfrom django.shortcuts import render\nfrom myapp.models import Author\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})\nAs you can see, the view logic of a model formset isn't drastically different\nthan that of a "normal" formset. The only difference is that we call\nformset.save() to save the data into the database. (This was described\nabove, in Saving objects in the formset.)
clean() on a ModelFormSetLink to this heading#Just like with ModelForms, 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\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 ...\nAlso note that by the time you reach this step, individual model instances\nhave already been created for each Form. Modifying a value in\nform.cleaned_data is not sufficient to affect the saved value. If you wish\nto modify a value in ModelFormSet.clean() you must modify\nform.instance:
from django.forms import BaseModelFormSet\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\nAs stated earlier, you can override the default queryset used by the model\nformset:
\nfrom django.forms import modelformset_factory\nfrom django.shortcuts import render\nfrom myapp.models import Author\n\ndef manage_authors(request):\n AuthorFormSet = modelformset_factory(Author, fields=('name', 'title'))\n if request.method == "POST":\n formset = AuthorFormSet(\n request.POST, request.FILES,\n queryset=Author.objects.filter(name__startswith='O'),\n )\n if formset.is_valid():\n formset.save()\n # Do something.\n else:\n formset = AuthorFormSet(queryset=Author.objects.filter(name__startswith='O'))\n return render(request, 'manage_authors.html', {'formset': formset})\nNote that we pass the queryset argument in both the POST and GET\ncases in this example.
There are three ways to render a formset in a Django template.
\nFirst, you can let the formset do most of the work:
\n<form method="post">\n {{ formset }}\n</form>\nSecond, you can manually render the formset, but let the form deal with\nitself:
\n<form method="post">\n {{ formset.management_form }}\n {% for form in formset %}\n {{ form }}\n {% endfor %}\n</form>\nWhen you manually render the forms yourself, be sure to render the management\nform as shown above. See the management form documentation.
\nThird, you can manually render each field:
\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>\nIf you opt to use this third method and you don't iterate over the fields with\na {% for %} loop, you'll need to render the primary key field. For example,\nif you were rendering the name and age fields of a model:
<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>\nNotice how we need to explicitly render {{ form.id }}. This ensures that\nthe model formset, in the POST case, will work correctly. (This example\nassumes a primary key named id. If you've explicitly defined your own\nprimary key that isn't called id, make sure it gets rendered.)
Inline formsets is a small abstraction layer on top of model formsets. These\nsimplify the case of working with related objects via a foreign key. Suppose\nyou have these two models:
\nfrom django.db import models\n\nclass Author(models.Model):\n name = models.CharField(max_length=100)\n\nclass Book(models.Model):\n author = models.ForeignKey(Author, on_delete=models.CASCADE)\n title = models.CharField(max_length=100)\nIf you want to create a formset that allows you to edit books belonging to\na particular author, you could do this:
\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'\n(<model name>_set ). If Book's ForeignKey to Author has a\nrelated_name, that's used instead.
InlineFormSetLink to this heading#When overriding methods on InlineFormSet, you should subclass\nBaseInlineFormSet rather than\nBaseModelFormSet.
For example, if you want to override clean():
from django.forms import BaseInlineFormSet\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 ...\nSee also Overriding clean() on a ModelFormSet.
\nThen when you create your inline formset, pass in the optional argument\nformset:
>>> from django.forms import inlineformset_factory\n>>> BookFormSet = inlineformset_factory(Author, Book, fields=('title',),\n... formset=CustomInlineFormSet)\n>>> author = Author.objects.get(name='Mike Royko')\n>>> formset = BookFormSet(instance=author)\nIf your model contains more than one foreign key to the same model, you'll\nneed to resolve the ambiguity manually using fk_name. For example, consider\nthe following model:
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()\nTo resolve this, you can use fk_name to\ninlineformset_factory():
>>> FriendshipFormSet = inlineformset_factory(Friend, Friendship, fk_name='from_friend',\n... fields=('to_friend', 'length_in_months'))\nYou may want to provide a view that allows a user to edit the related objects\nof a model. Here's how you can do that:
\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})\nNotice how we pass instance in both the POST and GET cases.
inlineformset_factory uses modelformset_factory and passes most\nof its arguments to modelformset_factory. This means you can use\nthe widgets parameter in much the same way as passing it to\nmodelformset_factory. See Specifying widgets to use in the form with\nwidgets above.