---
title: "Réimsí foirm"
version: 5.2
locale: ga
source: https://docs.djangoproject.com/ga/5.2/ref/forms/fields/
canonical: https://djangodocs.dev/ga/5.2/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\`.

Mar a mhínítear in [Foirmeacha a chur amach mar HTML](/ga/5.2/ref/forms/api/#ref-forms-api-outputting-html), gintear an lipéad réamhshocraithe le haghaidh `Réimse` ó ainm na páirce trí gach foscór a thiontú go spásanna agus cás uachtair na chéad litir a chur isteach. Sonraigh `lipéad` mura mbíonn lipéad imleor mar thoradh ar an iompar réamhshocraithe sin.

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()
...     sender = forms.EmailField(help_text="A valid email address, please.")
...     cc_myself = forms.BooleanField(required=False)
...
>>> 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>Sender:<div class="helptext">A valid email address, please.</div><input type="email" name="sender" required></div>
<div>Cc myself:<input type="checkbox" name="cc_myself"></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>
```

> **Changed in Django 5.1**
>
> \<fieldset\>Cuireadh tacaíocht `aria-describedby` leis do .

### `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/5.2/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`

> **New in Django 5.2**

The `bound_field_class` attribute allows a per-field override of
[`Form.bound_field_class`](/ga/5.2/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`.

Féach an doiciméadach:class: Form.has\_Changed () le haghaidh tuilleadh faisnéise.

## 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`

Roghnach. Ceachtar `Fíor` nó `Bréag`. Is é réamhshocraithe `True`. Sonraíonn sé an gcaithfear comhaid sa suíomh sonraithe a áireamh. Caithfidh ceachtar seo nó: attr: allow\_folders a bheith `True`.

#### `allow_folders`

Roghnach. Ceachtar `Fíor` nó `Bréag`. Is é “False” réamhshocraithe. Sonraíonn sé an gcaithfear fillteáin sa suíomh sonraithe a áireamh. Caithfidh ceachtar seo nó: attr: allow\_files a bheith `True`.

### 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).

> **Changed in Django 4.2.18**
>
> The default value for `max_length` was set to 39 characters.

### `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: py:class: fo-aicme JSON.JSONEncoder chun cineálacha sonraí nach dtacaíonn an serializer caighdeánach JSON a shraitheadh (m.sh. datetime.datetime\` nó:class: ~python: UUID.uuid). Mar shampla, is féidir leat an rang:class: ~django.core.serializers.json.djangojsonEncoder a úsáid.

Réamhshocraithe go `JSON.JSONEncoder`.

#### `decoder`

A: Py: aicme: fo-aicme JSON.JSONDecoder chun an t-ionchur a dhíshealú. B'fhéidir go gcaithfidh do dhístiriú cuntas a thabhairt ar an bhfíric nach féidir leat a bheith cinnte faoin gcineál ionchuir. Mar shampla, tá an baol agat go bhfaighidh tú `datetime` a thabhairt ar ais a bhí i ndáiríre ina teaghrán a bhí díreach sa fhormáid chéanna a roghnaíodh do datetime\`s.

Is féidir an díchódóir a úsáid chun an t-ionchur a bhailíochtú. Má ardaítear: PY:Class: JSON.JSONDecodeError le linn an díshealaithe, ardófar `ValidationError`.

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`

Ghlac an scéim le haghaidh URLanna a chuirtear ar fáil gan ceann amháin. Réamhshocraithe go `"http"`. Mar shampla, más é `assume_scheme` `https"` agus gurb é ``"example.com"` an luach a chuirtear ar fáil, is é``” <https://example.com> “an luach normalaithe.

> **Deprecated since Django 5.0**
>
> Deprecated since version 5.0: Athróidh an luach réamhshocraithe do `assume_scheme` ó `"http"` go `"https"` i Django 6.0. Socraigh: socrú: FORMS\_URLFIELD\_ASSUME\_HTTPS socrú idirthréimhseach go `True` chun https"\` a úsáid le linn timthriall scaoilte Django 5.x.

### `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`

Tiúpla réimsí a ghlanadh a luachanna agus a gcomhcheanglaítear ina luach amháin ina dhiaidh sin. Glanann gach luach den réimse ag an réimse comhfhreagrach i réimsí \`\- glanann an chéad luach ag an gcéad réimse, glanann an dara luach ag an dara réimse, srl Nuair a ghlantar gach réimse, déantar liosta na luachanna glan le chéile i luach amháin le: meth: ~ 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

Tá dhá réimse ar fáil chun caidrimh idir samhlacha a léiriú: :class: ModelChoiceField agus:class: ModelMultipleChoiceField. Teastaíonn paraiméadar `queryset` amháin ag teastáil ón dá réimse seo a úsáidtear chun na roghanna don réimse a chruthú. Ar bhailíochtú foirme, cuirfidh na réimsí seo réad samhail amháin (i gcás ```ModelChoiceField`) nó rudaí samhlacha iolracha (i gcás ``ModelMultipleChoiceField```) isteach i bhfoclóir `cleaned_data` na foirme.

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`

De réir réamhshocraithe beidh rogha fol \<select\>amh ag an ngiuirléid \`\` a úsáideann `ModelChoiceField` ag barr an liosta. Is féidir leat téacs an lipéad seo a athrú (arb é `---------- “` de réir réamhshocraithe) leis an tréith `empty_label`, nó is féidir leat an lipéad folamh a dhíchumasú go hiomlán trí `empty_label` a shocrú go 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.

#### `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/5.2/ref/forms/api/#django.forms.Form) and the name of the field.
The returned [`BoundField`](/ga/5.2/ref/forms/api/#django.forms.BoundField) instance will be used when accessing the
field in a template.

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