---
title: "Réimsí foirm"
version: 6.1
locale: ga
source: https://docs.djangoproject.com/ga/6.1/ref/forms/fields/
canonical: https://djangodocs.dev/ga/6.1/ref/forms/fields/
---
# Réimsí foirm

#### `class Field`

Nuair a chruthaíonn tú rang `Foirme`, is é an chuid is tábhachtaí ná réimsí na foirme a shainiú. Tá loighic bailíochtaithe saincheaptha ag gach réimse, mar aon le cúpla crúca eile.

#### `Field.clean(value)`

Cé go bhfuil an príomhbhealach a úsáidfidh tú ranganna `Field` i ranganna `Foirme`, is féidir leat iad a chur i bhfeidhm agus iad a úsáid go díreach chun tuairim níos fearr a fháil ar an gcaoi a n-oibríonn siad. Tá modh ```clean () ``ag gach cás ``Field`, a thógann argóint amháin agus a ardaíonn eisceacht ``Django.Core.Exceptions.ValidationError``` nó a thugann an luach glan ar ais:

```pycon
>>> from django import forms
>>> f = forms.EmailField()
>>> f.clean("foo@example.com")
'foo@example.com'
>>> f.clean("invalid email address")
Traceback (most recent call last):
...
ValidationError: ['Enter a valid email address.']
```

## Argóintí lárnach réimse

Glacann gach tógálaí ranga ```Field` ar a laghad na hargóintí seo. Glacann roinnt ranganna ``Réimse``` argóintí breise, atá sonrach le réimse, ach ba cheart glacadh leis na rudaí seo a leanas i gcónaí\*:

### `` `riachtanai ``

#### `Field.required`

De réir réamhshocraithe, glacann gach rang `Field` go bhfuil an luach ag teastáil, mar sin má chuireann tú luach folamh -- `None` nó an teaghrán folamh (``````````` `````````` ```````````) -- ansin ardóidh ```clean () ``eisceacht ``ValidationError```:

```pycon
>>> from django import forms
>>> f = forms.CharField()
>>> f.clean("foo")
'foo'
>>> f.clean("")
Traceback (most recent call last):
...
ValidationError: ['This field is required.']
>>> f.clean(None)
Traceback (most recent call last):
...
ValidationError: ['This field is required.']
>>> f.clean(0)
'0'
>>> f.clean(True)
'True'
>>> f.clean(False)
'False'
```

Chun a shonrú go bhfuil réimse ní gá, cuir `required=False` chuig an tógálaí `Field`:

```pycon
>>> f = forms.CharField(required=False)
>>> f.clean("foo")
'foo'
>>> f.clean("")
''
>>> f.clean(None)
''
>>> f.clean(0)
'0'
>>> f.clean(True)
'True'
>>> f.clean(False)
'False'
```

Má tá ```required=false ``ag `Field``` agus má chuireann tú luach folamh ar `clean ()`, ansin cuirfidh clean () \`\`luach folm\*normalaithe\* ar ais seachas \`\`ValidationError\` a ardú. Maidir le `charfield`, cuirfidh sé seo ar ais: attr: ~charfield.empty\_value atá réamhshocraithe go sreang folamh. Maidir le ranganna eile ```Field`, d'fhéadfadh sé a bheith ``None```. (Athraíonn sé seo ó réimse go réimse.)

Tá an tréith HTML “riachtanach” ag giuirléidí de réimsí foirme riachtanacha. Socraigh an tréith: attr: Form.USE\_REQUIRED\_ATTRIBUTE le False\` chun é a dhíchumasú. Ní chuirtear an tréith “riachtanach” san áireamh ar fhoirmeacha foirmeacha mar b'fhéidir nach mbeidh bailíochtú an bhrabhsálaí ceart agus foirmeacha á gcur leis agus á scriosadh.

### `lipéad`

#### `Field.label`

Ligeann an argóint `lipéad` duit an lipéad “atá cairdiúil don duine” don réimse seo a shonrú. Úsáidtear é seo nuair a thaispeántar an `Réimse` i Foirm\`.

As explained in [Foirmeacha a chur amach mar HTML](/ga/6.1/ref/forms/api/#ref-forms-api-outputting-html), the default label for a
`Field` is generated from the field name by converting all underscores to
spaces and upper-casing the first letter. Specify a string for `label` if
that default behavior doesn't result in an adequate label. Use an empty string
(`""`) to hide the label.

Seo sampla iomlán ```Foirm ``a chuireann `lipéad``` i bhfeidhm do dhá cheann dá réimsí. Tá auto\_id=false\` sonraithe againn chun an t-aschur a shimpliú:

```pycon
>>> from django import forms
>>> class CommentForm(forms.Form):
...     name = forms.CharField(label="Your name")
...     url = forms.URLField(label="Your website", required=False)
...     comment = forms.CharField()
...
>>> f = CommentForm(auto_id=False)
>>> print(f)
<div>Your name:<input type="text" name="name" required></div>
<div>Your website:<input type="url" name="url"></div>
<div>Comment:<input type="text" name="comment" required></div>
```

### `iarmhair_lipéad`

#### `Field.label_suffix`

Ligeann an argóint label\_suffix\` duit an fhoirm 's:attr: ~django.forms.form.label\_suffix a shárú ar bhonn in aghaidh an réimse:

```pycon
>>> class ContactForm(forms.Form):
...     age = forms.IntegerField()
...     nationality = forms.CharField()
...     captcha_answer = forms.IntegerField(label="2 + 2", label_suffix=" =")
...
>>> f = ContactForm(label_suffix="?")
>>> print(f)
<div><label for="id_age">Age?</label><input type="number" name="age" required id="id_age"></div>
<div><label for="id_nationality">Nationality?</label><input type="text" name="nationality" required id="id_nationality"></div>
<div><label for="id_captcha_answer">2 + 2 =</label><input type="number" name="captcha_answer" required id="id_captcha_answer"></div>
```

### `tosaithe`

#### `Field.initial`

Ligeann an argóint `tosaithe` duit an luach tosaigh le húsáid a shonrú agus an `Réimse` seo a rindreáil i `Foirme` neamhcheangailte.

Chun sonraí tosaigh dinimiciúla a shonrú, féach an paraiméadar: attr: Form.initial.

Is é an cás úsáide seo nuair is mian leat foirm “folamh” a thaispeáint ina ndéantar réimse a thionscnamh go luach áirithe. Mar shampla:

```pycon
>>> from django import forms
>>> class CommentForm(forms.Form):
...     name = forms.CharField(initial="Your name")
...     url = forms.URLField(initial="https://")
...     comment = forms.CharField()
...
>>> f = CommentForm(auto_id=False)
>>> print(f)
<div>Name:<input type="text" name="name" value="Your name" required></div>
<div>Url:<input type="url" name="url" value="https://" required></div>
<div>Comment:<input type="text" name="comment" required></div>
```

B'fhéidir go bhfuil tú ag smaoineamh, cén fáth nach rachadh foclóir de na luachanna tosaigh mar shonraí agus an fhoirm á thaispeáint agat? Bhuel, má dhéanann tú é sin, spreagfaidh tú bailíochtú, agus beidh aon earráidí bailíochtaithe san aschur HTML san áireamh:

```pycon
>>> class CommentForm(forms.Form):
...     name = forms.CharField()
...     url = forms.URLField()
...     comment = forms.CharField()
...
>>> default_data = {"name": "Your name", "url": "https://"}
>>> f = CommentForm(default_data, auto_id=False)
>>> print(f)
<div>Name:
  <input type="text" name="name" value="Your name" required>
</div>
<div>Url:
  <ul class="errorlist"><li>Enter a valid URL.</li></ul>
  <input type="url" name="url" value="https://" required aria-invalid="true">
</div>
<div>Comment:
  <ul class="errorlist"><li>This field is required.</li></ul>
  <input type="text" name="comment" required aria-invalid="true">
