---
title: "Foirmeacha"
version: 6.0
locale: ga
source: https://docs.djangoproject.com/ga/6.0/topics/forms/formsets/
canonical: https://djangodocs.dev/ga/6.0/topics/forms/formsets/
---
# Foirmeacha

#### `class BaseFormSet`

Is sraith teastartha é foirmshraith chun oibriú le foirmeacha iolracha ar an leathanach céanna. Is féidir é a bheith is fearr i gcomparáid le greille sonraí. Abair go bhfuil an fhoirm seo a leanas agat:

```pycon
>>> from django import forms
>>> class ArticleForm(forms.Form):
...     title = forms.CharField()
...     pub_date = forms.DateField()
...
```

B'fhéidir gur mhaith leat ligean don úsáideoir roinnt alt a chruthú ag an am céanna. Chun foirm a chruthú as `Airteagal Form` déanfaí an méid seo a leanas:

```pycon
>>> from django.forms import formset_factory
>>> ArticleFormSet = formset_factory(ArticleForm)
```

Tá rang formset cruthaithe agat anois darb ainm `ArticleFormSet`. Tugann an tacar foirmeacha a thaispeáint tugtar an cumas duit athrá a dhéanamh thar na foirmeacha sa tacar foirme agus iad a thaispeáint mar a dhéanfá le foirm rialta:

```pycon
>>> formset = ArticleFormSet()
>>> for form in formset:
...     print(form)
...
<div><label for="id_form-0-title">Title:</label><input type="text" name="form-0-title" id="id_form-0-title"></div>
<div><label for="id_form-0-pub_date">Pub date:</label><input type="text" name="form-0-pub_date" id="id_form-0-pub_date"></div>
```

Mar a fheiceann tú ní thaispeánann sé ach foirm folamh amháin. Tá líon na bhfoirmeacha folamh a thaispeántar á rialú ag an bparaiméadar `breise`. De réir réamhshocraithe, :func: ~django.forms.formsets.formsets.formset\_factory sainmhíníonn foirm bhreise amháin; cruthóidh an sampla seo a leanas rang formset chun dhá fhoirm bán a thaispeáint:

```pycon
>>> ArticleFormSet = formset_factory(ArticleForm, extra=2)
```

