ModelFormLink to this heading#If you're building a database-driven app, chances are you'll have forms that\nmap closely to Django models. For instance, you might have a BlogComment\nmodel, and you want to create a form that lets people submit comments. In this\ncase, it would be redundant to define the field types in your form, because\nyou've already defined the fields in your model.
For this reason, Django provides a helper class that lets you create a Form\nclass from a Django model.
Sebagai contoh:
\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)\nThe generated Form class will have a form field for every model field\nspecified, in the order specified in the fields attribute.
Setiap bidang model mempunyai biadng formulir awalan sesuai. Sebagai contoh, sebuah CharField pada sebuah model adalah diwakili sebagai CharField pada formulir. Sebuah model ManyToManyField diwakilkan sebagai sebuah MultipleChoiceField. Ini adalah daftar penuh dari perubahan:
Bidang Model | \nBidang Formulir | \n
|---|---|
| \n | Tidak muncul di formulir | \n
| \n | Tidak muncul di formulir | \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 | Tidak muncul di formulir | \n
| \n | \n |
| \n |
| \n
| \n | \n |
| \n | \n |
| \n | \n |
Seperti yang mungkin anda duga, jenis tipe model ForeignKey dan ManyToManyField adalah kasus-kasus berbeda:
ForeignKey diwakili oleh django.forms.ModelChoiceField, yaitu sebuah ChoiceField yang pilihan-pilihan adalah sebuah model QuerySet.
ManyToManyField diwakili oleh django.forms.ModelMultipleChoiceField, dimana MultipleChoiceField yang pilihan-pilihannya adalah sebuah model QuerySet.
Sebagai tambahan, setiap bidang formulir dibangkitkan mempunyai atribut disetel sebagai berikut:
\nJika bidang model mempunyai blank=True, maka required disetel ke False pada bidang formulir. Sebaliknya required=True.
The form field's label is set to the verbose_name of the model\nfield, with the first character capitalized.
help_text bidang formulir disetel pada help_text dari bidang model.
If the model field has choices set, then the form field's widget\nwill be set to Select, with choices coming from the model field's\nchoices. The choices will normally include the blank choice which is\nselected by default. If the field is required, this forces the user to\nmake a selection. The blank choice will not be included if the model\nfield has blank=False and an explicit default value (the\ndefault value will be initially selected instead).
Akhirnya, catat bahwa anda dapat menimpa bidang formulir digunakan untuk bidang model diberikan. Lihat Overriding the default fields below.
\nPertimbangkan kumpulan model ini:
\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']\nWith these models, the ModelForm subclasses above would be roughly\nequivalent to this (the only difference being the save() method, which\nwe'll discuss in a moment.):
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#Terdapat dua langkah utama dilibatkan dalam ModelForm:
Validating the model instance 1
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.
Pengesahan Model (Model.full_clean()) dibangkitkan dari dalam langkah formulir pengesahan, tepat setelah metode formulir clean() dipanggil.
clean()Link to this heading#You can override the clean() method on a model form to provide additional\nvalidation in the same way you can on a normal form.
A model form instance attached to a model object will contain an instance\nattribute that gives its methods access to that specific model instance.
Sebagai bagian dari pengolahan pengesahan. ModelForm akan memanggil metode clean() untuk setiap bidang pada model anda yang mempunyai bidang sesuai pada formulir anda. Jika anda telah tidak menyertakan bidang model apapun, pengesahan tidak akan berjalan pada bidang-bidang tersebut. Lihat dokumentasi form validation 1 untuk lebih pada bagimana bidang membersihkan dan pengesahan bekerja.
Metode clean() model akan dipanggil sebelum pemeriksanaan keunikan apapun dibuat. Lihat Validating objects untuk informasi lebih pada tautan clean() model.
error_messages modelLink to this heading#Error messages defined at the\nform field level or at the\nform Meta level always take\nprecedence over the error messages defined at the\nmodel field level.
Pesan-pesan kesalahan ditentukan pada model fields hanya digunakan ketika ValidationError dimunculkan selama langkah model validation 1 dan tidak ada pesan kesalahan sesuai ditentukan pada tingkatan formulir.
You can override the error messages from NON_FIELD_ERRORS raised by model\nvalidation by adding the NON_FIELD_ERRORS key\nto the error_messages dictionary of the ModelForm’s inner Meta class:
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#Every ModelForm also has a save() method. This method creates and saves\na database object from the data bound to the form. A subclass of ModelForm\ncan accept an existing model instance as the keyword argument instance; if\nthis is supplied, save() will update that instance. If it's not supplied,\nsave() will create a new instance of the specified model:
>>> 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()\nNote that if the form hasn't been validated, calling save() will do so by checking\nform.errors. A ValueError will be raised if the data in the form\ndoesn't validate -- i.e., if form.errors evaluates to True.
If an optional field doesn't appear in the form's data, the resulting model\ninstance uses the model field default, if\nthere is one, for that field. This behavior doesn't apply to fields that use\nCheckboxInput,\nCheckboxSelectMultiple, or\nSelectMultiple (or any custom widget whose\nvalue_omitted_from_data() method always returns\nFalse) since an unchecked checkbox and unselected <select multiple>\ndon't appear in the data of an HTML form submission. Use a custom form field or\nwidget if you're designing an API and want the default fallback behavior for a\nfield that uses one of these widgets.
This save() method accepts an optional commit keyword argument, which\naccepts either True or False. If you call save() with\ncommit=False, then it will return an object that hasn't yet been saved to\nthe database. In this case, it's up to you to call save() on the resulting\nmodel instance. This is useful if you want to do custom processing on the\nobject before saving it, or if you want to use one of the specialized\nmodel saving options. commit is True\nby default.
Another side effect of using commit=False is seen when your model has\na many-to-many relation with another model. If your model has a many-to-many\nrelation and you specify commit=False when you save a form, Django cannot\nimmediately save the form data for the many-to-many relation. This is because\nit isn't possible to save many-to-many data for an instance until the instance\nexists in the database.
To work around this problem, every time you save a form using commit=False,\nDjango adds a save_m2m() method to your ModelForm subclass. After\nyou've manually saved the instance produced by the form, you can invoke\nsave_m2m() to save the many-to-many form data. For example:
# 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()\nOther than the save() and save_m2m() methods, a ModelForm works\nexactly the same way as any other forms form. For example, the\nis_valid() method is used to check for validity, the is_multipart()\nmethod is used to determine whether a form requires multipart file upload (and\nhence whether request.FILES must be passed to the form), etc. See\nMengikat berkas terunggah ke formulir for more information.
It is strongly recommended that you explicitly set all fields that should be\nedited in the form using the fields attribute. Failure to do so can easily\nlead to security problems when a form unexpectedly allows a user to set certain\nfields, especially when new fields are added to a model. Depending on how the\nform is rendered, the problem may not even be visible on the web page.
The alternative approach would be to include all fields automatically, or\nremove only some. This fundamental approach is known to be much less secure\nand has led to serious exploits on major websites (e.g. GitHub).
\nThere are, however, two shortcuts available for cases where you can guarantee\nthese security concerns do not apply to you:
\nSetel atribut fields ke nilai khusus '__all__' untuk menunjukkan bahwa semua bidang-bidang dalam model harus digunakan. Sebagai contoh:
from django.forms import ModelForm\n\nclass AuthorForm(ModelForm):\n class Meta:\n model = Author\n fields = '__all__'\nSetel atribut exclude dari kelas Meta sebelah dalam ModelForm pada daftar dari bidang untuk tidak disertakan dari formulir.
Sebagai contoh:
\nclass PartialAuthorForm(ModelForm):\n class Meta:\n model = Author\n exclude = ['title']\nSince the Author model has the 3 fields name, title and\nbirth_date, this will result in the fields name and birth_date\nbeing present on the form.
If either of these are used, the order the fields appear in the form will be the\norder the fields are defined in the model, with ManyToManyField instances\nappearing last.
In addition, Django applies the following rule: if you set editable=False on\nthe model field, any form created from the model via ModelForm will not\ninclude that field.
The default field types, as described in the Field types table above, are\nsensible defaults. If you have a DateField in your model, chances are you'd\nwant that to be represented as a DateField in your form. But ModelForm\ngives you the flexibility of changing the form field for a given model.
Untuk menentukan widget penyesuaian untuk bidang, gunakan atribut widgets dari kelas Meta sebelah dalam. Ini harus berupa nama bidang pemetaan kamus pada kelas widget atau instance.
For example, if you want the CharField for the name attribute of\nAuthor to be represented by a <textarea> instead of its default\n<input type="text">, you can override the field's widget:
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 }\nThe widgets dictionary accepts either widget instances (e.g.,\nTextarea(...)) or classes (e.g., Textarea). Note that the widgets\ndictionary is ignored for a model field with a non-empty choices attribute.\nIn this case, you must override the form field to use a different widget.
Demikian pula, anda dapat menentukan atribut labels, help_texts dan error_messages dari kelas Meta sebelah dalam jika anda ingin lebih lanjut menyesuaikan bidang.
Sebagai contoh jika anda ingin menyesuaikan kata-kata dari semua pengguna menghadai string untuk bidang 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 }\nAnda dapat juga menentukan field_classes untuk menyesuaikan jenis dari bidang terinstansiasi berdasarkan formulir.
Sebagai contoh, jika anda ingin menggunakan MySlugFormField untuk bidang slug, anda dapat melakukan berikut:
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 }\nFinally, if you want complete control over of a field -- including its type,\nvalidators, required, etc. -- you can do this by declaratively specifying\nfields like you would in a regular Form.
If you want to specify a field's validators, you can do so by defining\nthe field declaratively and setting its validators parameter:
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']\nBy default, the fields in a ModelForm will not localize their data. To\nenable localization for fields, you can use the localized_fields\nattribute on the Meta class.
>>> 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',)\nJika localized_fields disetel menjadi nilai khusus '__all__', semua bidang akan dilokalkan.
As with basic forms, you can extend and reuse ModelForms by inheriting\nthem. This is useful if you need to declare extra fields or extra methods on a\nparent class for use in a number of forms derived from models. For example,\nusing the previous ArticleForm class:
>>> class EnhancedArticleForm(ArticleForm):\n... def clean_pub_date(self):\n... ...\nThis creates a form that behaves identically to ArticleForm, except there's\nsome extra validation and cleaning for the pub_date field.
Anda dapat juga mensubkelaskan kelas sebelah dalam Meta induk jika anda ingin merubah daftar Meta.fields atau Meta.exclude:
>>> class RestrictedArticleForm(EnhancedArticleForm):\n... class Meta(ArticleForm.Meta):\n... exclude = ('body',)\nThis adds the extra method from the EnhancedArticleForm and modifies\nthe original ArticleForm.Meta to remove one field.
Terdapat sepasang hal untuk dicatat, bagaimanapun.
\nNormal Python name resolution rules apply. If you have multiple base\nclasses that declare a Meta inner class, only the first one will be\nused. This means the child's Meta, if it exists, otherwise the\nMeta of the first parent, etc.
It's possible to inherit from both Form and ModelForm simultaneously,\nhowever, you must ensure that ModelForm appears first in the MRO. This is\nbecause these classes rely on different metaclasses and a class can only have\none metaclass.
It's possible to declaratively remove a Field inherited from a parent class by\nsetting the name to be None on the subclass.
You can only use this technique to opt out from a field defined declaratively\nby a parent class; it won't prevent the ModelForm metaclass from generating\na default field. To opt-out from default fields, see\nMemilih bidang untuk digunakan.
As with regular forms, it's possible to specify initial data for forms by\nspecifying an initial parameter when instantiating the form. Initial\nvalues provided this way will override both initial values from the form field\nand values from an attached model instance. For example:
>>> 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'\nAnda dapat membuat formulir dari model yang diberikan menggunakan fungsi berdiri sendiri modelform_factory(), daripada menggunakan pengertian kelas. Ini mungkin lebih nyaman jika anda tidak memiliki banyak penyesuaian untuk dibuat:
>>> from django.forms import modelform_factory\n>>> from myapp.models import Book\n>>> BookForm = modelform_factory(Book, fields=("author", "title"))\nThis can also be used to make modifications to existing forms, for example by\nspecifying the widgets to be used for a given field:
\n>>> from django.forms import Textarea\n>>> Form = modelform_factory(Book, form=BookForm,\n... widgets={"title": Textarea()})\nBidang-bidang untuk disertakan dapat ditentukan menggunakan argumen katakunci fields dan exclude, atau atribut-atribut sesuai pada ModelForm didalam kelas Meta. Harap lihat dokumentasi Memilih bidang untuk digunakan ModelForm.
... atau adakan lokalisasi untuk bidang khusus:
\n>>> Form = modelform_factory(Author, form=AuthorForm, localized_fields=("birth_date",))\nLike regular formsets, Django provides a couple\nof enhanced formset classes to make working with Django models more\nconvenient. Let's reuse the Author model from above:
>>> from django.forms import modelformset_factory\n>>> from myapp.models import Author\n>>> AuthorFormSet = modelformset_factory(Author, fields=('name', 'title'))\nUsing fields restricts the formset to use only the given fields.\nAlternatively, you can take an "opt-out" approach, specifying which fields to\nexclude:
>>> AuthorFormSet = modelformset_factory(Author, exclude=('birth_date',))\nThis will create a formset that is capable of working with the data associated\nwith the Author model. It works just like a regular 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-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<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>\nBy default, when you create a formset from a model, the formset will use a\nqueryset that includes all objects in the model (e.g.,\nAuthor.objects.all()). You can override this behavior by using the\nqueryset argument:
>>> formset = AuthorFormSet(queryset=Author.objects.filter(name__startswith='O'))\nAlternatifnya, anda dapat membuat sub kelas yang mensetel self.queryset dalam __init__:
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')\nKemudian, lewati kelas BaseAuthorFormSet anda ke fungsi pabrik:
>>> AuthorFormSet = modelformset_factory(\n... Author, fields=('name', 'title'), formset=BaseAuthorFormSet)\nIf you want to return a formset that doesn't include any pre-existing\ninstances of the model, you can specify an empty QuerySet:
\n>>> AuthorFormSet(queryset=Author.objects.none())\nBy default, when you use modelformset_factory, a model form will\nbe created using modelform_factory().\nOften, it can be useful to specify a custom model form. For example,\nyou can create a custom model form that has custom validation:
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 ...\nKemudian, lewati formulir model anda ke fungsi pabrik:
\nAuthorFormSet = modelformset_factory(Author, form=AuthorForm)\nIt is not always necessary to define a custom model form. The\nmodelformset_factory function has several arguments which are\npassed through to modelform_factory, which are described below.
widgetsLink to this heading#Using the widgets parameter, you can specify a dictionary of values to\ncustomize the ModelForm’s widget class for a particular field. This\nworks the same way as the widgets dictionary on the inner Meta\nclass of a ModelForm works:
>>> AuthorFormSet = modelformset_factory(\n... Author, fields=('name', 'title'),\n... widgets={'name': Textarea(attrs={'cols': 80, 'rows': 20})})\nlocalized_fieldsLink to this heading#Menggunakan parameter localized_fields, anda dapat mengadakan lokalisasi untuk bidang ini dalam formulir.
>>> AuthorFormSet = modelformset_factory(\n... Author, fields=('name', 'title', 'birth_date'),\n... localized_fields=('birth_date',))\nJika localized_fields disetel menjadi nilai khusus '__all__', semua bidang akan dilokalkan.
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.
Lewati commit=False untuk mengembalikan instance model tidak tersimpan:
# 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 tidak mencegah obyek yang ada dari menjadi ditampilkan:
>>> 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 send additional POST data. Formsets don't yet provide functionality for an "edit only" view that prevents 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>\nSebuah nilai max_num dari None (awalan) menaruh batasan tinggi pada sejumlah formulir-formulir ditampilkan (1000). Dalam praktiknya ini adalah setara pada tidak ada batasan.
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() pada sebuah 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\nSeperti dinyatakan sebelumnya, anda dapat menimpa queryset awalan digunakan oleh formset model:
\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 queryset = Author.objects.filter(name__startswith='O')\n if request.method == "POST":\n formset = AuthorFormSet(\n request.POST, 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})\nCatat bahwa kami melewatkan argumen queryset dalam kedua kasus POST dan GET dalam contoh ini.
Ada tiga cara untuk mengirim sebuah formset dalam sebuah cetakan Django.
\nPertama, anda dapat membiarkan formset melakukan sebagian besar pekerjaan:
\n<form method="post">\n {{ formset }}\n</form>\nKedua, anda dapat secara manual membangun formset, tetapi membiarkan formulir berurusan dengan itu sendiri:
\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.
\nKetiga, anda dapat secara manual membangun setiap bidang:
\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.)
Formset berderet adalah lapisan abstraksi kecil pada atas formset model. Ini menyederhanakan kasus dari bekerja dengan obyek-obyek terkait melalui sebuah foreign key. Seandainya anda mempunyai dua model ini:
\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.
Sebagai contoh, jika anda ingin menimpa 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 ...\nLihat juga Menimpa clean() pada sebuah ModelFormSet.
\nKemudian ketika anda membuat formset berderet anda, lewatkan di argumen pilihan formset:
>>> 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()\nUntuk mengatasi ini, anda dapat menggunakan fk_name pada inlineformset_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})\nPerhatikan bagaimana kami melewatkan instance dalam kedua kasus POST dan GET.
inlineformset_factory menggunakan modelformset_factory dan melewatkan kebanyakan argumennya ke modelformset_factory. Ini berarti anda dapat menggunakan parameter widgets dalam banyak cara yang sama ketika melewatkan itu ke modelformset_factory. Lihat Specifying widgets to use in the form with widgets diatas.