</div>
```

Sin é an fáth nach dtaispeántar luachanna `tosaithe` ach le haghaidh foirmeacha neamhcheangailte. Maidir le foirmeacha ceangailte, úsáidfidh an t-aschur HTML na sonraí ceangailte.

Tabhair faoi deara freisin nach n-úsáidtear luachanna `tosaithe` mar shonraí “fillte” i mbailíochtú mura dtugtar luach réimse áirithe. Is iad luachanna `tosaithe` *amháin* atá beartaithe le haghaidh taispeáint foirme tosaigh:

```pycon
>>> class CommentForm(forms.Form):
...     name = forms.CharField(initial="Your name")
...     url = forms.URLField(initial="https://")
...     comment = forms.CharField()
...
>>> data = {"name": "", "url": "", "comment": "Foo"}
>>> f = CommentForm(data)
>>> f.is_valid()
False
# The form does *not* fallback to using the initial values.
>>> f.errors
{'url': ['This field is required.'], 'name': ['This field is required.']}
```

In ionad tairiseach, is féidir leat aon ghlaoch a rith freisin:

```pycon
>>> import datetime
>>> class DateForm(forms.Form):
...     day = forms.DateField(initial=datetime.date.today)
...
>>> print(DateForm())
<div><label for="id_day">Day:</label><input type="text" name="day" value="2023-02-11" required id="id_day"></div>
```

Ní dhéanfar an glaoch a mheas ach amháin nuair a thaispeántar an fhoirm neamhcheangailte, ní nuair a shainmhínítear í.

### `giuirléid`

#### `Field.widget`

Ligeann an argóint `widget` duit rang `Widget` a shonrú le húsáid agus an Réimse seo á rindreáil. Féach: doc: /ref/forms/giuirléidí le haghaidh tuilleadh faisnéise.

### `téacs_cabhrach`

#### `Field.help_text`

Ligeann an argóint `help_text` duit téacs tuairisciúil a shonrú don `Field` seo. Má sholáthraíonn tú `help_text`, taispeánfar é in aice leis an `Réimse` nuair a dhéanfar an `Field` le ceann de na modhanna áisiúla `Foirm` (m.sh., as\_ul () ).

Cosúil leis an réimse samhail:: attr: ~django.db.models.field.help\_text, níl an luach seo ag éalú HTML i bhfoirmeacha a ghintear go huathoibríoch.

Seo sampla iomlán `Form` a chuireann `help_text` i bhfeidhm do dhá cheann dá réimsí. Tá auto\_id=false\` sonraithe againn chun an t-aschur a shimpliú:

```pycon
>>> from django import forms
>>> class HelpTextContactForm(forms.Form):
...     subject = forms.CharField(max_length=100, help_text="100 characters max.")
...     message = forms.CharField()
...     contact_email = forms.EmailField(help_text="Your email (so we can reply).")
...
>>> f = HelpTextContactForm(auto_id=False)
>>> print(f)
<div>Subject:<div class="helptext">100 characters max.</div><input type="text" name="subject" maxlength="100" required></div>
<div>Message:<input type="text" name="message" required></div>
<div>Contact email:<div class="helptext">Your email (so we can reply).</div><input type="email" name="contact_email" maxlength="320" required></div>
```

Nuair a bhíonn téacs cabhrach ag réimse tá baint aige lena ionchur ag baint úsáide as an tréith HTML `aria-describedby`. \<input\>Má chuirtear an giuirléid i ``` `an <fieldset>sin cuirtear ``aria-describedby ``` leis an eilimint seo, ar shlí eile cuirtear é le\`\`\` giuirléid:

```pycon
>>> from django import forms
>>> class UserForm(forms.Form):
...     username = forms.CharField(max_length=255, help_text="e.g., user@example.com")
...
>>> f = UserForm()
>>> print(f)
<div>
<label for="id_username">Username:</label>
<div class="helptext" id="id_username_helptext">e.g., user@example.com</div>
<input type="text" name="username" maxlength="255" required aria-describedby="id_username_helptext" id="id_username">
</div>
```

Agus tréith saincheaptha `aria-describedby` á chur leis, déan cinnte go gcuirfidh tú ```id ``den eilimint ``help_text``` (má úsáidtear é) san ord atá ag teastáil san áireamh freisin. Maidir le húsáideoirí léitheoirí scáileáin, léitear tuairiscí ina n-ord cuma laistigh de aria-describedby\`:

```pycon
>>> class UserForm(forms.Form):
...     username = forms.CharField(
...         max_length=255,
...         help_text="e.g., user@example.com",
...         widget=forms.TextInput(
...             attrs={"aria-describedby": "custom-description id_username_helptext"},
...         ),
...     )
...
>>> f = UserForm()
>>> print(f["username"])
<input type="text" name="username" aria-describedby="custom-description id_username_helptext" maxlength="255" id="id_username" required>
```

### `teachtaireachtaí earráid`

#### `Field.error_messages`

Ligeann an argóint `error_messages` duit na teachtaireachtaí réamhshocraithe a ardóidh an réimse a shárú. Pas isteach i bhfoclóir le heochracha a mheaitseálann leis na teachtaireachtaí earráide is mian leat a shárú. Mar shampla, seo an teachtaireacht earráide réamhshocraithe:

```pycon
>>> from django import forms
>>> generic = forms.CharField()
>>> generic.clean("")
Traceback (most recent call last):
  ...
ValidationError: ['This field is required.']
```

Agus seo teachtaireacht earráide saincheaptha:

```pycon
>>> name = forms.CharField(error_messages={"required": "Please enter your name"})
>>> name.clean("")
Traceback (most recent call last):
  ...
ValidationError: ['Please enter your name']
```

Sa chuid ranganna Réimse ionsuite \`\_ thíos, sainmhíníonn gach \`\`Field na heochracha teachtaireachta earráide a úsáideann sé.

### bailíochtóirí \`\`

#### `Field.validators`

Ligeann an argóint `bailíochtaire` duit liosta feidhmeanna bailíochtaithe a sholáthar don réimse seo.

Féach na:doc: doiciméadú bailíochtóir le haghaidh tuilleadh eolais. \</ref/validators\>

### `logánaithe`

#### `Field.localize`

Cuireann an argóint localize\` ar chumas ionchur sonraí foirme a logánú, chomh maith leis an aschur rindreáilte.

Féach an [formáid doiciméadú logánaithe](/ga/6.1/topics/i18n/formatting/) le haghaidh tuilleadh eolais.

### `díchumasa`

#### `Field.disabled`

Déanann an argóint boolean `díchumasa`, nuair a shocraíonn sé go `True`, réimse foirme a dhíchumasú ag baint úsáide as an tréith HTML `disabled` ionas nach mbeidh úsáideoirí é in eagar. Fiú má chuireann úsáideoir isteach ar luach an réimse a chuirtear chuig an bhfreastalaí, déanfar neamhaird air i bhfabhar an luach ó shonraí tosaigh na foirme.

### `ainmne_teimpléad`

#### `Field.template_name`

Ligeann an argóint `template_name` teimpléad saincheaptha a úsáid nuair a dhéantar an réimse a léiriú le:meth: ~django.forms.boundfield.as\_field\_group. De réir réamhshocraithe tá an luach seo socraithe go `” django/forms/field.html “`. Is féidir é a athrú in aghaidh an réimse tríd an tréith seo a shárú nó níos ginearálta tríd an teimpléad réamhshocraithe a shárú, féach freis:ref: overriding-built-in-field-templates.

### `bound_field_class`

#### `Field.bound_field_class`

The `bound_field_class` attribute allows a per-field override of
[`Form.bound_field_class`](/ga/6.1/ref/forms/api/#django.forms.Form.bound_field_class).

## Seiceáil an bhfuil athrú tagtha ar na sonraí réimse

### aigh\_athraigh () \`\`

#### `Field.has_changed()`

Úsáidtear an modh ```has_changed () ``chun a chinneadh an bhfuil luach an réimse athraithe ón luach tosaigh. Tuairisceáin ``True``` nó `False`.

See the [`Form.has_changed`](/ga/6.1/ref/forms/api/#django.forms.Form.has_changed) documentation for more information.

## Ranganna Réimse tógtha

Ar ndóigh, tagann sraith ranganna `Réimse` sa leabharlann foirme\` a léiríonn riachtanais choiteanna bailíochtaithe. Doiciméadaítear an chuid seo gach réimse ionsuite.

I gcás gach réimse, déanaimid cur síos ar an ngiuirléid réamhshocraithe a úsáidtear mura sonraíonn tú ```giuirléid`. Sonraímid freisin an luach a chuirtear ar ais nuair a sholáthraíonn tú luach folamh (féach an chuid ar ``riachtan``` thuas chun a thuiscint cad a chiallaíonn sé sin).

### `Booleanfield`

#### `class BooleanField(**kwargs)`