Formsets can be iterated and indexed, accessing forms in the order they were
created. You can reorder the forms by overriding the default
[`iteration`](https://docs.python.org/3/reference/datamodel.html#object.__iter__) and
[`indexing`](https://docs.python.org/3/reference/datamodel.html#object.__getitem__) behavior if needed.

## Sonraí tosaigh a úsáid le tacar foirme

Is iad na sonraí tosaigh an rud a spreagann príomh-inúsáidteacht foirmshraith. Mar a thaispeántar thuas is féidir leat líon na bhfoirmeacha breise a shainiú. Is é an rud a chiallaíonn sé seo ná go bhfuil tú ag insint don fhoirm cé mhéad foirm bhreise atá le taispeáint i dteannta leis an líon foirmeacha a ghineann sé ó na sonraí tosaigh. Breathnaímid ar shampla:

```pycon
>>> import datetime
>>> from django.forms import formset_factory
>>> from myapp.forms import ArticleForm
>>> ArticleFormSet = formset_factory(ArticleForm, extra=2)
>>> formset = ArticleFormSet(
...     initial=[
...         {
...             "title": "Django is now open source",
...             "pub_date": datetime.date.today(),
...         }
...     ]
... )

>>> for form in formset:
...     print(form)
...
<div><label for="id_form-0-title">Title:</label><input type="text" name="form-0-title" value="Django is now open source" id="id_form-0-title"></div>
<div><label for="id_form-0-pub_date">Pub date:</label><input type="text" name="form-0-pub_date" value="2023-02-11" id="id_form-0-pub_date"></div>
<div><label for="id_form-1-title">Title:</label><input type="text" name="form-1-title" id="id_form-1-title"></div>
<div><label for="id_form-1-pub_date">Pub date:</label><input type="text" name="form-1-pub_date" id="id_form-1-pub_date"></div>
<div><label for="id_form-2-title">Title:</label><input type="text" name="form-2-title" id="id_form-2-title"></div>
<div><label for="id_form-2-pub_date">Pub date:</label><input type="text" name="form-2-pub_date" id="id_form-2-pub_date"></div>
```

Tá trí fhoirm san iomlán anois ag taispeáint thuas. Ceann amháin do na sonraí tosaigh a cuireadh isteach agus dhá fhoirm bhreise. Tabhair faoi deara freisin go bhfuilimid ag dul isteach i liosta foclóirí mar na sonraí tosaigh.

Má úsáideann tú `tosaithe` chun tacar foirme a thaispeáint, ba cheart duit an `tosaitheach` céanna a rith agus tú ag próiseáil aighneacht foirmeacha sin ionas gur féidir leis an tacar foirme a bhrath cé na foirmeacha a d'athraigh an t-úsáideoir. Mar shampla, b'fhéidir go mbeadh rud éigin cosúil le: `ArticleFormSet (request.post, initial= [...])`.

> **See also**
>
> \<model-formsets\>:ref: Foirmeacha a chruthú ó mhúnlaí le foirmeacha samhail .

## An líon uasta na bhfoirmeacha a theorannú

Tugann an paraiméadar `max_num` to:func: ~django.forms.formsets.formset\_factory an cumas duit líon na bhfoirmeacha a thaispeánfaidh an formset a theorannú:

```pycon
>>> from django.forms import formset_factory
>>> from myapp.forms import ArticleForm
>>> ArticleFormSet = formset_factory(ArticleForm, extra=2, max_num=1)
>>> formset = ArticleFormSet()
>>> for form in formset:
...     print(form)
...
<div><label for="id_form-0-title">Title:</label><input type="text" name="form-0-title" id="id_form-0-title"></div>
<div><label for="id_form-0-pub_date">Pub date:</label><input type="text" name="form-0-pub_date" id="id_form-0-pub_date"></div>
```

Má tá luach `max_num` níos mó ná líon na míreanna atá ann cheana sna sonraí tosaigh, cuirfear foirmeacha bán breise suas le `extra` leis an tacar foirmeacha, fad nach mbeidh líon iomlán na bhfoirmeacha níos mó ná `max_num`. Mar shampla, má tá `extra=2` agus `max_num=2` agus má thosaítear an foirmshraith le mír `initial` amháin, taispeánfar foirm don mhír tosaigh agus foirm bán amháin.

Má sháraíonn líon na míreanna sna sonraí tosaigh `max_num`, taispeánfar gach foirm sonraí tosaigh beag beann ar luach `max_num` agus ní thaispeánfar aon fhoirmeacha breise. Mar shampla, má tá `extra=3` agus `max_num=1` agus má dhá mhír tosaigh an foirmeach a thosú, taispeánfar dhá fhoirm leis na sonraí tosaigh.

Cuireann luach `max_num` de `None` (an réamhshocrú) teorainn ard ar líon na bhfoirmeacha a thaispeántar (1000). Go praiticiúil tá sé seo coibhéiseach le haon teorainn.

By default, `max_num` only affects how many forms are displayed and does not
affect validation. If `validate_max=True` is passed to the
[`formset_factory()`](/ga/6.0/ref/forms/formsets/#django.forms.formsets.formset_factory), then `max_num` will affect
validation. See [bailite\_max](#validate-max).

## Uaslíon na bhfoirmeacha ionchasacha a theorannú

Ceadaíonn an paraiméadar `absolute_max` to:func: .formset\_factory líon na bhfoirmeacha is féidir a dhéanamh a theorannú nuair a sholáthraítear sonraí POST \`. Cosnaíonn sé seo i gcoinne ionsaithe ídithe cuimhne ag úsáid iarratais brionnaithe POST \`\`

```pycon
>>> from django.forms.formsets import formset_factory
>>> from myapp.forms import ArticleForm
>>> ArticleFormSet = formset_factory(ArticleForm, absolute_max=1500)
>>> data = {
...     "form-TOTAL_FORMS": "1501",
...     "form-INITIAL_FORMS": "0",
... }
>>> formset = ArticleFormSet(data)
>>> len(formset.forms)
1500
>>> formset.is_valid()
False
>>> formset.non_form_errors()
['Please submit at most 1000 forms.']
```

Nuair is é `absolute_max` ```None ``, réamhshocraithe é go ``max_num + 1000```. (Má tá `` `max_num `` ```None ``, réamhshocraithe é go ``2000```).

Má tá `absolute_max` níos lú ná `max_num`, ardófar `Error lua`.

## Bailíochtú Formset

Tá bailíochtú le tacar foirme beagnach comhionann le ```Foirm ``rialta. Tá modh ``is_valid``` ar an tacar foirmeacha chun bealach áisiúil a sholáthar chun gach foirm sa tacar foirme a bhailíochtú:

```pycon
>>> from django.forms import formset_factory
>>> from myapp.forms import ArticleForm
>>> ArticleFormSet = formset_factory(ArticleForm)
>>> data = {
...     "form-TOTAL_FORMS": "1",
...     "form-INITIAL_FORMS": "0",
... }
>>> formset = ArticleFormSet(data)
>>> formset.is_valid()
True
```

Níor chuireamar aon sonraí isteach chuig an tacar foirme a bhfuil foirm bhailí mar thoradh air. Tá an tacar foirmeacha cliste go leor chun neamhaird a dhéanamh ar fhoirmeacha breise nár athraíodh. Má sholáthraímid alt neamhbhailí:

```pycon
>>> data = {
...     "form-TOTAL_FORMS": "2",
...     "form-INITIAL_FORMS": "0",
...     "form-0-title": "Test",
...     "form-0-pub_date": "1904-06-16",
...     "form-1-title": "Test",
...     "form-1-pub_date": "",  # <-- this date is missing but required
... }
>>> formset = ArticleFormSet(data)
>>> formset.is_valid()
False
>>> formset.errors
[{}, {'pub_date': ['This field is required.']}]
```

Mar a fheicimid, is liosta é `formset.errors` a fhreagraíonn a n-iontrálacha do na foirmeacha sa tacar foirmeacha. Rinneadh bailíochtú do gach ceann den dá fhoirm, agus tá an teachtaireacht earráide ag súil leis le feiceáil don dara mír.

Díreach cosúil le gnáth-Foirm \`\`á n-úsáid, d'fhéadfadh tréithe HTML mar \`\`maxlength\` a bheith san áireamh i ngach réimse i bhfoirmeacha foirmeacha le haghaidh bailíochtaithe brabhsálaí. Mar sin féin, ní chuimsíonn réimsí foirmeacha foirmeacha an tréith `riachtan` mar d'fhéadfadh an bailíochtú sin a bheith mícheart agus foirmeacha á gcur leis agus á scriosadh.

#### `BaseFormSet.total_error_count()`

Chun a sheiceáil cé mhéad earráid atá sa fhoirmset, is féidir linn an modh total\_error\_count\` a úsáid:

```pycon
>>> # Using the previous example
>>> formset.errors
[{}, {'pub_date': ['This field is required.']}]
>>> len(formset.errors)
2
>>> formset.total_error_count()
1
```

Is féidir linn a sheiceáil freisin an bhfuil sonraí foirme difriúil ó na sonraí tosaigh (ie seoladh an fhoirm gan aon sonraí):

```pycon
>>> data = {
...     "form-TOTAL_FORMS": "1",
...     "form-INITIAL_FORMS": "0",
...     "form-0-title": "",
...     "form-0-pub_date": "",
... }
>>> formset = ArticleFormSet(data)
>>> formset.has_changed()
False
```

### An “Foirm Bainistíochta” a thuiscint

B'fhéidir gur thug tú faoi deara na sonraí breise (`Form-Total_Forms`, Form-Initial\_Forms\`) a bhí ag teastáil i sonraí an fhoirmscair thuas. Tá na sonraí seo ag teastáil don Foirm Bainistíochta . Úsáideann an tacar foirmeacha seo chun bailiúchán na bhfoirmeacha atá sa tacar foirme a bhainistiú. Mura gcuireann tú na sonraí bainistíochta seo ar fáil, beidh an tacar foirme neamhbhailí:

```pycon
>>> data = {
...     "form-0-title": "Test",
...     "form-0-pub_date": "",
... }
>>> formset = ArticleFormSet(data)
>>> formset.is_valid()
False
```

Úsáidtear é chun súil a choinneáil ar cé mhéad cásanna foirme atá á thaispeáint. Má tá foirmeacha nua á chur agat trí JavaScript, ba cheart duit na réimsí comhaireamh san fhoirm seo a mhéadú freisin. Ar an láimh eile, má tá JavaScript á úsáid agat chun rudaí atá ann cheana a scriosadh, ansin ní mór duit a chinntiú go ndéantar na cinn atá á mbaintear marcáilte i gceart lena scriosadh trí `Form-#-delete` a chur san áireamh sna sonraí POST \`. Táthar ag súil go mbeidh gach foirm i láthair sna sonraí POST beag beann.

Tá an fhoirm bhainistíochta ar fáil mar thréith den tacar foirme féin. Agus tacar foirme á rindreáil i dteimpléad, is féidir leat na sonraí bainistíochta go léir a chur san áireamh trí {{my\_formset.management\_form}} a rindreáil (ainm do thacar foirme a chur in ionad mar is cuí).

> **Note**
>
> Chomh maith leis na réimsí `Form-Total_Forms` agus `Form-Initial_Forms` a thaispeántar sna samplaí anseo, cuimsíonn an fhoirm bhainistíochta réimsí `Form-Min_Num_Forms` agus Form-Max\_Num\_Forms freisin. Tá siad aschur leis an gcuid eile den fhoirm bhainistíochta, ach amháin ar mhaithe le háisiúlacht cód taobh an chliaint. Níl na réimsí seo ag teastáil agus mar sin ní thaispeántar iad sa shampla sonraí POST .

### `comhaireann_foirme_iomlán` agus `comhaireann_foirme_tosaithe`

Tá cúpla modh ag `BaseFormSet` a bhfuil dlúthbhaint acu leis an `ManagementForm`, total\_form\_count\` agus `initial_form_count`.

Tugann `total_form_count` líon iomlán na bhfoirmeacha sa tacar foirme seo ar ais. Tugann `initial_form_count` líon na bhfoirmeacha sa tacar foirme a rinneadh réamh-líonadh, agus úsáidtear é freisin chun a chinneadh cé mhéad foirm atá ag teastáil. Is dócha nach mbeidh ort riamh ceachtar de na modhanna seo a shárú, mar sin bí cinnte le do thoil go dtuigeann tú cad a dhéanann siad sula ndéanann siad é sin.

### `foirme_folam`

Soláthraíonn `BaseFormSet` tréith bhreise `empty_form` a thugann sampla foirme le réimír `__prefix__` le húsáid níos éasca i bhfoirmeacha dinimiciúla le JavaScript.

### `teachtaireachtaí earráid`

Ligeann an argóint `error_messages` duit na teachtaireachtaí réamhshocraithe a ardóidh an foirmset a shárú. Pas isteach i bhfoclóir le heochracha a mheaitseálann leis na teachtaireachtaí earráide is mian leat a shárú. I measc na heochracha teachtaireachta earráide tá `` `too_few_forms' ``, `too_many_forms'`, agus `` `missing_management_form' ``. D'fhéadfadh go mbeadh `% (num) d` sna teachtaireachtaí earráide `` `too_few_forms' `` agus `` `too_many_forms' ``, agus `max_num`, ina gcuirfear min\_num\` agus `max_num` in ionad `min_num` faoi seach.

Mar shampla, seo an teachtaireacht earráide réamhshocraithe nuair a bhíonn an fhoirm bhainistíochta in easnamh:

```pycon
>>> formset = ArticleFormSet({})
>>> formset.is_valid()
False
>>> formset.non_form_errors()
['ManagementForm data is missing or has been tampered with. Missing fields: form-TOTAL_FORMS, form-INITIAL_FORMS. You may need to file a bug report if the issue persists.']
```

Agus seo teachtaireacht earráide saincheaptha:

```pycon
>>> formset = ArticleFormSet(
...     {}, error_messages={"missing_management_form": "Sorry, something went wrong."}
... )
>>> formset.is_valid()
False
>>> formset.non_form_errors()
['Sorry, something went wrong.']
```

### Bailíochtú foirm saincheaptha

Tá modh ```glan ``ag tacar foirme cosúil leis an gceann ar rang ``Foirme```. Seo an áit a shainmhíníonn tú do bhailíochtú féin a oibríonn ag an leibhéal foirmset:

```pycon
>>> from django.core.exceptions import ValidationError
>>> from django.forms import BaseFormSet
>>> from django.forms import formset_factory
>>> from myapp.forms import ArticleForm

>>> class BaseArticleFormSet(BaseFormSet):
...     def clean(self):
...         """Checks that no two articles have the same title."""
...         if any(self.errors):
...             # Don't bother validating the formset unless each form is valid on its own
...             return
...         titles = set()
...         for form in self.forms:
...             if self.can_delete and self._should_delete_form(form):
...                 continue
...             title = form.cleaned_data.get("title")
...             if title in titles:
...                 raise ValidationError("Articles in a set must have distinct titles.")
...             titles.add(title)
...

>>> ArticleFormSet = formset_factory(ArticleForm, formset=BaseArticleFormSet)
>>> data = {
...     "form-TOTAL_FORMS": "2",
...     "form-INITIAL_FORMS": "0",
...     "form-0-title": "Test",
...     "form-0-pub_date": "1904-06-16",
...     "form-1-title": "Test",
...     "form-1-pub_date": "1912-06-23",
... }
>>> formset = ArticleFormSet(data)
>>> formset.is_valid()
False
>>> formset.errors
[{}, {}]
>>> formset.non_form_errors()
['Articles in a set must have distinct titles.']
```

Tugtar ar an modh ```clean ``foirmeacha tar éis na modhanna ``Form.clean``` go léir a ghlaoch. Faighfear na hearráidí ag baint úsáide as an modh non\_form\_errors () ar an tacar foirme.

Déanfar earráidí neamh-fhoirme a thabhairt le aicme breise de `neamhfhoirme` chun cabhrú leo a idirdhealú ó earráidí foirm-shonracha. Mar shampla, bheadh cuma {{formset.non\_form\_errors}} :

```html+django
<ul class="errorlist nonform">
    <li>Articles in a set must have distinct titles.</li>
</ul>
```

## Líon na bhfoirmeacha i dtacar foirmeacha a bhailíochtú

Soláthraíonn Django cúpla bealach chun líon íosta nó uasta na bhfoirmeacha curtha isteach a bhailíochtú. Ba cheart d'iarratais a dteastaíonn bailíochtú níos inúsáidte uathu ar líon na bhfoirmeacha bailíochtú saincheaptha

### `bailite_max`

Má chuirtear `validate_max=True` chuig: :func: ~django.forms.formsets.formset\_factory, seiceálfaidh bailíochtú freisin go bhfuil líon na bhfoirmeacha sa tacar sonraí, lúide iad siúd atá marcáilte le scriosadh, níos lú ná max\_\`num\` nó cothrom le max\_\`num.

```pycon
>>> from django.forms import formset_factory
>>> from myapp.forms import ArticleForm
>>> ArticleFormSet = formset_factory(ArticleForm, max_num=1, validate_max=True)
>>> data = {
...     "form-TOTAL_FORMS": "2",
...     "form-INITIAL_FORMS": "0",
...     "form-0-title": "Test",
...     "form-0-pub_date": "1904-06-16",
...     "form-1-title": "Test 2",
...     "form-1-pub_date": "1912-06-23",
... }
>>> formset = ArticleFormSet(data)
>>> formset.is_valid()
False
>>> formset.errors
[{}, {}]
>>> formset.non_form_errors()
['Please submit at most 1 form.']
```

`validate_max=Bailíonn True` i gcoinne `max_num` go docht fiú má sháraíodh `max_num` toisc go raibh méid na sonraí tosaigh a sholáthraíodh iomarcach.

Is féidir an teachtaireacht earráide a shaincheapadh tríd an teachtaireacht too\_many\_forms' a chur chuig an argóint:ref: formsets-error-messages.

> **Note**
>
> Beag beann ar `validate_max`, má sháraíonn líon na bhfoirmeacha i tacar sonraí `absolute_max`, ansin teipeann ar an bhfoirm a bhailíochtú amhail is dá gcuirfí validate\_max\` socraithe, agus ina theannta sin ní bheidh ach na chéad fhoirmeacha absolute\_max\` bailíochtaithe. Déanfar an chuid eile a ghearradh go hiomlán. Déanann sé seo chun cosaint a dhéanamh ar ionsaithe ídithe cuimhne ag baint úsáide as iarrat Féach: tagairt: formsets-absolute-max.

### `bailate_min`

Má chuirtear `validate_min=True` chuig: :func: ~django.forms.formsets.formset\_factory, seiceálfaidh bailíochtú freisin go bhfuil líon na bhfoirmeacha sa tacar sonraí, lúide iad siúd atá marcáilte le scriosadh, níos mó ná min\_\`num\` nó cothrom le min\_\`num.

```pycon
>>> from django.forms import formset_factory
>>> from myapp.forms import ArticleForm
>>> ArticleFormSet = formset_factory(ArticleForm, min_num=3, validate_min=True)
>>> data = {
...     "form-TOTAL_FORMS": "2",
...     "form-INITIAL_FORMS": "0",
...     "form-0-title": "Test",
...     "form-0-pub_date": "1904-06-16",
...     "form-1-title": "Test 2",
...     "form-1-pub_date": "1912-06-23",
... }
>>> formset = ArticleFormSet(data)
>>> formset.is_valid()
False
>>> formset.errors
[{}, {}]
>>> formset.non_form_errors()
['Please submit at least 3 forms.']
```

Is féidir an teachtaireacht earráide a shaincheapadh tríd an teachtaireacht too\_few\_forms' a chur chuig argóint:ref: formsets-error-messages.

> **Note**
>
> Beag beann ar `validate_min`, mura bhfuil aon sonraí i bhfoirmshraith, taispeánfar foirmeacha folamh `extra + min_num`.

## Déileáil le foirmeacha a ordú agus a scriosadh

Soláthraíonn an: Func: ~django.forms.formsets.formset\_factory dhá pharaiméadar roghnach `can_order` agus `can_delete` chun cabhrú le foirmeacha a ordú i bhfoirmeacha agus foirmeacha a scriosadh ó fhoirmshraith.

### Is féidir \_ordú \`\`

#### `BaseFormSet.can_order`

Réamhshocraithe: `Fréag`

Ligeann duit tacar foirme a chruthú leis an gcumas a ordú:

```pycon
>>> from django.forms import formset_factory
>>> from myapp.forms import ArticleForm
>>> ArticleFormSet = formset_factory(ArticleForm, can_order=True)
>>> formset = ArticleFormSet(
...     initial=[
...         {"title": "Article #1", "pub_date": datetime.date(2008, 5, 10)},
...         {"title": "Article #2", "pub_date": datetime.date(2008, 5, 11)},
...     ]
... )
>>> for form in formset:
...     print(form)
...
<div><label for="id_form-0-title">Title:</label><input type="text" name="form-0-title" value="Article #1" id="id_form-0-title"></div>
<div><label for="id_form-0-pub_date">Pub date:</label><input type="text" name="form-0-pub_date" value="2008-05-10" id="id_form-0-pub_date"></div>
<div><label for="id_form-0-ORDER">Order:</label><input type="number" name="form-0-ORDER" value="1" id="id_form-0-ORDER"></div>
<div><label for="id_form-1-title">Title:</label><input type="text" name="form-1-title" value="Article #2" id="id_form-1-title"></div>
<div><label for="id_form-1-pub_date">Pub date:</label><input type="text" name="form-1-pub_date" value="2008-05-11" id="id_form-1-pub_date"></div>
<div><label for="id_form-1-ORDER">Order:</label><input type="number" name="form-1-ORDER" value="2" id="id_form-1-ORDER"></div>
<div><label for="id_form-2-title">Title:</label><input type="text" name="form-2-title" id="id_form-2-title"></div>
<div><label for="id_form-2-pub_date">Pub date:</label><input type="text" name="form-2-pub_date" id="id_form-2-pub_date"></div>
<div><label for="id_form-2-ORDER">Order:</label><input type="number" name="form-2-ORDER" id="id_form-2-ORDER"></div>
```

Cuireann sé seo réimse breise le gach foirm. Ainmnítear `ORDER` ar an réimse nua seo agus is `Forms.IntegerField` é. Maidir leis na foirmeacha a tháinig ó na sonraí tosaigh sé luach uimhriúil dóibh go huathoibríoch. Breathnaímid ar cad a tharlóidh nuair a athraíonn an t-úsáideoir na luachanna seo:

```pycon
>>> data = {
...     "form-TOTAL_FORMS": "3",
...     "form-INITIAL_FORMS": "2",
...     "form-0-title": "Article #1",
...     "form-0-pub_date": "2008-05-10",
...     "form-0-ORDER": "2",
...     "form-1-title": "Article #2",
...     "form-1-pub_date": "2008-05-11",
...     "form-1-ORDER": "1",
...     "form-2-title": "Article #3",
...     "form-2-pub_date": "2008-05-01",
...     "form-2-ORDER": "0",
... }

>>> formset = ArticleFormSet(
...     data,
...     initial=[
...         {"title": "Article #1", "pub_date": datetime.date(2008, 5, 10)},
...         {"title": "Article #2", "pub_date": datetime.date(2008, 5, 11)},
...     ],
... )
>>> for form in formset.ordered_forms:
...     print(form.cleaned_data)
...
{'title': 'Article #3', 'pub_date': datetime.date(2008, 5, 1), 'ORDER': 0}
{'title': 'Article #2', 'pub_date': datetime.date(2008, 5, 11), 'ORDER': 1}
{'title': 'Article #1', 'pub_date': datetime.date(2008, 5, 10), 'ORDER': 2}
```

[`BaseFormSet`](#django.forms.formsets.BaseFormSet) also provides an
[`ordering_widget`](#django.forms.formsets.BaseFormSet.ordering_widget) attribute and
[`get_ordering_widget()`](#django.forms.formsets.BaseFormSet.get_ordering_widget) method that
control the widget used with
[`can_order`](#django.forms.formsets.BaseFormSet.can_order).

#### `ording_widget`

#### `BaseFormSet.ordering_widget`

Réamhshocraithe: :class: ~django.forms.numberInput

Socraigh `ordering_widget` chun an rang giuirléid atá le húsáid le `can_order` a shonrú:

```pycon
>>> from django.forms import BaseFormSet, formset_factory
>>> from myapp.forms import ArticleForm
>>> class BaseArticleFormSet(BaseFormSet):
...     ordering_widget = HiddenInput
...

>>> ArticleFormSet = formset_factory(
...     ArticleForm, formset=BaseArticleFormSet, can_order=True
... )
```

#### `faigh_ording_widget`

#### `BaseFormSet.get_ordering_widget()`

Athraigh ```get_ordering_widget () ``más gá duit sampla giuirléid a sholáthar le húsáid le ``can_order```:

```pycon
>>> from django.forms import BaseFormSet, formset_factory
>>> from myapp.forms import ArticleForm
>>> class BaseArticleFormSet(BaseFormSet):
...     def get_ordering_widget(self):
...         return HiddenInput(attrs={"class": "ordering"})
...

>>> ArticleFormSet = formset_factory(
...     ArticleForm, formset=BaseArticleFormSet, can_order=True
... )
```

### `` `is féidir _scriosa ``

#### `BaseFormSet.can_delete`

Réamhshocraithe: `Fréag`

Ligeann duit tacar foirme a chruthú leis an gcumas foirmeacha a roghnú le scriosadh:

```pycon
>>> from django.forms import formset_factory
>>> from myapp.forms import ArticleForm
>>> ArticleFormSet = formset_factory(ArticleForm, can_delete=True)
>>> formset = ArticleFormSet(
...     initial=[
...         {"title": "Article #1", "pub_date": datetime.date(2008, 5, 10)},
...         {"title": "Article #2", "pub_date": datetime.date(2008, 5, 11)},
...     ]
... )
>>> for form in formset:
...     print(form)
...
<div><label for="id_form-0-title">Title:</label><input type="text" name="form-0-title" value="Article #1" id="id_form-0-title"></div>
<div><label for="id_form-0-pub_date">Pub date:</label><input type="text" name="form-0-pub_date" value="2008-05-10" id="id_form-0-pub_date"></div>
<div><label for="id_form-0-DELETE">Delete:</label><input type="checkbox" name="form-0-DELETE" id="id_form-0-DELETE"></div>
<div><label for="id_form-1-title">Title:</label><input type="text" name="form-1-title" value="Article #2" id="id_form-1-title"></div>
<div><label for="id_form-1-pub_date">Pub date:</label><input type="text" name="form-1-pub_date" value="2008-05-11" id="id_form-1-pub_date"></div>
<div><label for="id_form-1-DELETE">Delete:</label><input type="checkbox" name="form-1-DELETE" id="id_form-1-DELETE"></div>
<div><label for="id_form-2-title">Title:</label><input type="text" name="form-2-title" id="id_form-2-title"></div>
<div><label for="id_form-2-pub_date">Pub date:</label><input type="text" name="form-2-pub_date" id="id_form-2-pub_date"></div>
<div><label for="id_form-2-DELETE">Delete:</label><input type="checkbox" name="form-2-DELETE" id="id_form-2-DELETE"></div>
```

Cosúil le `can_order` cuireann sé seo réimse nua le gach foirm darb ainm `DELETE` agus is `Forms.BooleanField` é. Nuair a thagann sonraí trí aon cheann de na réimsí scriosta a mharcáil is féidir leat rochtain a fháil orthu le deleted\_forms\`:

```pycon
>>> data = {
...     "form-TOTAL_FORMS": "3",
...     "form-INITIAL_FORMS": "2",
...     "form-0-title": "Article #1",
...     "form-0-pub_date": "2008-05-10",
...     "form-0-DELETE": "on",
...     "form-1-title": "Article #2",
...     "form-1-pub_date": "2008-05-11",
...     "form-1-DELETE": "",
...     "form-2-title": "",
...     "form-2-pub_date": "",
...     "form-2-DELETE": "",
... }

>>> formset = ArticleFormSet(
...     data,
...     initial=[
...         {"title": "Article #1", "pub_date": datetime.date(2008, 5, 10)},
...         {"title": "Article #2", "pub_date": datetime.date(2008, 5, 11)},
...     ],
... )
>>> [form.cleaned_data for form in formset.deleted_forms]
[{'title': 'Article #1', 'pub_date': datetime.date(2008, 5, 10), 'DELETE': True}]
```

Má tá a: class: ModelFormSet \<django.forms.models.BaseModelFormSet\>\`á úsáid agat, scriosfar cásanna samhail d'fhoirmeacha scriosta nuair a ghlaonn tú ar \`\`formset.save () \`.

If you call `formset.save(commit=False)`, objects will not be deleted
automatically. You'll need to call `delete()` on each of the
[`formset.deleted_objects`](/ga/6.0/topics/forms/modelforms/#django.forms.models.BaseModelFormSet.deleted_objects) to actually delete
them:

```pycon
>>> instances = formset.save(commit=False)
>>> for obj in formset.deleted_objects:
...     obj.delete()
...
```

Ar an láimh eile, má tá simplí ```formSet ``á úsáid agat, is fútsa atá sé `formset.deleted_forms``` a láimhseáil, b'fhéidir i modh save ()\` do fhoirmset, mar níl aon smaoineamh ginearálta ann faoi cad a chiallaíonn sé foirm a scriosadh.

[`BaseFormSet`](#django.forms.formsets.BaseFormSet) also provides a
[`deletion_widget`](#django.forms.formsets.BaseFormSet.deletion_widget) attribute and
[`get_deletion_widget()`](#django.forms.formsets.BaseFormSet.get_deletion_widget) method that
control the widget used with
[`can_delete`](#django.forms.formsets.BaseFormSet.can_delete).

#### `scrios_widget`

#### `BaseFormSet.deletion_widget`

Réamhshocraithe: :class: ~django.forms.checkboxInput

Socraigh `deletion_widget` chun an rang giuirléid atá le húsáid le `can_delete` a shonrú:

```pycon
>>> from django.forms import BaseFormSet, formset_factory
>>> from myapp.forms import ArticleForm
>>> class BaseArticleFormSet(BaseFormSet):
...     deletion_widget = HiddenInput
...

>>> ArticleFormSet = formset_factory(
...     ArticleForm, formset=BaseArticleFormSet, can_delete=True
... )
```

#### `faigh_scrios_widget`

#### `BaseFormSet.get_deletion_widget()`

Athraigh ```get_deletion_widget () ``más gá duit sampla giuirléid a sholáthar le húsáid le ``can_delete```:

```pycon
>>> from django.forms import BaseFormSet, formset_factory
>>> from myapp.forms import ArticleForm
>>> class BaseArticleFormSet(BaseFormSet):
...     def get_deletion_widget(self):
...         return HiddenInput(attrs={"class": "deletion"})
...

>>> ArticleFormSet = formset_factory(
...     ArticleForm, formset=BaseArticleFormSet, can_delete=True
... )
```

### `` `is féidir _scrios_breise ``

#### `BaseFormSet.can_delete_extra`

Réamhshocraithe: Fíor\`

Agus tú ag socrú `can_delete=True`, bainfear an rogha chun foirmeacha breise a scriosadh `can_delete_extra=false` a shonrú.

## Réimsí breise a chur le tacar foirmeacha

Más gá duit réimsí breise a chur leis an tacar foirme is féidir é seo a chur i gcrích go héasca. Soláthraíonn an bunaicme foirmset modh `add_fields`. Is féidir leat an modh seo a shárú chun do réimsí féin a chur leis nó fiú réimsí réamhshocraithe/tréithe na réimsí ordaithe agus scriostha a athshainiú:

```pycon
>>> from django.forms import BaseFormSet
>>> from django.forms import formset_factory
>>> from myapp.forms import ArticleForm
>>> class BaseArticleFormSet(BaseFormSet):
...     def add_fields(self, form, index):
...         super().add_fields(form, index)
...         form.fields["my_field"] = forms.CharField()
...

>>> ArticleFormSet = formset_factory(ArticleForm, formset=BaseArticleFormSet)
>>> formset = ArticleFormSet()
>>> for form in formset:
...     print(form)
...
<div><label for="id_form-0-title">Title:</label><input type="text" name="form-0-title" id="id_form-0-title"></div>
<div><label for="id_form-0-pub_date">Pub date:</label><input type="text" name="form-0-pub_date" id="id_form-0-pub_date"></div>
<div><label for="id_form-0-my_field">My field:</label><input type="text" name="form-0-my_field" id="id_form-0-my_field"></div>
```

## Ag dul paraiméadair saincheaptha chuig foirmeacha

Uaireanta glacann do rang foirme paraiméadair saincheaptha, cosúil le MyArticleForm . Is féidir leat an paraiméadar seo a rith agus an tacar foirmeacha á gcur isteach agat:

```pycon
>>> from django.forms import BaseFormSet
>>> from django.forms import formset_factory
>>> from myapp.forms import ArticleForm

>>> class MyArticleForm(ArticleForm):
...     def __init__(self, *args, user, **kwargs):
...         self.user = user
...         super().__init__(*args, **kwargs)
...

>>> ArticleFormSet = formset_factory(MyArticleForm)
>>> formset = ArticleFormSet(form_kwargs={"user": request.user})
```

Féadfaidh an `form_kwargs` ag brath ar an gcás foirme shonrach freisin. Soláthraíonn an bunaicme formset modh `get_form_kwargs`. Tógann an modh argóint amháin - innéacs na foirme sa tacar foirme. Is é `None` an t-innéacs fao:ref: empty\_form:

```pycon
>>> from django.forms import BaseFormSet
>>> from django.forms import formset_factory

>>> class BaseArticleFormSet(BaseFormSet):
...     def get_form_kwargs(self, index):
...         kwargs = super().get_form_kwargs(index)
...         kwargs["custom_kwarg"] = index
...         return kwargs
...

>>> ArticleFormSet = formset_factory(MyArticleForm, formset=BaseArticleFormSet)
>>> formset = ArticleFormSet()
```

## Réimír foirmshraith a shaincheapadh

Sa HTML rindreáilte, cuimsíonn foirmeacha réimír ar ainm gach réimse. De réir réamhshocraithe, is é `foirm` an réimír, ach is féidir é a shaincheapadh ag baint úsáide as argóint `prefix` an fhoirmshraith.

Mar shampla, sa chás réamhshocraithe, b'fhéidir go bhfeicfidh tú:

```html
<label for="id_form-0-title">Title:</label>
<input type="text" name="form-0-title" id="id_form-0-title">
```

Ach le ArticleFormSet (prefix='article') éiríonn sé sin:

```html
<label for="id_article-0-title">Title:</label>
<input type="text" name="article-0-title" id="id_article-0-title">
```

\<multiple-formsets-in-view\>Tá sé seo úsáideach más mian leat: ref: úsáid níos mó ná tacar foirme amháin i radharc .

## Foirmshraith a úsáid i radhairc agus teimpléid

Tá na tréithe agus na modhanna seo a leanas ag foirmeacha a bhaineann le rindreáil:

#### `BaseFormSet.renderer`

Sonraíonn sé an: doc: renderer \</ref/forms/renderers\> le húsáid don fhoirmshraith. Réamhshocraithe don rindeoir a shonraítear leis an socrú: setting: FORM\_RENDER.

#### `BaseFormSet.template_name`

Ainm an teimpléid a rinneadh má theilgtear an tacar foirme isteach i sreang, m.sh. trí ```print (formset) ``nó i dteimpléad trí``` {{formset}} .

De réir réamhshocraithe, maoin ag filleadh luach an renderer's:attr: ~django.forms.renderers.baserenderer.formset\_template\_name. Féadfaidh tú é a shocrú mar ainm teimpléad teaghrán d'fhonn é sin a shárú d'aicme foirmeacha áirithe.

Úsáidfear an teimpléad seo chun foirm bhainistíochta an fhoirmeacha a léiriú, agus ansin gach foirm sa tacar foirme de réir an teimpléid atá sainmhínithe ag an bhfoirm 's:attr: ~django.forms.form.template\_name.

#### `BaseFormSet.template_name_div`

Ainm an teimpléid a úsáidtear agus tú ag glaoch: meth: .as\_div. De réir réamhshocraithe is é seo `” django/forms/formsets/div.html “`. Déanann an teimpléad seo foirm bhainistíochta an fhoirm agus ansin gach foirm sa tacar foirme de réir an mhodh foirme's:meth: ~django.forms.form.as\_div.

#### `BaseFormSet.template_name_p`

Ainm an teimpléid a úsáidtear agus tú ag glaoch: meth: .as\_p. De réir réamhshocraithe is é seo `” django/forms/formsets/p.html “`. Déanann an teimpléad seo foirm bhainistíochta an fhoirm agus ansin gach foirm sa tacar foirme de réir an mhodh foirme's:meth: ~django.forms.form.as\_p.

#### `BaseFormSet.template_name_table`

Ainm an teimpléid a úsáidtear agus tú ag glaoch: meth: .as\_table. De réir réamhshocraithe is é seo `” django/forms/formsets/table.html “`. Déanann an teimpléad seo foirm bhainistíochta an fhoirm agus ansin gach foirm sa tacar foirme de réir an mhodh foirme's:meth: ~django.forms.form.as\_table.

#### `BaseFormSet.template_name_ul`

Ainm an teimpléid a úsáidtear agus tú ag glaoch: meth: .as\_ul. De réir réamhshocraithe is é seo `” django/forms/formsets/ul.html “`. Déanann an teimpléad seo foirm bhainistíochta an fhoirm agus ansin gach foirm sa tacar foirme de réir an mhodh foirme's:meth: ~django.forms.form.as\_ul.

#### `BaseFormSet.get_context()`

Tugann sé an comhthéacs ar ais chun tacar foirme a rindreáil i dteimpléad.

Is é an comhthéacs atá ar fáil:

- `formset`: An sampla den fhoirmset.

#### `BaseFormSet.render(template_name=None, context=None, renderer=None)`

Tugtar `__str__` ar an modh rindreála chomh maith leis na modhanna: meth: .as\_div, :meth: .as\_p, :meth: .as\_ul, agus:meth: .as\_table. Tá na hargóintí go léir roghnach agus beidh siad réamhshocraithe:

- `ainmne_teimpléad`: :attr: .template\_ainm
- `context`: Luach ar ais ag: meth: .get\_context
- `renderer`: Luach ar ais ar:attr: .renderer

#### `BaseFormSet.as_div()`

Déanann sé an tacar foirme leis an teimpléad:attr: .template\_name\_div.

#### `BaseFormSet.as_p()`

Déanann sé an tacar foirme leis an teimpléad:attr: .template\_name\_p.

#### `BaseFormSet.as_table()`

Déanann sé an tacar foirme leis an teimpléad:attr: .template\_name\_table.

#### `BaseFormSet.as_ul()`

Déanann sé an tacar foirme leis an teimpléad:attr: .template\_name\_ul.

Níl sé an-difriúil le tacar foirme a úsáid taobh istigh de radharc ó rang rialta `Foirme` a úsáid. Is é an t-aon rud a theastaíonn uait a bheith ar an eolas faoi ná a chinntiú go n-úsáidtear an fhoirm bhainistíochta taobh istigh den teimpléad. Breathnaímid ar radharc samplach:

```
from django.forms import formset_factory
from django.shortcuts import render
from myapp.forms import ArticleForm

def manage_articles(request):
    ArticleFormSet = formset_factory(ArticleForm)
    if request.method == "POST":
        formset = ArticleFormSet(request.POST, request.FILES)
        if formset.is_valid():
            # do something with the formset.cleaned_data
            pass
    else:
        formset = ArticleFormSet()
    return render(request, "manage_articles.html", {"formset": formset})
```

D'fhéadfadh cuma seo a bheith ar an teimpléad manage\_articles.html\`:

```html+django
<form method="post">
    {{ formset.management_form }}
    <table>
        {% for form in formset %}
        {{ form }}
        {% endfor %}
    </table>
</form>
```

Mar sin féin tá aicearra beag ann don méid thuas trí ligean don fhoirmscar féin déileáil leis an bhfoirm bhainistíochta:

```html+django
<form method="post">
    <table>
        {{ formset }}
    </table>
</form>
```

Críochnaíonn an méid thuas ag glaoch ar an modh: meth: BaseFormSet.render ar an rang formset. Déanann sé seo an tacar foirme ag baint úsáide as an teimpléad a shonraítear leis an tréith: attr: ~BaseFormSet.Template\_Name. Cosúil le foirmeacha, de réir réamhshocraithe déanfar an tacar foirme `as_div`, agus modhanna cúntóra eile `as_p`, as\_ul\`, agus `as_table` ar fáil. \<overriding-built-in-formset-templates\>Is féidir rindreáil an fhoirmshraith a shaincheapadh tríd an tréith `template_name` a shonrú, nó níos ginearálta trí:ref: an teimpléad réamhshocraithe a shárú .

### Rinneadh de láimh `can_delete` agus `can_order`

Má rindeann tú réimsí de láimh sa teimpléad, is féidir leat paraiméadar `can_delete` a rinneadh le `{{form.Delete}}`:

```html+django
<form method="post">
    {{ formset.management_form }}
    {% for form in formset %}
        <ul>
            <li>{{ form.title }}</li>
            <li>{{ form.pub_date }}</li>
            {% if formset.can_delete %}
                <li>{{ form.DELETE }}</li>
            {% endif %}
        </ul>
    {% endfor %}
</form>
```

Ar an gcaoi chéanna, má tá sé de chumas ag an bhfoirm ordú (`can_order=true`), is féidir é a rinneadh le `{{form.order}}`.

### Ag baint úsáide as níos mó ná tacar foirme amháin i radharc

Tá tú in ann níos mó ná tacar foirme amháin a úsáid i radharc más mian leat. Tá foirmeacha ar iasacht cuid mhaith dá iompar ó fhoirmeacha. Agus é sin ráite tá tú in ann `prefix` a úsáid chun ainmneacha réimse foirmeacha foirmeacha a bhfuil luach ar leith acu chun ligean níos mó ná tacar foirme amháin a sheoladh chuig amharc gan ainmneacha a chomhrac. Breathnaímid ar an gcaoi a bhféadfaí é seo a chur i gcrích:

```
from django.forms import formset_factory
from django.shortcuts import render
from myapp.forms import ArticleForm, BookForm

def manage_articles(request):
    ArticleFormSet = formset_factory(ArticleForm)
    BookFormSet = formset_factory(BookForm)
    if request.method == "POST":
        article_formset = ArticleFormSet(request.POST, request.FILES, prefix="articles")
        book_formset = BookFormSet(request.POST, request.FILES, prefix="books")
        if article_formset.is_valid() and book_formset.is_valid():
            # do something with the cleaned_data on the formsets.
            pass
    else:
        article_formset = ArticleFormSet(prefix="articles")
        book_formset = BookFormSet(prefix="books")
    return render(
        request,
        "manage_articles.html",
        {
            "article_formset": article_formset,
            "book_formset": book_formset,
        },
    )
```

Ansin déanfá na foirmeacha a rinneadh mar is gnách. Tá sé tábhachtach a chur in iúl gur gá duit prefix\` a rith ar na cásanna POST agus neamh-POST araon ionas go ndéanfar é a léiriú agus a phróiseáil i gceart.

Cuireann gach formset's:ref: réimír \`in ionad an réimír réamh \<formset-prefix\>shocraithe \`\`foirm \`\`a chuirtear le tréithe HTML \`\`ainm\` agus id\` gach réimse.