- Giuirléid réamhshocraithe: :class: CheckboxInput
- Luach folamh: `Fréag`
- Normalaítear go dtí: Luach Python `True` nó False\`.
- Bailíonn sé gurb é an luach `True` (m.sh. seiceáiltear an bosca seiceála) má tá `required=True` sa réimse.
- Eochracha teachtaireachta earráide: `riachtan`

> **Note**
>
> Ós rud é go bhfuil required=True\` ag gach fo-aicme ```Field` de réir réamhshocraithe, tá an coinníoll bailíochtaithe anseo tábhachtach. Más mian leat boolean a chur san áireamh i d'fhoirm a d'fhéadfadh a bheith ``True``` nó False\` (m.sh. bosca seiceála seiceáilte nó neamhsheiceáilte), ní mór duit cuimhneamh a chur isteach `required=False` agus an Booleanfield\` á chruthú.

### `Charfield`

#### `class CharField(**kwargs)`

- Giuirléid réamhshocraithe: :class: textInput
- Luach folamh: Cibé rud a thug tú mar: attr: empty\_value.
- Normalaítear go dtí: Sreang.
- Úsáid:aicme: ~django.core.validators.maxLengthValidator agus:class: ~django.core.validators.minLengthValidator má chuirtear ```max_length ``agus ``min_length``` `` `min_length` `` ar fáil. Seachas sin, tá gach ionchur bailí.
- Eochracha teachtaireachta earráide: `riachtan`, ```max_length ``, `min_length``` \`

Tá na hargóintí roghnacha seo a leanas ann le haghaidh bailíoch

#### `max_length`

#### `min_length`

Má chuirtear ar fáil, cinntíonn na hargóintí seo go bhfuil an sreang ar a mhéad nó ar a laghad an fad tugtha.

#### `strip`

Má tá `True` (réamhshocraithe), déanfar an luach a bhaint as spás bán tosaigh agus rianúil.

#### `empty_value`

An luach le húsáid chun “folamh” a léiriú. Réamhshocraithe chuig teaghrán folamh.

### `Réimse roghnaí`

#### `class ChoiceField(**kwargs)`

- Giuirléid réamhshocraithe: :class: Roghnaigh \`
- Luach folamh: "(teaghrán folamh)
- Normalaítear go dtí: Sreang.
- Bailíonn sé go bhfuil an luach a thugtar ar liosta na roghanna.
- Eochracha teachtaireachta earráide: `riachtan`, invalid\_choice\`

D'fhéadfadh go mbeadh `% (value) s` sa teachtaireacht earráide `invalid_choice`, agus cuirfear an rogha roghnaithe in ionad.

Tógann sé argóint breise amháin:

#### `choices`

\<field-choices-enum-types\>Ceachtar:term: iterable de dhá thúpla le húsáid mar roghanna don réimse seo, :ref: cineál áireamh \`, nó glaoch a thugann athraitheach den sórt sin. Glacann an argóint seo leis na formáidí céanna leis an argóint \`\`roghna\` le réimse samhail. Féach an:ref: doiciméadú tagartha réimse samhail maidir le roghanna \<field-choices\>\`le haghaidh tuilleadh sonraí. Má tá an argóint inghlaonta, déantar é a mheas gach uair a thionscnaítear foirm an réimse, i dteannta le linn rindreála. Réamhshocraithe ar liosta folamh.

> **Cineál rogha**
>
> Normalaíonn an réimse seo roghanna le teaghráin, mar sin má theastaíonn roghanna i gcineálacha sonraí eile, mar shampla sláimhreacha nó booleans, smaoinigh ar: class: TypedChoiceField a úsáid ina ionad.

### `Dáta réimse`

#### `class DateField(**kwargs)`

- Giuirléid réamhshocraithe: :class: DateInput
- Luach folamh: Níl \`\`
- Normalaítear go dtí: Rud Python `datetime.date`.
- Bailíonn sé gur datetime.date\`, datetime.datetime\` nó teaghrán formáidithe i bhformáid dáta áirithe an luach a thugtar.
- Eochracha teachtaireachta earráide: `riachtan`, neamhbhailí \`

Tógann sé argóint roghnach amháin:

#### `input_formats`

Athraitheach formáidí a úsáidtear chun iarracht a dhéanamh teaghrán a thiontú go réad bailí `datetime.date`.

Mura gcuirtear argóint `input_formats` ar fáil, tógtar na formáidí ionchuir réamhshocraithe ón bhformáid áitiúil gníomhach `DATE_INPUT_FORMATS` eochair, nó ó:setting: DATE\_INPUT\_FORMATS má tá logánú díchumasaithe. Féach freis:doc: formáid logánaithe' \</topics/i18n/formatting\>.

### `DataTimeField`

#### `class DateTimeField(**kwargs)`

- Giuirléid réamhshocraithe: :class: DateTimeInput
- Luach folamh: Níl \`\`
- Normalaítear go dtí: Rud Python `datetime.datetime`.
- Bailíonn sé gur datetime.datetime\`, datetime.date\` nó teaghrán formáidithe i bhformáid dáta-ama áirithe an luach a thugtar.
- Eochracha teachtaireachta earráide: `riachtan`, neamhbhailí \`

Tógann sé argóint roghnach amháin:

#### `input_formats`

Athraitheach formáidí a úsáidtear chun iarracht a dhéanamh teaghrán a thiontú go réad bailí datetime.datetime\`, i dteannta formáidí ISO 8601.

Glacann an réimse i gcónaí le teaghráin i ndátaí formáidithe ISO 8601 nó den chineál céanna aitheanta ar:func: ~django.utils.dateparse.parse\_datetime. Is iad roinnt samplaí:

- `` `2006-10-25 14:30:59 ' ``
- `'2006-10-25H 14:30:59 '`
- `` `'2006-10-25 14:30 ' ``
- `` `'2006-10-25T 14:30 ' ``
- '2006-10-25H 14:30 AR \`\`
- `'2006-10-25H 14:30 + 02:00 '`
- `` `'2006-10-25' ``

Mura gcuirtear argóint `input_formats` ar fáil, tógtar na formáidí ionchuir réamhshocraithe ón bhformáid áitiúil gníomhach `DATETIME_INPUT_FORMATS` agus `DATE_INPUT_FORMATS` eochracha, nó ó:setting: DATE\_INPUT\_FORMATS má dhíchumasaítear logánú. Féach freis:doc: formáid logánaithe' \</topics/i18n/formatting\>.

### `Decimalfield`

#### `class DecimalField(**kwargs)`

- Giuirléid réamhshocraithe: :class: NumberInput nuai:attr: Field.Localize is `False`, eile: class: TextInput.
- Luach folamh: Níl \`\`
- Normalaítear go dtí: A Python `deachimal`.
- Bailíonn sé gur deachúil é an luach a thugtar. Úsáid:aicme: ~django.core.validators.maxvalueValidator agus:class: ~django.core.validators.minvalueValidator má chuirtear `max_value` agus `min_value` ar fáil. Úsáid:aicme: ~django.core.validators.stepvalueValidator má chuirtear `step_size` ar fáil. Déantar neamhaird de spás bán ceannródaíoch agus leantach.
- Eochracha teachtaireachta earráide: `riachtan`, neamhbhailí\`, luach\_maxe\`, luach\_mine\`, uas\_digits\`, max\_decimal\_places\`, max\_whole\_digits\`, step\_size\`.

D'fhéadfadh go mbeadh `% (limit_value) s` sna teachtaireachtaí earráide `max_value` agus `min_value`, a chuirfear an teorainn iomchuí in ionad. Ar an gcaoi chéanna, d'fhéadfadh go mbeadh % (max) s\` sna teachtaireachtaí earráide `max_digits`, max\_decimal\_places\` agus `max_whole_digits`.

Tógann sé cúig argóint roghnach:

#### `max_value`

#### `min_value`

Rialaíonn siad seo an raon luachanna a cheadaítear sa réimse, agus ba cheart iad a thabhairt mar luachanna Decimal.Decimal\`.

#### `max_digits`

An líon uasta na ndigití (iad siúd roimh an bpointe deachúil móide iad siúd tar éis an phointe deachúil, le nialais tosaigh a scriosadh) a cheadaítear sa luach.

#### `decimal_places`

An líon uasta na n-áiteanna deachúil a cheadaítear.

#### `step_size`

Cuir ionchuir bailí a theorannú go iolrach dhílis de `step_size`. Má chuirtear `min_value` ar fáil freisin, cuirtear é leis mar fhritháireamh chun a fháil amach an bhfuil méid an chéim ag teacht leis.

### `Réimse tréimhseach`

#### `class DurationField(**kwargs)`

- Giuirléid réamhshocraithe: :class: textInput
- Luach folamh: Níl \`\`
- Déanann sé normalú go: A Python: Class: ~python: datetime.timedelta.
- Bailíonn sé gur sreang é an luach a thugtar ar féidir é a thiontú ina timedel\`. Ní mór an luach a bheith idir: attr: datetime.timedelta.min agus:attr: datetime.timedelta.max.
- Eochracha teachtaireachta earráide: `riachtan`, neamhbhailí \`, overflow\`.

Glacann sé le haon fhormáid a thuige:func: ~django.utils.dateparse.parse\_duration.

### `Réimse ríomhphost`

#### `class EmailField(**kwargs)`

- Giuirléid réamhshocraithe: :class: emailInput
- Luach folamh: Cibé rud a thug tú mar empty\_value\`.
- Normalaítear go dtí: Sreang.
- Úsáid:Class: ~django.core.validators.emailValidator chun a bhailíochtú gur seoladh ríomhphoist bailí é an luach a thugtar, ag baint úsáide as léiriú rialta measartha casta.
- Eochracha teachtaireachta earráide: `riachtan`, neamhbhailí \`

Tá na hargóintí roghnacha ```max_length ``, `min_length```, agus `empty_value` a oibríonn díreach mar a dhéanann siad le haghaidh: class: charfield. Tá an argóint max\_length réamhshocraithe go 320 (féach: rfc: 3696 #section -3).

### `FileField`

#### `class FileField(**kwargs)`

- Giuirléid réamhshocraithe: :class: ClearableFileInput
- Luach folamh: Níl \`\`
- Normalaíonn sé go: Rud UploadedFile\` a fhilleann ábhar an chomhaid agus ainm an chomhaid i réad amháin.
- Is féidir a bhailíochtú go bhfuil sonraí comhad neamh-folamh ceangailte leis an bhfoirm.
- Eochracha teachtaireachta earráide: `riachtan`, neamhbhailí\`, `easna`, folamh \`, max\_length\`

Tá na hargóintí roghnacha ann maidir le bailíochtú: ```max_length ``agus ``allow_empty_file```. Má chuirtear ar fáil, cinntíonn siad seo go bhfuil ainm an chomhaid ar a mhéad an fad tugtha, agus go n-éireoidh leis an mbailíochtú fiú má tá ábhar an chomhaid folamh.

Chun tuilleadh eolais a fhoghlaim faoin réad `uploadedfile`, féach na:doc: doiciméadú uaslódála comhad. \</topics/http/file-uploads\>

\<binding-uploaded-files\>Nuair a úsáideann tú `FileField` i bhfoirm, ní mór duit cuimhneamh freisin to:ref: sonraí an chomhaid a cheangal leis an bhfoirm .

Tagraíonn an earráid ```max_length ``d'fhad an ainm comhaid. Sa teachtaireacht earráide don eochair sin, cuirfear an fad uasta ainm comhaid in ionad `% (max) d``` agus cuirfear an fad ainm comhaid reatha in ionad % (length) d\`.

### `FilePathfield`

#### `class FilePathField(**kwargs)`

- Giuirléid réamhshocraithe: :class: Roghnaigh \`
- Luach folamh: "(teaghrán folamh)
- Normalaítear go dtí: Sreang.
- Bailíonn sé go bhfuil an rogha roghnaithe ar liosta na roghanna.
- Eochracha teachtaireachta earráide: `riachtan`, invalid\_choice\`

Ligeann an réimse roghnú ó chomhaid taobh istigh de eolaire áirithe Tógann sé cúig argóint breise; ní theastaíonn ach `path`:

#### `path`

An cosán iomlán chuig an eolaire a bhfuil a n-ábhar is mian leat liostaithe. Caithfidh an t-eolaire seo a bheith ann.

#### `recursive`

Má tá `False` (an réamhshocraithe) ní thairgfear ach ábhar díreach `path` mar roghanna. Má tá “Fíor”, cuirfear an t-eolaire isteach go athshlánach agus liostófar gach sliocht mar roghanna.

#### `match`

Patrún abairt rialta; ní cheadófar ach comhaid le hainmneacha a mheaitseálann leis an abairt seo mar roghanna.

#### `allow_files`

Optional. Either `True` or `False`. Default is `True`. Specifies
whether files in the specified location should be included. Either this
or [`allow_folders`](#django.forms.FilePathField.allow_folders) must be `True`.

#### `allow_folders`

Optional. Either `True` or `False`. Default is `False`. Specifies
whether folders in the specified location should be included. Either
this or [`allow_files`](#django.forms.FilePathField.allow_files) must be `True`.

`FilePathField` has the following method:

#### `set_choices()`

> **New in Django 6.1**

Scans the directory at [`path`](#django.forms.FilePathField.path) and refreshes the field's
choices. This is called automatically during `__init__()`, but it can
also be called explicitly to pick up files added to the directory
after the field was first instantiated (usually at server startup). For
example, call it in a form's `__init__()` to get fresh choices per
request:

```
class MyForm(forms.Form):
    my_file = forms.FilePathField(path="/path/to/dir")

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.fields["my_file"].set_choices()
```

### Floatfield \`\`

#### `class FloatField(**kwargs)`

- Giuirléid réamhshocraithe: :class: NumberInput nuai:attr: Field.Localize is `False`, eile: class: TextInput.
- Luach folamh: Níl \`\`
- Normalaítear go dtí: Snámhphointe Python.
- Bailíonn sé gur snámhphointe an luach a thugtar. Úsáid:aicme: ~django.core.validators.maxvalueValidator agus:class: ~django.core.validators.minvalueValidator má chuirtear `max_value` agus `min_value` ar fáil. Úsáid:aicme: ~django.core.validators.stepvalueValidator má chuirtear `step_size` ar fáil. Ceadaítear spás bán tosaigh agus rianaithe, mar atá i bhfeidhm float () Python.
- Eochracha teachtaireachta earráide: `riachtan`, `neamhbhailí`, luach\_maxe\`, luach\_min\`, step\_size\`.

Tógann sé trí argóint roghnacha:

#### `max_value`

#### `min_value`

Rialaíonn siad seo an raon luachanna a cheadaítear sa réimse.

#### `step_size`

Cuir ionchuir bailí a theorannú go iolrach dhílis de `step_size`. Má chuirtear `min_value` ar fáil freisin, cuirtear é leis mar fhritháireamh chun a fháil amach an bhfuil méid an chéim ag teacht leis.

### `GenericipAddressField`

#### `class GenericIPAddressField(**kwargs)`

Réimse ina bhfuil IPv4 nó seoladh IPv6.

- Giuirléid réamhshocraithe: :class: textInput
- Luach folamh: "(teaghrán folamh)
- Normalaítear go dtí: Sreang. Déantar seoltaí IPv6 a normalú mar a thuairiscítear thíos.
- Bailíonn sé gur seoladh IP bailí é an luach a thugtar.
- Error message keys: `required`, `invalid`, `max_length`

Leanann normalú an seoladh IPv6: rfc: 4291 #section -2.2 alt 2.2, lena n-áirítear úsáid a bhaint as an bhformáid IPv4 a mholtar i mír 3 den chuid sin, cosúil le `: :ffff:192.0.2.0`. Mar shampla, bheadh `2001:0:: 0:01` normalaithe go `2001: :1`, agus `: :ffff:0a0a0a` go\`\`: :ffff:10.10.10\`\`. Déantar gach carachtar a thiontú go litreacha beaga.

Tógann sé trí argóint roghnacha:

#### `protocol`

Teoraíonn sé ionchuir bailí don phrótacal sonraithe. Is iad na luachanna a nglactar leo ná ```an bheirt ``(réamhshocraithe), ``IPv4``` nó `IPv6`. Tá an meaitseáil neamh-íogair.

#### `unpack_ipv4`

Díphacáil seoltaí mapáilte IPv4 mar `:: ffff: 192.0.2.1`. Má tá an rogha seo cumasaithe déanfaí an seoladh sin a dhíphacáil go ```192.0.2.1 ``. Tá réamhshocrú díchumasaithe. Ní féidir é a úsáid ach amháin nuair a shocraítear ``prótacol``` go beach'.

#### `max_length`

Defaults to 39, and behaves the same way as it does for
[`CharField`](#django.forms.CharField).

### `ImageField`

#### `class ImageField(**kwargs)`

- Giuirléid réamhshocraithe: :class: ClearableFileInput
- Luach folamh: Níl \`\`
- Normalaíonn sé go: Rud UploadedFile\` a fhilleann ábhar an chomhaid agus ainm an chomhaid i réad amháin.
- Bailíonn sé go bhfuil sonraí comhaid ceangailte leis an bhfoirm. Úsáideann sé freisin: class: ~django.core.validators.fileExtensionValidator chun a bhailíochtú go dtacaíonn Pillow leis an síneadh comhaid.
- Eochracha teachtaireachta earráide: `riachtan`, neamhbhailí\`, `easna`, folam\`, `invalid_image`

Ag baint úsáide as `ImageField` is gá go bhfuil: pypi: pillow suiteáilte le tacaíocht do na formáidí íomhá a úsáideann tú. Má bhíonn earráid “íomhá truaillithe” ort nuair a uaslódálann tú íomhá, ciallaíonn sé de ghnáth nach dtuigeann Pillow a fhormáid. Chun é seo a shocrú, suiteáil an leabharlann cuí agus athshuiteáil Pillow.

\<binding-uploaded-files\>Nuair a úsáideann tú `ImageField` ar fhoirm, ní mór duit cuimhneamh freisin to:ref: sonraí an chomhaid a cheangal leis an bhfoirm .

Tar éis an réimse a ghlanadh agus a bhailíochtú, beidh tréith “íomhá” breise ag an réad `uploadedfile` ina bhfuil an sampla Pillow [Image](https://pillow.readthedocs.io/en/latest/reference/Image.html) a úsáidtear chun seiceáil an raibh an comhad ina íomhá bailí. Dúnann Pillow an tuairisceoir comhaid bunúsach tar éis íomhá a fhíorú, mar sin cé go bhfuil tréithe sonraí neamh-íomhá, mar shampla formáid\`, airde \`, agus leithead, ar fáil, ní féidir modhanna a bhaineann rochtain ar shonraí íomhá bunúsacha, mar shampla getdata () nó \`getpixel (), a úsáid gan an comhad a athoscailt. Mar shampla:

```pycon
>>> from PIL import Image
>>> from django import forms
>>> from django.core.files.uploadedfile import SimpleUploadedFile
>>> class ImageForm(forms.Form):
...     img = forms.ImageField()
...
>>> file_data = {"img": SimpleUploadedFile("test.png", b"file data")}
>>> form = ImageForm({}, file_data)
# Pillow closes the underlying file descriptor.
>>> form.is_valid()
True
>>> image_field = form.cleaned_data["img"]
>>> image_field.image
<PIL.PngImagePlugin.PngImageFile image mode=RGBA size=191x287 at 0x7F5985045C18>
>>> image_field.image.width
191
>>> image_field.image.height
287
>>> image_field.image.format
'PNG'
>>> image_field.image.getdata()
# Raises AttributeError: 'NoneType' object has no attribute 'seek'.
>>> image = Image.open(image_field)
>>> image.getdata()
<ImagingCore object at 0x7f5984f874b0>
```

Ina theannta sin, déanfar `uploadedfile.content_type` a nuashonrú le cineál ábhair na híomhá más féidir le Pillow é a chinneadh, ar shlí eile socraítear é go None .

### `Réimse iomlána`

#### `class IntegerField(**kwargs)`

- Giuirléid réamhshocraithe: :class: NumberInput nuai:attr: Field.Localize is `False`, eile: class: TextInput.
- Luach folamh: Níl \`\`
- Normalaítear go dtí: Sláimhir Python.
- Bailíonn sé gur sláimhir é an luach a thugtar. Úsáid:aicme: ~django.core.validators.maxvalueValidator agus:class: ~django.core.validators.minvalueValidator má chuirtear `max_value` agus `min_value` ar fáil. Úsáid:aicme: ~django.core.validators.stepvalueValidator má chuirtear `step_size` ar fáil. Ceadaítear spás bán tosaigh agus rianaithe, mar atá i bhfeidhm int () Python.
- Eochracha teachtaireachta earráide: `riachtan`, ```neamhbhailí ``, `luach_maxe```, luach\_min\`, méide\_step\`

D'fhéadfadh go mbeadh `% (limit_value) s` sna teachtaireachtaí earráide `max_value`, min\_value\` agus `step_size`, % (limit\_value) s\`, a chuirfear an teorainn iomchuí in ionad.

Glacann sé trí argóint roghnach le haghaidh bailíochtú:

#### `max_value`

#### `min_value`

Rialaíonn siad seo an raon luachanna a cheadaítear sa réimse.

#### `step_size`

Cuir ionchuir bailí a theorannú go iolrach dhílis de `step_size`. Má chuirtear `min_value` ar fáil freisin, cuirtear é leis mar fhritháireamh chun a fháil amach an bhfuil méid an chéim ag teacht leis.

### `Jsonfield`

#### `class JSONField(encoder=None, decoder=None, **kwargs)`

Réimse a ghlacann le sonraí ionchódaithe JSON do a:class: ~django.db.models.jsonField.

- Giuirléid réamhshocraithe: :class: Textarea
- Luach folamh: Níl \`\`
- Normalaítear go dtí: Léiriú Python ar an luach JSON (de ghnáth mar `dict`, liost\`, nó `None`), ag brath ar:attr: JSONfield.decoder.
- Bailíonn sé gur JSON bailí é an luach a thugtar.
- Eochracha teachtaireachta earráide: `riachtan`, neamhbhailí \`

Glacann sé dhá argóint roghnach:

#### `encoder`

A [`json.JSONEncoder`](https://docs.python.org/3/library/json.html#json.JSONEncoder) subclass to serialize data types not
supported by the standard JSON serializer (e.g. `datetime.datetime`
or [`UUID`](https://docs.python.org/3/library/uuid.html#uuid.UUID)). For example, you can use the
[`DjangoJSONEncoder`](/ga/6.1/topics/serialization/#django.core.serializers.json.DjangoJSONEncoder) class.

Réamhshocraithe go `JSON.JSONEncoder`.

#### `decoder`

A [`json.JSONDecoder`](https://docs.python.org/3/library/json.html#json.JSONDecoder) subclass to deserialize the input. Your
deserialization may need to account for the fact that you can't be
certain of the input type. For example, you run the risk of returning a
`datetime` that was actually a string that just happened to be in the
same format chosen for `datetime`s.

The `decoder` can be used to validate the input. If
[`json.JSONDecodeError`](https://docs.python.org/3/library/json.html#json.JSONDecodeError) is raised during the deserialization,
a `ValidationError` will be raised.

Réamhshocraithe go `JSON.JSONDecoder`.

> **Note**
>
> Má úsáideann tú a:class: ModelForm \`\<django.forms.ModelForm\>, úsáidfear an \`\`encoder\` agus decoder\` ó:class: ~django.db.models.jsonField.

> **Foirmeacha atá cairdiúil don**
>
> Níl `JSONField` go háirithe cairdiúil le húsáid i bhformhór na gcásanna. Is bealach úsáideach é, áfach, sonraí a fhormáidiú ó ghuirléid taobh an chliaint le cur isteach chuig an bhfreastalaí.

### `MultiplechoiceField`

#### `class MultipleChoiceField(**kwargs)`

- Giuirléid réamhshocraithe: :class: SelectMultiple
- Luach folamh: `[]` (liosta folamh)
- Normalaítear go: Liosta de na teaghráin.
- Bailíonn sé go bhfuil gach luach sa liosta luachanna ar leith i liosta na roghanna.
- Eochracha teachtaireachta earráide: `riachtan`, invalid\_choice\`, invalid\_list\`

D'fhéadfadh go mbeadh `% (value) s` sa teachtaireacht earráide `invalid_choice`, agus cuirfear an rogha roghnaithe in ionad.

Glacann sé argóint breise riachtanach amháin, `roghna`, mar atá le haghaidh: class: roghnaíon.

### `Nullbooleanfield`

#### `class NullBooleanField(**kwargs)`

- Giuirléid réamhshocraithe: :class: NullBooleanSelect
- Luach folamh: Níl \`\`
- Normalaítear go dtí: Luach Python `True`, False\` nó `None`.
- Ní bhailíonn sé rud ar bith (ie, ní ardaíonn sé `ValidationError` riamh).

Is féidir `NullBooleanField` a úsáid le giuirléidí amsúil:class: ~django.forms.select nó:class: ~django.forms.radioSelect tríd an giuirléid `roghnaithe` a sholáthar:

```
NullBooleanField(
    widget=Select(
        choices=[
            ("", "Unknown"),
            (True, "Yes"),
            (False, "No"),
        ]
    )
)
```

### `Regexfield`

#### `class RegexField(**kwargs)`

- Giuirléid réamhshocraithe: :class: textInput
- Luach folamh: Cibé rud a thug tú mar empty\_value\`.
- Normalaítear go dtí: Sreang.
- Úsáid:Class: ~django.core.validators.regexValidator chun a bhailíochtú go bhfuil an luach tugtha comhoiriúnach le léiriú rialta áirithe.
- Eochracha teachtaireachta earráide: `riachtan`, neamhbhailí \`

Tógann sé argóint riachtanach amháin:

#### `regex`

Léiriú rialta a shonraítear mar shreang nó mar réad abairt rialta tiomsaithe.

Glacann sé freisin ```max_length ``, `min_length```, strip\`, agus `empty_value` a oibríonn díreach mar a dhéanann siad do:class: charfield.

#### `strip`

Réamhshocraithe go `False`. Má tá sé cumasaithe, cuirfear stialladh i bhfeidhm roimh an bhailíochtú regex.

### `Slugfield`

#### `class SlugField(**kwargs)`

- Giuirléid réamhshocraithe: :class: textInput
- Luach folamh: Cibé rud a thug tú mar: attr: empty\_value.
- Normalaítear go dtí: Sreang.
- Úsáid:aicme: ~django.core.validators.validate\_slug nó:class: ~django.core.validators.validate\_unicode\_slug chun a bhailíochtú nach bhfuil ach litreacha, uimhreacha, béim agus braithíní sa luach tugtha.
- Teachtaireachtaí earráide: `riachtan`, neamhbhailí\`

Tá an réimse seo beartaithe le húsáid chun samhail:class: ~django.db.models.slugfield a léiriú i bhfoirmeacha.

Glacann sé dhá pharaiméadar roghnach

#### `allow_unicode`

Boolean a thugann treoir don réimse glacadh le litreacha Unicode i dteannta le litreacha ASCII. Réamhshocraithe go `False`.

#### `empty_value`

An luach le húsáid chun “folamh” a léiriú. Réamhshocraithe chuig teaghrán folamh.

### Réimse ama \`\`

#### `class TimeField(**kwargs)`

- Giuirléid réamhshocraithe: :class: TimeInput
- Luach folamh: Níl \`\`
- Normalaítear go dtí: Rud Python `datetime.time`.
- Bailíonn sé gur datetime.time\` nó teaghrán formáidithe i bhformáid ama áirithe an luach a thugtar.
- Eochracha teachtaireachta earráide: `riachtan`, neamhbhailí \`

Tógann sé argóint roghnach amháin:

#### `input_formats`

Athraitheach formáidí a úsáidtear chun iarracht a dhéanamh teaghrán a thiontú go réad bailí `datetime.time`.

Mura gcuirtear argóint `input_formats` ar fáil, tógtar na formáidí ionchuir réamhshocraithe ón bhformáid áitiúil gníomhach `TIME_INPUT_FORMATS` eochair, nó ó:setting: TIME\_INPUT\_FORMATS má tá logánú díchumasaithe. Féach freis:doc: formáid logánaithe' \</topics/i18n/formatting\>.

### `TypedChoiceField`

#### `class TypedChoiceField(**kwargs)`

Díreach cosúil le a:class: choicefield, except:class: TypedChoiceField glacann dhá argóint breise, :attr: coerce agus:attr: empty\_value.

- Giuirléid réamhshocraithe: :class: Roghnaigh \`
- Luach folamh: Cibé rud a thug tú mar: attr: empty\_value.
- Déanann sé normalú go: Luach den chineál a sholáthraíonn an argóint:attr: coerce.
- Bailíonn sé go bhfuil an luach a thugtar ar liosta na roghanna agus gur féidir é a chur iallach.
- Eochracha teachtaireachta earráide: `riachtan`, invalid\_choice\`

Tógann sé argóintí breise:

#### `coerce`

Feidhm a thógann argóint amháin agus a thugann luach éigeantach ar ais. I measc na samplaí tá na `int`, float\`, bool\` agus cineálacha eile ionsuite. Réamhshocraithe ar fheidhm aitheantais. Tabhair faoi deara go dtarlaíonn comhéigean tar éis bailíochtú ionchuir, mar sin is féidir luach nach bhfuil i láthair i “roghanna” a chur i bhfeidhm.

#### `empty_value`

An luach le húsáid chun “folamh” a léiriú. Réamhshocraithe don teaghrán folamh; Is rogha coitianta eile é ```None ``anseo. Tabhair faoi deara nach gcuirfear an luach seo a iallach leis an bhfeidhm a thugtar san argóint ``force```, mar sin roghnaigh é dá réir.

### `TypedMultiplechoiceField`

#### `class TypedMultipleChoiceField(**kwargs)`

Díreach cosúil le a:class: MultipleChoiceField, seachas: class: TypedMultipleChoiceField thógann dhá argóint breise, `coerce` agus `empty_value`.

- Giuirléid réamhshocraithe: :class: SelectMultiple
- Luach folamh: Cibé rud a thug tú mar `empty_value`
- Normalaítear go dtí: Liosta luachanna den chineál a sholáthraíonn an argóint forbairt .
- Bailíonn sé go bhfuil na luachanna a thugtar ar liosta na roghanna agus gur féidir iad a chur iallach.
- Eochracha teachtaireachta earráide: `riachtan`, invalid\_choice\`

D'fhéadfadh go mbeadh `% (value) s` sa teachtaireacht earráide `invalid_choice`, agus cuirfear an rogha roghnaithe in ionad.

Glacann sé dhá argóint bhreise, `coerce` agus empty\_value\`, mar atá le haghaidh: class: TypedChoiceField.

### `Urlfield`

#### `class URLField(**kwargs)`

- Giuirléid réamhshocraithe: :class: Urlinput
- Luach folamh: Cibé rud a thug tú mar empty\_value\`.
- Normalaítear go dtí: Sreang.
- Úsáid:Class: ~django.core.validators.urlValidator chun a bhailíochtú gur URL bailí é an luach a thugtar.
- Eochracha teachtaireachta earráide: `riachtan`, neamhbhailí \`

Tá na hargóintí roghnacha ```max_length ``, `min_length```, empty\_value\` a oibríonn díreach mar a dhéanann siad do:class: charfield, agus argóint amháin eile:

#### `assume_scheme`

The scheme assumed for URLs provided without one. Defaults to
`"https"`. For example, if `assume_scheme` is `"https"` and the
provided value is `"example.com"`, the normalized value will be
`"https://example.com"`.

### `Uuidfield`

#### `class UUIDField(**kwargs)`

- Giuirléid réamhshocraithe: :class: textInput
- Luach folamh: Níl \`\`
- Déanann sé normalú go réad: A: Class: ~Python: UUID.uuid.
- Eochracha teachtaireachta earráide: `riachtan`, neamhbhailí \`

Glacfaidh an réimse seo le haon fhormáid teaghrán a nglactar leis mar argóint `hex` don tógálaí: class: ~python:uuid.uuid.

## Ranganna `Páirce` tógtha beagán casta

### `Combofield`

#### `class ComboField(**kwargs)`

- Giuirléid réamhshocraithe: :class: textInput
- Luach folamh: "(teaghrán folamh)
- Normalaítear go dtí: Sreang.
- Bailíonn sé an luach a thugtar i gcoinne gach ceann de na réimsí a shonraítear mar argóint don Combofield.
- Eochracha teachtaireachta earráide: `riachtan`, neamhbhailí \`

Tógann sé argóint riachtanach breise amháin:

#### `fields`

Liosta na réimsí ba chóir a úsáid chun luach an réimse a bhailíochtú (san ord ina gcuirtear ar fáil iad).

```pycon
>>> from django.forms import ComboField
>>> f = ComboField(fields=[CharField(max_length=20), EmailField()])
>>> f.clean("test@example.com")
'test@example.com'
>>> f.clean("longemailaddress@example.com")
Traceback (most recent call last):
...
ValidationError: ['Ensure this value has at most 20 characters (it has 28).']
```

### `Réimse Illuacha`

#### `class MultiValueField(fields=(), **kwargs)`

- Giuirléid réamhshocraithe: :class: textInput
- Luach folamh: "(teaghrán folamh)
- Normalaítear go dtí: an cineál a chuirtear ar ais trí mhodh comhbhrúiteach\` sa fho-aicme.
- Bailíonn sé an luach a thugtar i gcoinne gach ceann de na réimsí a shonraítear mar argóint don MultivalueField\`.
- Eochracha teachtaireachta earráide: `riachtan`, neamhbhailí \`, neamhiomlán\`

Comhiomlánann sé loighic réimsí iolracha a tháirgeann luach amháin le chéile.

Tá an réimse seo teibí agus ní mór é a fho-aicmiú. I gcodarsnacht leis na réimsí aonluacha, ní mór fo-aicmí de:class: MultivalueField a chur i bhfeidhme:meth: ~django.forms.field.clean ach ina ionad sin - cur i bhfeidhm: meth: ~MultivalueField.compress.

Tógann sé argóint riachtanach breise amháin:

#### `fields`

A tuple of fields whose values are cleaned and subsequently combined
into a single value. Each value of the field is cleaned by the
corresponding field in `fields` -- the first value is cleaned by the
first field, the second value is cleaned by the second field, etc.
Once all fields are cleaned, the list of clean values is combined into
a single value by [`compress()`](#django.forms.MultiValueField.compress).

Glacann sé roinnt argóintí roghnach freisin:

#### `require_all_fields`

Réamhshocraithe go `True`, agus sa chás sin ardófar earráid bailíochtaithe `riachtanaithe` mura soláthraítear aon luach d'aon réimse.

Nuair a shocraítear é go False\`, is féidir an tréith: attr: Field.required a shocrú go `False` le haghaidh réimsí aonair chun iad a dhéanamh roghnach. Mura gcuirtear aon luach ar fáil do réimse riachtanach, ardófar earráid bailíochtaithe `neamhiomlán`.

Is féidir teachtaireacht earráide réamhshocraithe `neamhchomhlán` a shainiú ar an bhfo-aicme:class: MultivalueField, nó is féidir teachtaireachtaí éagsúla a shainiú ar gach réimse aonair. Mar shampla:

```
from django.core.validators import RegexValidator

class PhoneField(MultiValueField):
    def __init__(self, **kwargs):
        # Define one message for all fields.
        error_messages = {
            "incomplete": "Enter a country calling code and a phone number.",
        }
        # Or define a different message for each field.
        fields = (
            CharField(
                error_messages={"incomplete": "Enter a country calling code."},
                validators=[
                    RegexValidator(r"^[0-9]+$", "Enter a valid country calling code."),
                ],
            ),
            CharField(
                error_messages={"incomplete": "Enter a phone number."},
                validators=[RegexValidator(r"^[0-9]+$", "Enter a valid phone number.")],
            ),
            CharField(
                validators=[RegexValidator(r"^[0-9]+$", "Enter a valid extension.")],
                required=False,
            ),
        )
        super().__init__(
            error_messages=error_messages,
            fields=fields,
            require_all_fields=False,
            **kwargs
        )
```

#### `widget`

Caithfidh sé a bheith ina fho-aicme de:class: Django.Forms.MultiWidget. Is é an luach réamhshocraithe:class: ~django.forms.textInput, rud nach bhfuil an-úsáideach sa chás seo is dócha.

#### `compress(data_list)`

Tógann sé liosta de luachanna bailí agus cuireann sé leagan “comhbhrúite” de na luachanna sin ar ais - i luach amháin. Mar shampla, :class: Is fo-aicme é splitDateTimeField a chomhcheanglaíonn réimse ama agus réimse dáta i réad `datetime`.

Caithfear an modh seo a chur i bhfeidhm sna fo-aicmí.

### `SplitDateTimeField`

#### `class SplitDateTimeField(**kwargs)`

- Giuirléid réamhshocraithe: :class: SplitDateTimeWidget
- Luach folamh: Níl \`\`
- Normalaítear go dtí: Rud Python `datetime.datetime`.
- Bailíonn sé gur datetime.datetime\` nó sreang formáidithe i bhformáid dáta-ama áirithe an luach a thugtar.
- Eochracha teachtaireachta earráide: `riachtan`, neamhbhailí\`, dáta\_invalid\`, invalid\_time\`

Glacann sé dhá argóint roghnach:

#### `input_date_formats`

Liosta de na formáidí a úsáidtear chun iarracht a dhéanamh teaghrán a thiontú go réad bailí `datetime.date`.

Mura gcuirtear argóint `input_date_formats` ar fáil, úsáidtear na formáidí ionchuir réamhshocraithe le haghaidh: class: DateField.

#### `input_time_formats`

Liosta de na formáidí a úsáidtear chun iarracht a dhéanamh teaghrán a thiontú go réad bailí `datetime.time`.

Mura gcuirtear argóint `input_time_formats` ar fáil, úsáidtear na formáidí ionchuir réamhshocraithe le haghaidh: class: Timefield.

## Réimsí a bhaineann le caidrimh

Two fields are available for representing relationships between
models: [`ModelChoiceField`](#django.forms.ModelChoiceField) and
[`ModelMultipleChoiceField`](#django.forms.ModelMultipleChoiceField). Both of these fields require a
single `queryset` parameter that is used to create the choices for
the field. Upon form validation, these fields will place either one
model object (in the case of `ModelChoiceField`) or multiple model
objects (in the case of `ModelMultipleChoiceField`) into the
`cleaned_data` dictionary of the form.

Le haghaidh úsáidí níos casta, is féidir leat `querySet = None` a shonrú agus an réimse foirme á dhearbhú agus ansin an `queryset` a líonadh i modh \_\_init\_\_ () sa fhoirm:

```
class FooMultipleChoiceForm(forms.Form):
    foo_select = forms.ModelMultipleChoiceField(queryset=None)

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.fields["foo_select"].queryset = ...
```

Tá tréith `literator` ag ModelChoiceField\` agus `ModelMultipleChoiceField` araon a shonraíonn an rang a úsáidtear chun athrú thar an tacar fiosrúcháin agus roghanna á ghiniúint. Féach:ref: roghanna litearálach-caidrim' le haghaidh sonraí.

### `ModelChoiceField`

#### `class ModelChoiceField(**kwargs)`

- Giuirléid réamhshocraithe: :class: Roghnaigh \`
- Luach folamh: Níl \`\`
- Normalaítear go dtí: Sampla samhail.
- Bailíonn sé go bhfuil an id a thugtar sa tacar ceisteanna.
- Eochracha teachtaireachta earráide: `riachtan`, invalid\_choice\`

D'fhéadfadh go mbeadh `% (value) s` sa teachtaireacht earráide `invalid_choice`, agus cuirfear an rogha roghnaithe in ionad.

Ligeann sé réad samhail amháin a roghnú, atá oiriúnach chun eochair eachtrach a léiriú. Tabhair faoi deara go mbíonn an giuirléid réamhshocraithe do ModelChoiceField neamhphraiticiúil nuair a mhéadaíonn líon na n-iontrálacha. Ba chóir duit é a úsáid le haghaidh níos mó ná 100 mír a sheachaint.

Teastaíonn argóint amháin:

#### `queryset`

“QuerySet” de rudaí samhail as a dhíorthaítear na roghanna don réimse agus a úsáidtear chun rogha an úsáideora a bhailíochtú. Déantar é a mheas nuair a dhéantar an fhoirm a rinneadh.

Glacann `ModelChoicefield` roinnt argóintí roghnacha freisin:

#### `empty_label`

By default the `<select>` widget used by `ModelChoiceField` will
have an empty choice at the top of the list. You can change the text of
this label (which is `"- Select an option -"` by default) with the
`empty_label` attribute, or you can disable the empty label entirely
by setting `empty_label` to `None`:

```
# A custom empty label
field1 = forms.ModelChoiceField(queryset=..., empty_label="(Nothing)")

# No empty label
field2 = forms.ModelChoiceField(queryset=..., empty_label=None)
```

Tabhair faoi deara nach gcruthaítear aon rogha folamh (beag beann ar luach `empty_label`) má theastaíonn `ModelChoiceField` agus má tá luach tosaigh réamhshocraithe aige, nó go socraítear argóint `widget` <go:class>: ~django.forms.RadioSelect agus is é: attr: ~ModeliceChofield.blank False.

> **Changed in Django 6.1**
>
> The default empty label was changed from `"---------"` to
> `"- Select an option -"`.

#### `to_field_name`

Úsáidtear an argóint roghnach seo chun an réimse atá le húsáid mar luach na roghanna i ngiuirléid an réimse a shonrú. Bí cinnte gur réimse uathúil é don tsamhail, ar shlí eile d'fhéadfadh an luach roghnaithe níos mó ná réad amháin a mheaitseáil. De réir réamhshocraithe tá sé socraithe go `None`, sa chás sin úsáidfear príomh-eochair gach réad. Mar shampla:

```
# No custom to_field_name
field1 = forms.ModelChoiceField(queryset=...)
```

bheadh toradh air:

```html
<select id="id_field1" name="field1">
<option value="obj1.pk">Object1</option>
<option value="obj2.pk">Object2</option>
...
</select>
```

agus:

```
# to_field_name provided
field2 = forms.ModelChoiceField(queryset=..., to_field_name="name")
```

bheadh toradh air:

```html
<select id="id_field2" name="field2">
<option value="obj1.name">Object1</option>
<option value="obj2.name">Object2</option>
...
</select>
```

#### `blank`

Agus an giuirléid: class: ~django.forms.RadioSelect á úsáid agat, cinneann an argóint boolean roghnach seo an gcruthaítear rogha folamh. De réir réamhshocraithe, is é `blank` False\`, agus sa chás sin ní chruthaítear aon rogha folamh.

Tá an tréith ag `ModelChoiceField` freisin:

#### `iterator`

An rang iterator a úsáidtear chun roghanna réimse a ghiniúint ó `queryset`. De réir réamhshocraithe, :class: ModelChoiceIterator.

Glaofar ar an modh ```__str__ () ``den mhúnla chun léiriúcháin teaghrán a ghiniúint ar na rudaí le húsáid i roghanna an réimse. Chun ionadaíochtaí saincheaptha a sholáthar, déan fo-aicme ``ModelChoicefield``` agus label\_from\_instance\` a shárú. Gheobhaidh an modh seo réad samhail agus ba cheart go gcuirfeadh sreang atá oiriúnach chun é a léiriú ar ais. Mar shampla:

```
from django.forms import ModelChoiceField

class MyModelChoiceField(ModelChoiceField):
    def label_from_instance(self, obj):
        return "My Object #%i" % obj.id
```

### `ModelMultipleChoiceField`

#### `class ModelMultipleChoiceField(**kwargs)`

- Giuirléid réamhshocraithe: :class: SelectMultiple
- Luach folamh: An folamh `QuerySet` (self.queryset.none () )
- Normalaítear go dtí: A `QuerySet` de chásanna samhail.
- Bailíonn sé go bhfuil gach id sa liosta luachanna tugtha sa tacar fiosrúcháin.
- Eochracha teachtaireachta earráide: `riachtan`, `invalid_list`, invalid\_choice\`, invalid\_pk\_value\`

D'fhéadfadh go mbeadh % (value) s\` sa teachtaireacht `invalid_choice` agus d'fhéadfadh go mbeadh % (pk) s\` sa teachtaireacht `invalid_pk_value`, agus cuirfear na luachanna cuí in ionad.

Ligeann sé réad samhail amháin nó níos mó a roghnú, atá oiriúnach chun caidreamh go leor le go leor a léiriú. Mar atá le: class: ModelChoiceField, is féidir leat `label_from_instance` a úsáid chun na léirithe réad a shaincheapadh.

Teastaíonn argóint amháin:

#### `queryset`

Mar an gcéanna len:class: ModelChoiceField.QuerySet.

Tógann sé argóint roghnach amháin:

#### `to_field_name`

Mar an gcéanna len:class: ModelChoiceField.to\_Field\_Nam.

Tá an tréith ag `ModelMultipleChoiceField` freisin:

#### `iterator`

Mar an gcéanna len:class: ModelChoiceField.iterator.

### Roghanna caidrimh athraitheacha

De réir réamhshocraithe, :class: ModelChoiceField agus:class: ModelMultipleChoiceField úsáid:class: ModelChoiceIterator chun a réimse `roghnaithe` a ghiniúint.

Nuair a dhéantar athrá, tugann ModelChoiceIterator\` roghanna 2-thúpla ina bhfuil: class: ModelChoiceIteratorValue cásanna mar an chéad eilimint `luach` i ngach rogha. \<option\>Fillteann `ModelChoiceIteratorValue` an luach rogha agus tagairt á choinneáil don shampla samhail foinse is féidir a úsáid i bhfeidhmiú giuirléid saincheaptha, mar shampla, chun sonraí-\* tréithe \`\_ a chur le \`\`\` eilimintí.

Mar shampla, smaoinigh ar na samhlacha seo a leanas:

```
from django.db import models

class Topping(models.Model):
    name = models.CharField(max_length=100)
    price = models.DecimalField(decimal_places=2, max_digits=6)

    def __str__(self):
        return self.name

class Pizza(models.Model):
    topping = models.ForeignKey(Topping, on_delete=models.CASCADE)
```

\<option\>Is féidir leat fo-aicme giuirléid a:class: ~django.forms.select a úsáid chun luach `Topping.price` a áireamh mar an tréith HTML `sonraí-praghas` do gach eilimint :

```
from django import forms

class ToppingSelect(forms.Select):
    def create_option(
        self, name, value, label, selected, index, subindex=None, attrs=None
    ):
        option = super().create_option(
            name, value, label, selected, index, subindex, attrs
        )
        if value:
            option["attrs"]["data-price"] = value.instance.price
        return option

class PizzaForm(forms.ModelForm):
    class Meta:
        model = Pizza
        fields = ["topping"]
        widgets = {"topping": ToppingSelect}
```

Tabharfaidh sé seo an roghnú `Pizza.Topping` mar:

```html
<select id="id_topping" name="topping" required>
<option value="" selected>---------</option>
<option value="1" data-price="1.50">mushrooms</option>
<option value="2" data-price="1.25">onions</option>
<option value="3" data-price="1.75">peppers</option>
<option value="4" data-price="2.00">pineapple</option>
</select>
```

Le haghaidh úsáide níos airde, féadfaidh tú fo-aicme `ModelChoiceIterator` d'fhonn na roghanna 2-tuple a fhaightear a shaincheapadh.

#### `ModelChoiceLiterator`

#### `class ModelChoiceIterator(field)`

An rang réamhshocraithe a shanntar don tréith `iterator` de:class: ModelChoiceField agus:class: ModelMultipleChoiceField. Inathraitheach a thugann roghanna 2-tuple ón tacar fiosrúcháin.

Teastaíonn argóint amháin:

#### `field`

An sampla de `ModelChoiceField` nó `ModelMultipleChoiceField` chun roghanna a athrú agus a tháirgeadh.

Tá an modh seo a leanas ag ModelChoiceIterator\`:

#### `__iter__()`

Tugann sé roghanna dhá thiúpla, san fhormáid `(luach, lipéad)` a úsáideann: attr: ChoiceField.Choices. Is é a: class: ModelChoiceIteratorValue an chéad eilimint `luach` sampla.

#### `ModelChoiceLiteratorValue`

#### `class ModelChoiceIteratorValue(value, instance)`

Teastaíonn dhá argóint:

#### `value`

Luach an rogha. \<option\>Úsáidtear an luach seo chun tréith `luach` eilimint HTML a léiriú.

#### `instance`

An tsamhail samhail ón tacar ceisteanna. Is féidir rochtain a fháil ar an gcás i bhfeidhmiú saincheaptha choicewidget.create\_option () chun an HTML rindreáilte a choigeartú.

Tá an modh seo a leanas ag ModelChoiceIteratorValue\`:

#### `__str__()`

Tabhair ar ais `luach` mar shreang le léiriú i HTML.

## Réimsí saincheaptha a chur ar

Mura gcomhlíonann na ranganna “Réimse” ionsuite do riachtanais, is féidir leat ranganna saincheaptha ```Réimse ``a chruthú. Chun seo a dhéanamh, cruthaigh fo-aicme de ``Django.Forms.Field```. Is é an t-aon cheanglais atá aige ná go gcuirfidh sé modh ```glan () `i bhfeidhm agus go nglacfaidh a modh ``__init__ () ``leis na croí-argóintí a luaitear thuas (``riachtan```, lip\`, `lip`, tionsc\`, widget\`, help\_text\`).

You can also customize how a field will be accessed by overriding
[`bound_field_class`](#django.forms.Field.bound_field_class) or override
[`Field.get_bound_field()`](#django.forms.Field.get_bound_field) if you need more flexibility when creating
the `BoundField`:

#### `Field.get_bound_field(form, field_name)`

Takes an instance of [`Form`](/ga/6.1/ref/forms/api/#django.forms.Form) and the name of the field.
The returned [`BoundField`](/ga/6.1/ref/forms/api/#django.forms.BoundField) instance will be used when accessing the
field in a template.

See [Saincheapadh Boundfield](/ga/6.1/ref/forms/api/#custom-boundfield) for examples of overriding a `BoundField`.