A: Aicme: Is é an sampla Foirme teorann le tacar sonraí, nó gan teorann.
\nMá tá sé teorann le tacar sonraí, tá sé in ann na sonraí sin a bhailíochtú agus an fhoirm a léiriú mar HTML leis na sonraí a thaispeántar sa HTML.
Má tá sé**gan teorann**, ní féidir leis bailíochtú a dhéanamh (toisc nach bhfuil aon sonraí le bailíochtú!) , ach is féidir leis an bhfoirm bán a rinneadh mar HTML fós.
Chun sampla untheor:class: Form a chruthú, déan an rang a chur isteach:
\n>>> f = ContactForm()\nChun sonraí a cheangal le foirm, cuir na sonraí mar fhoclóir mar an chéad pharaiméadar chuig do thógálaí aicme:class: Form:
\n>>> data = {\n... "subject": "hello",\n... "message": "Hi there",\n... "contact_email": "foo@example.com",\n... "urgent": True,\n... }\n>>> f = ContactForm(data)\nSa bhfoclóir seo, is iad na heochracha na hainmneacha réimse, a fhreagraíonn do na tréithe i d'aicme:class: Form. Is iad na luachanna na sonraí atá tú ag iarraidh a bhailíochtú. Is teaghráin iad seo de ghnáth, ach níl aon cheanglas ann gur teaghráin iad; braitheann an cineál sonraí a chuireann tú ar: aicme: Field, mar a fheicfimid i gceann nóiméad.
\nMás gá duit idirdhealú a dhéanamh idir cásanna foirme ceangailte agus neamhcheangailte ag an am rith, seiceáil luach na tréithe foirme's:attr: ~form.is_bound:
\n>>> f = ContactForm()\n>>> f.is_bound\nFalse\n>>> f = ContactForm({"subject": "hello"})\n>>> f.is_bound\nTrue\nTabhair faoi deara go gcruthaíonn foirm*teorann* le sonraí folamh a rith le foclóir folamh:
\n>>> f = ContactForm({})\n>>> f.is_bound\nTrue\nMá tá sampla teorain:class: Form agat agus má theastaíonn uait na sonraí a athrú ar bhealach éigin, nó más mian leat sampla untheor:class: Form a cheangal le roinnt sonraí, cruthaigh sampla eile: class: Form. Níl aon bhealach ann chun sonraí a athrú i gcás a:class: Form. Nuair a cruthaíodh a: aicme: Form sampla, ba cheart duit a shonraí a mheas gan athrú, cibé acu tá sonraí aige nó nach bhfuil.
\nCuir modh ``glan () `i bhfeidhm ar do ``Foirm ``nuair a chaithfidh tú bailíochtú saincheaptha a chur le haghaidh réimsí atá idirspleáchach. Féach: ref: `validating-fields-with-glan `mar shampla úsáid.
\nIs é príomhthasc a: aicme: Form ná sonraí a bhailíochtú. Le sampla teorain:class: Form, glaoigh ar an modh:meth: ~form.is_valid chun bailíochtú a reáchtáil agus boolean a thabhairt ar ais ag ainmniú an raibh na sonraí bailí:
\n>>> data = {\n... "subject": "hello",\n... "message": "Hi there",\n... "contact_email": "foo@example.com",\n... "urgent": True,\n... }\n>>> f = ContactForm(data)\n>>> f.is_valid()\nTrue\nLet's try with some invalid data. In this case, subject is blank (an error,\nbecause all fields are required by default) and contact_email is not a\nvalid email address:
>>> data = {\n... "subject": "",\n... "message": "Hi there",\n... "contact_email": "invalid email address",\n... "urgent": True,\n... }\n>>> f = ContactForm(data)\n>>> f.is_valid()\nFalse\nRochtain ar thréith :attr: ~form.errors chun foclóir teachtaireachtaí earráide a fháil:
\n>>> f.errors\n{'subject': ['This field is required.'],\n 'contact_email': ['Enter a valid email address.']}\nSa fhoclóir seo, is iad na heochracha na hainmneacha réimse, agus is liostaí teaghráin iad na luachanna a léiríonn na teachtaireachtaí earráide. Stóráiltear na teachtaireachtaí earráide i liostaí toisc go bhféadfadh teachtaireachtaí earráide iliomad a bheith
\nIs féidir leat rochtain a fháil ar: attr: ~form.errors gan glaoch ar: meth: ~form.is_valid ar dtús. Déanfar sonraí na foirme a bhailíochtú an chéad uair a ghlaonn tú ar: meth: ~form.is_valid nó access:attr: ~form.errors.
\nNí ghlaofar ar na gnáthaimh bailíochtaithe ach uair amháin, is cuma cé mhéad uair a rochtain agat ar: attr: ~form.errors nó glao:meth: ~form.is_valid. Ciallaíonn sé seo má tá fo-iarsmaí ag bailíochtú, ní spreagfar na fo-iarsmaí sin ach uair amháin.
\nFaigheann dict ar ais a léarscáil réimsí chuig a gcásanna bunaidh ValidationError.
>>> f.errors.as_data()\n{'subject': [ValidationError(['This field is required.'])],\n 'contact_email': [ValidationError(['Enter a valid email address.'])]}\nUse this method anytime you need to identify an error by its code. This\nenables things like rewriting the error's message or writing custom logic in a\nview when a given error is present. It can also be used to serialize the errors\nin a custom format (e.g. XML); for instance, as_json()\nrelies on as_data().
Tá an gá atá le modh as_data () ``mar gheall ar chomhoiriúnacht ar ais. Cailleadh cásanna ``ValidationError roimhe seo chomh luath agus a gcuid teachtaireachtaí earráide **a rinneadh leis an bhfoclóir Form.errors. Go hidéalach bheadh Form.errors` stóráilte cásanna agus modhanna ValidationError le réimír as_ iad a dhéanamh, ach b'éigean é a dhéanamh ar an mbealach eile d'fhonn gan cód a bhriseadh a bhfuil súil le teachtaireachtaí earráide a rinneadh i Form.errors`.
Returns a string with the errors serialized as JSON.
\n>>> f.errors.as_json()\n'{"subject": [{"message": "This field is required.", "code": "required"}],\n "contact_email": [{"message": "Enter a valid email address.", "code": "invalid"}]}'\nDe réir réamhshocraithe, ní éalaíonn as_json () ``a aschur. Má tá tú á úsáid le haghaidh rud éigin cosúil le hiarratais AJAX chuig amharc foirme ina ndéanann an cliant an freagra a léirmhíniú agus earráidí isteach sa leathanach, beidh tú ag iarraidh a bheith cinnte go n-éalóidh tú na torthaí ar thaobh an chliaint chun an fhéidearthacht ionsaí scripteála tras-láithreáin a sheachaint. Is féidir leat é seo a dhéanamh i JavaScript le ``Element.textContent = ErrorText nó le $ (el) .text (ErrorText) ``jQuery (seachas a fheidhm ``.html ()).
Mura dteastaíonn uait éalú taobh an chliaint a úsáid ar chúis éigin, is féidir leat escape_html = true a shocrú freisin agus éalófar teachtaireachtaí earráide ionas gur féidir leat iad a úsáid go díreach i HTML.
Returns the errors as a dictionary suitable for serializing to JSON.\nForm.errors.as_json() returns serialized JSON, while this returns the\nerror data before it's serialized.
The escape_html parameter behaves as described in\nForm.errors.as_json().
Ligeann an modh seo earráidí a chur le réimsí ar leith ón modh ``Form.clean () `, nó ón taobh amuigh den fhoirm ar fad; mar shampla ó radharc.
\nIs é an argóint réimse ainm an réimse ar chóir na hearráidí a chur leis. <django.forms.Form.non_field_errors>Más é a luach None, déileálfar leis an earráid mar earráid neamh-réimse mar a d'fhaigh:meth: `form.non_field_errors () `.
Is féidir leis an argóint earráid a bheith ina shreang, nó b'fhéidir mar shampla de ValidationError. Féach:ref: earrá-bhailíochtai-earráid le haghaidh dea-chleachtais agus earráidí foirme á sainmhíniú.
Tabhair faoi deara go mbaineann form.add_error () ``an réimse ábhartha go huathoibríoch ó ``cleaned_data.
Tugann an modh seo boolean ar ais ag ainmniú an bhfuil earráid i réimse le earráid sonrach cód ``. Más é ```Cód ```None, fillfidh sé True má tá aon earráidí sa réimse ar chor ar bith.
Chun seiceáil le haghaidh earráidí neamh-réimse bain úsáid as: data: ~django.core.EXCEPTIONS.NON_FIELD_ERRORS mar an paraiméadar field.
Tugann an modh seo an liosta earráidí ó:attr: Form.errors <django.forms.Form.errors>`nach bhfuil baint acu le réimse áirithe. Áirítear leis seo ``ValidationError`s a ardaítear in:meth: Form.clean () `agus earráidí curtha leis ag baint úsáid:meth: `Form.add_error (None, <django.forms.Form.clean>“...”) <django.forms.Form.add_error>.
\nTá sé gan chiall foirm a bhailíochtú gan aon sonraí, ach, chun an taifead, seo cad a tharlaíonn le foirmeacha neamhcheangailte:
\n>>> f = ContactForm()\n>>> f.is_valid()\nFalse\n>>> f.errors\n{}\nÚsáid: Attr: ~Form.Initial chun luach tosaigh réimsí foirme a dhearbhú ag an am rith. Mar shampla, b'fhéidir gur mhaith leat réimse ``ainm úsáideora ``a líonadh isteach le hainm úsáideora an tseisiúin reatha.
\nChun é seo a chur i gcrích, bain úsáid as an argóint:attr: ~form.initial chuig a:class: Form. Ba chóir go mbeadh an argóint seo, má thugtar, ina fhoclóir a mhapáil ainmneacha réimse go luachanna Cuir san áireamh ach na réimsí a bhfuil luach tosaigh á shonrú agat dóibh; ní gá gach réimse a áireamh i d'fhoirm. Mar shampla:
\n>>> f = ContactForm(initial={"subject": "Hi there!"})\nNí thaispeántar na luachanna seo ach le haghaidh foirmeacha neamhcheangailte, agus ní úsáidtear iad mar luachanna cúltaca mura gcuirtear luach ar leith ar fáil.
\nMá shainmhíníonn a:class: ~django.forms.field: attr: ~Field.Initial agus san áireamh tuat:attr: ~form.initial agus an Form` á gcur isteach agat, ansin beidh tosaíocht ag an deireanach initial. Sa sampla seo, soláthraítear tosaithe ag leibhéal an réimse agus ag leibhéal na foirme araon, agus faigheann an dara ceann tosaíocht:
>>> from django import forms\n>>> class CommentForm(forms.Form):\n... name = forms.CharField(initial="class")\n... url = forms.URLField()\n... comment = forms.CharField()\n...\n>>> f = CommentForm(initial={"name": "instance"}, auto_id=False)\n>>> print(f)\n<div>Name:<input type="text" name="name" value="instance" required></div>\n<div>Url:<input type="url" name="url" required></div>\n<div>Comment:<input type="text" name="comment" required></div>\nTugann na sonraí tosaigh ar ais do réimse foirme. Aisghabhann sé na sonraí ó:attr: Form.initial má tá sé i láthair, ar shlí eile iarracht: attr: Field.initial. Déantar luachanna inghlaonta a mheas.
\nIt is recommended to use BoundField.initial over\nget_initial_for_field() because BoundField.initial has a\nsimpler interface. Also, unlike get_initial_for_field(),\nBoundField.initial caches its values. This is useful especially when\ndealing with callables whose return values can change (e.g. datetime.now or\nuuid.uuid4):
>>> import uuid\n>>> class UUIDCommentForm(CommentForm):\n... identifier = forms.UUIDField(initial=uuid.uuid4)\n...\n>>> f = UUIDCommentForm()\n>>> f.get_initial_for_field(f.fields["identifier"], "identifier")\nUUID('972ca9e4-7bfe-4f5b-af7d-07b3aa306334')\n>>> f.get_initial_for_field(f.fields["identifier"], "identifier")\nUUID('1b411fab-844e-4dec-bd4f-e9b0495f04d0')\n>>> # Using BoundField.initial, for comparison\n>>> f["identifier"].initial\nUUID('28a09c59-5f00-4ed9-9179-a3b074fa9c30')\n>>> f["identifier"].initial\nUUID('28a09c59-5f00-4ed9-9179-a3b074fa9c30')\nÚsáid an modh has_changed () ``ar do `Foirm nuair is gá duit a sheiceáil an bhfuil sonraí na foirme athraithe ó na sonraí tosaigh.
>>> data = {\n... "subject": "hello",\n... "message": "Hi there",\n... "contact_email": "foo@example.com",\n... "urgent": True,\n... }\n>>> f = ContactForm(data, initial=data)\n>>> f.has_changed()\nFalse\nNuair a chuirtear an fhoirm isteach, déanaimid í a athchógáil agus soláthraímid na sonraí bunaidh ionas gur féidir an comparáid a dhéanamh:
\n>>> f = ContactForm(request.POST, initial=data)\n>>> f.has_changed()\nTrue\nBeidh has_modified () ``True má tá na sonraí ó Request.post` difriúil ón méid a cuireadh ar fáil in:attr: ~form.initial nó False ar shlí eile. Déantar an toradh a ríomh trí ghlaoch: meth: field.has_changed do gach réimse san fhoirm.
Tugann an tréith changed_data liosta d'ainmneacha na réimsí a bhfuil a luachanna i sonraí ceangailte na foirme (request.post` de ghnáth) difriúil ón méid a cuireadh ar fáil in:attr: ~form.initial. Tugann sé liosta folamh ar ais mura bhfuil aon sonraí difriúil.
>>> f = ContactForm(request.POST, initial=data)\n>>> f.changed_data\n['subject', 'message']\nIs féidir leat rochtain a fháil ar na réimsí de:class: Form ón tréith fields:
>>> for row in f.fields.values():\n... print(row)\n...\n<django.forms.fields.CharField object at 0x7ffaac632510>\n<django.forms.fields.URLField object at 0x7ffaac632f90>\n<django.forms.fields.CharField object at 0x7ffaac3aa050>\n>>> f.fields["name"]\n<django.forms.fields.CharField object at 0x7ffaac6324d0>\nIs féidir leat an réimse agus:class: .BoundField den sampla: Class: Form a athrú chun an bealach a chuirtear i láthair sa fhoirm a athrú:
\n>>> f.as_div().split("</div>")[0]\n'<div><label for="id_subject">Subject:</label><input type="text" name="subject" maxlength="100" required id="id_subject">'\n>>> f["subject"].label = "Topic"\n>>> f.as_div().split("</div>")[0]\n'<div><label for="id_subject">Topic:</label><input type="text" name="subject" maxlength="100" required id="id_subject">'\nBí cúramach gan an tréith base_fields a athrú toisc go mbeidh tionchar ag an modhnú seo ar gach cás ``ContactForm ``ina dhiaidh sin laistigh den phróiseas Python céanna:
>>> f.base_fields["subject"].label_suffix = "?"\n>>> another_f = ContactForm(auto_id=False)\n>>> another_f.as_div().split("</div>")[0]\n'<div><label for="id_subject">Subject?</label><input type="text" name="subject" maxlength="100" required id="id_subject">'\nTá gach réimse i rang a: “Foirm” freagrach ní amháin as sonraí a bhailíochtú, ach freisin as iad a “ghlanadh” - iad a normalú go formáid chomhsheasmhach. Is gné deas í seo, toisc go gceadaíonn sé sonraí do réimse áirithe a ionchur ar bhealaí éagsúla, agus aschur comhsheasmhach mar thoradh air i gcónaí.
\nMar shampla, normalaíonn :class: ~django.forms.dateField ionchur isteach i réad Python datetime.date. Is cuma má chuireann tú sreang air san fhormáid '1994-07-15'`, réad ``datetime.date ``, nó roinnt formáidí eile, normalóidh ``DateField é i gcónaí go réad ``datetime.`date` fad is atá sé bailí.
Nuair a bheidh sampla a:class: ~Form cruthaithe agat le sraith sonraí agus é a bhailíochtú, is féidir leat rochtain a fháil ar na sonraí glan trína tréith ``cleaned_data`:
\n>>> data = {\n... "subject": "hello",\n... "message": "Hi there",\n... "contact_email": "foo@example.com",\n... "urgent": True,\n... }\n>>> f = ContactForm(data)\n>>> f.is_valid()\nTrue\n>>> f.cleaned_data\n{'subject': 'hello', 'message': 'Hi there', 'contact_email': 'foo@example.com', 'urgent': True}\nTabhair faoi deara go nglanann aon réimse téacs-bhunaithe - mar Charfield nó Emailfield - an t-ionchur i sreang i gcónaí. Clúdóimid na himpleachtaí ionchódú níos déanaí sa doiciméad seo.
Mura ndéantar do chuid sonraí a bhailíochtú, níl ach na réimsí bailí sa fhoclóir ``cleaned_data ``:
\n>>> data = {\n... "subject": "",\n... "message": "Hi there",\n... "contact_email": "invalid email address",\n... "urgent": True,\n... }\n>>> f = ContactForm(data)\n>>> f.is_valid()\nFalse\n>>> f.cleaned_data\n{'message': 'Hi there', 'urgent': True}\nBeidh eochair le haghaidh réimsí a shainmhínítear sa Foirm i gcónaí* sa cleaned_data`, fiú má chuireann tú sonraí breise nuair a shainmhíníonn tú an Foirm. Sa sampla seo, cuirimid dornán réimsí breise chuig an tógálaí ContactForm `, ach níl ach réimsí na foirme sa cleaned_data`:
>>> data = {\n... "subject": "hello",\n... "message": "Hi there",\n... "contact_email": "foo@example.com",\n... "urgent": True,\n... "extra_field_1": "foo",\n... "extra_field_2": "bar",\n... "extra_field_3": "baz",\n... }\n>>> f = ContactForm(data)\n>>> f.is_valid()\nTrue\n>>> f.cleaned_data # Doesn't contain extra_field_1, etc.\n{'subject': 'hello', 'message': 'Hi there', 'contact_email': 'foo@example.com', 'urgent': True}\nWhen the Form is valid, cleaned_data will include a key and value for\nall its fields, even if the data didn't include a value for some optional\nfields. In this example, the data dictionary doesn't include a value for the\nnickname field, but cleaned_data includes it, with an empty value:
>>> from django import forms\n>>> class OptionalPersonForm(forms.Form):\n... first_name = forms.CharField()\n... last_name = forms.CharField()\n... nickname = forms.CharField(required=False)\n...\n>>> data = {"first_name": "John", "last_name": "Lennon"}\n>>> f = OptionalPersonForm(data)\n>>> f.is_valid()\nTrue\n>>> f.cleaned_data\n{'first_name': 'John', 'last_name': 'Lennon', 'nickname': ''}\nIn this above example, the cleaned_data value for nickname is set to\nan empty string, because nickname is CharField, and CharFields\ntreat empty values as an empty string. Each field type knows what its "blank"\nvalue is -- e.g., for DateField, it's None instead of the empty string.\nFor full details on each field's behavior in this case, see the "Empty value"\nnote for each field in the Ranganna ``Réimse ``tógtha section below.
Is féidir leat cód a scríobh chun bailíochtú a dhéanamh do réimsí foirme áirithe (bunaithe ar a n-ainm) nó don fhoirm ina iomláine (ag smaoineamh ar theaglaim de réimsí éagsúla). Tá tuilleadh faisnéise faoi seo in:doc: /ref/forms/validation.
\nIs é an dara tasc atá ag réad Foirm é féin a rinneadh mar HTML. Chun é sin a dhéanamh, print é:
>>> f = ContactForm()\n>>> print(f)\n<div><label for="id_subject">Subject:</label><input type="text" name="subject" maxlength="100" required id="id_subject"></div>\n<div><label for="id_message">Message:</label><textarea name="message" cols="40" rows="10" required id="id_message"></textarea></div>\n<div><label for="id_contact_email">Contact email:</label><input type="email" name="contact_email" maxlength="320" required id="id_contact_email"></div>\n<div><label for="id_urgent">Urgent:</label><input type="checkbox" name="urgent" id="id_urgent"></div>\nMá tá an fhoirm ceangailte le sonraí, cuirfear na sonraí sin san áireamh go cuí san aschur HTML. Mar shampla, má léirítear réimse le <input type="text">, beidh na sonraí sa tréith luach. Má léirítear réimse le `, ansin cuir <input type="checkbox">fidh an HTML sin ``seiceáil más cuí:
>>> data = {\n... "subject": "hello",\n... "message": "Hi there",\n... "contact_email": "foo@example.com",\n... "urgent": True,\n... }\n>>> f = ContactForm(data)\n>>> print(f)\n<div><label for="id_subject">Subject:</label><input type="text" name="subject" value="hello" maxlength="100" required id="id_subject"></div>\n<div><label for="id_message">Message:</label><textarea name="message" cols="40" rows="10" required id="id_message">Hi there</textarea></div>\n<div><label for="id_contact_email">Contact email:</label><input type="email" name="contact_email" value="foo@example.com" maxlength="320" required id="id_contact_email"></div>\n<div><label for="id_urgent">Urgent:</label><input type="checkbox" name="urgent" id="id_urgent" checked></div>\n<div>Cumhdaíonn an t-aschur réamhshocraithe seo gach réimse le ```. Tabhair faoi deara a leanas:
\n<input type="submit">Maidir le solúbthacht, ní chuimsíonn an aschuir* na clibeanna ```` <form>agus ```` nó clib</form> ``. Is é do phost é sin a dhéanamh.
Tá ionadaíocht HTML réamhshocraithe ag gach cineál réimse. <input type="email">Léirítear charfield le ```` agus ``Ríomhphost le`` ```` ```` ```` ```` ` ```` ```` <input type="text">```` <input type="checkbox">Léirítear `BooleanField (Null=bréagach) ``le ``. Tabhair faoi deara nach bhfuil siad seo ach réamhshocruithe ciallmhara; is féidir leat a shonrú cén HTML atá le húsáid do réimse ar leith trí ghuirléidí a úsáid, a mhíneoimid go luath.
Tógtar an ainm ``HTML do gach clib go díreach óna ainm tréithe sa rang ``Contactform.
The text label for each field -- e.g. 'Subject:', 'Message:' and\n'Contact email:' is generated from the field name by converting all\nunderscores to spaces and upper-casing the first letter. Again, note\nthese are merely sensible defaults; you can also specify labels manually.
Tá gach lipéad téacs timpeallaithe i gclib HTML <label>, a chuireann in iúl don réimse foirme iomchuí trína id `. Gintear a id`, ina dhiaidh sin, trí id_' a réamhfheidhmiú chuig ainm an réimse. Cuirtear na tréithe id` agus na clibeanna <label> san áireamh san aschur de réir réamhshocraithe, chun dea-chleachtais a leanúint, ach is féidir leat an t-iompar sin a athrú.
Úsáideann an t-aschur comhréir HTML5, ag díriú ar <DOCTYPE html>. Mar shampla, úsáideann sé tréithe boolean mar checked seachas an stíl XHTML de ``checked='checked'`.
Cé gurb é as <div>chur `an stíl aschuir réamhshocraithe nuair a dhéanann tú foirm a phriontáil ``is féidir leat an t-aschur a shaincheapadh trí do theimpléad foirme féin a úsáid ar féidir a shocrú ar fud an láithreáin, in aghaidh foirme, nó in aghaidh na sampla. Féach:ref: `teimpléid foirm-athúsáid'.
Úsáideann an rindreáil réamhshocraithe nuair a dhéanann tú foirm “priontáil” na modhanna agus na tréithe seo a leanas.
\nainmne_teimpléadLink to this heading#Ainm an teimpléid a rinneadh má theilgtear an fhoirm isteach i sreang, m.sh. trí priontáil (foirm) ``nó i dteimpléad trí {{form}} ``.
De réir réamhshocraithe, maoin ag filleadh luach an renderer's:attr: ~django.forms.renderers.baserenderer.form_template_name. Féadfaidh tú é a shocrú mar ainm teimpléad teaghrán d'fhonn é sin a shárú d'aicme foirme áirithe.
\nTugtar __str__ ar an modh rindreála chomh maith leis na:meth: .form.as_div, :meth: .form.as_table, :meth: .form.as_p, agus:meth: .form.as_ul modhanna. Tá gach argóint roghnach agus réamhshocraithe:
ainm_teimpléad: :attr: .form.template_ainm
context: Luach ar ais ag: meth: .form.get_context
renderer: Luach ar ais ar:attr: .form.default_renderer
Trí template_name a rith is féidir leat an teimpléad a úsáidtear le haghaidh glao amháin a shaincheapadh.
Tabhair ar ais an gcomhthéacs teimpléid chun an fhoirm a rin
\nIs é an comhthéacs atá ar fáil:
\n\nteimpléad_ainm_lipéadLink to this heading#An teimpléad a úsáidtear chun ``réimse a léiriú<label>, a úsáidtear nuair a ghlaoitear: meth: `BoundField.label_tag/:Meth: ~BoundField.LEGEND_TAG. Is féidir é a athrú in aghaidh an fhoirme 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-form-templates.
\nIs é an cur chuige a mholtar chun stíl aschuir foirme a athrú ná teimpléad foirme saincheaptha a shocrú ar fud an láithreáin, in aghaidh na foirme, nó in aghaidh an Féach:ref: reusable-form-templates le haghaidh samplaí.
\nCuirtear na feidhmeanna cúntóra seo a leanas ar fáil le haghaidh comhoiriúnacht ar chúl agus is seachfhreastalaí iad chuig:meth: Form.render ag rith luach áirithe template_name.
Déanann gach cúntóir modh foirme le tréith a thugann an t-ainm teimpléid chuí.
\nAn teimpléad a úsáideann as_div () ``. Réamhshocraithe: ```django/forms/div.html'.
<div>Léiríonn as_div () ``an fhoirm mar shraith eilimintí , agus réimse amháin i ng <div>ach ``, mar shampla:
>>> f = ContactForm()\n>>> f.as_div()\n... gives HTML like:
\n<div>\n<label for="id_subject">Subject:</label>\n<input type="text" name="subject" maxlength="100" required id="id_subject">\n</div>\n<div>\n<label for="id_message">Message:</label>\n<textarea name="message" cols="40" rows="10" required id="id_message"></textarea>\n</div>\n<div>\n<label for="id_contact_email">Contact email:</label>\n<input type="email" name="contact_email" required id="id_contact_email">\n</div>\n<div>\n<label for="id_urgent">Urgent:</label>\n<input type="checkbox" name="urgent" id="id_urgent">\n</div>\nAn teimpléad a úsáideann as_p () ``. Réamhshocraithe: ```django/forms/p.html'.
<p>Léiríonn as_p () ``an fhoirm mar shraith clibeanna , agus réimse amháin i <p>ngach ``:
>>> f = ContactForm()\n>>> f.as_p()\n... gives HTML like:
\n<p><label for="id_subject">Subject:</label> <input type="text" name="subject" maxlength="100" required id="id_subject"></p>\n<p><label for="id_message">Message:</label> <textarea name="message" cols="40" rows="10" required id="id_message"></textarea></p>\n<p><label for="id_contact_email">Contact email:</label> <input type="email" name="contact_email" maxlength="320" required id="id_contact_email"></p>\n<p><label for="id_urgent">Urgent:</label> <input type="checkbox" name="urgent" id="id_urgent"></p>\nAn teimpléad a úsáideann as_ul () ``. Réamhshocraithe: ```django/forms/ul.html'.
<li>Léiríonn as_ul () ``an fhoirm mar shraith clibeanna <li>, agus réimse amháin i ngach . <ul>Cuimsíonn ai*ní* an `` nó <ul>, ionas gur féidir leat aon tréithe HTML a shonrú ar</ul> an ```` le haghaidh solúbthachta:
>>> f = ContactForm()\n>>> f.as_ul()\n... gives HTML like:
\n<li><label for="id_subject">Subject:</label> <input type="text" name="subject" maxlength="100" required id="id_subject"></li>\n<li><label for="id_message">Message:</label> <textarea name="message" cols="40" rows="10" required id="id_message"></textarea></li>\n<li><label for="id_contact_email">Contact email:</label> <input type="email" name="contact_email" maxlength="320" required id="id_contact_email"></li>\n<li><label for="id_urgent">Urgent:</label> <input type="checkbox" name="urgent" id="id_urgent"></li>\nAn teimpléad a úsáideann as_table () ``. Réamhshocraithe: ```django/forms/table.html'.
<table>Léiríonn as_table () ``an fhoirm mar HTML `:
>>> f = ContactForm()\n>>> f.as_table()\n... gives HTML like:
\n<tr><th><label for="id_subject">Subject:</label></th><td><input type="text" name="subject" maxlength="100" required id="id_subject"></td></tr>\n<tr><th><label for="id_message">Message:</label></th><td><textarea name="message" cols="40" rows="10" required id="id_message"></textarea></td></tr>\n<tr><th><label for="id_contact_email">Contact email:</label></th><td><input type="email" name="contact_email" maxlength="320" required id="id_contact_email"></td></tr>\n<tr><th><label for="id_urgent">Urgent:</label></th><td><input type="checkbox" name="urgent" id="id_urgent"></td></tr>\nTá sé coitianta go leor sraitheanna agus réimsí a fhoirmiú atá ag teastáil nó a bhfuil earráidí acu. Mar shampla, b'fhéidir gur mhaith leat na sraitheanna foirme riachtanacha a chur i láthair i dtrom agus earráidí a aibhsiú
\nTá cúpla crúca ag an rang:class: Form is féidir leat a úsáid chun tréithe class a chur leis na sraitheanna riachtanacha nó le sraitheanna le hearráidí: socraigh na tréithe: attr: Form.error_css_class agus/nó :attr: Form.required_css_class tréithe:
from django import forms\n\n\nclass ContactForm(forms.Form):\n error_css_class = "error"\n required_css_class = "required"\n\n # ... and the rest of your fields here\nNuair a bheidh sé sin déanta agat, tabharfar ranganna "earráid" agus/nó "riachtana" sraitheanna, de réir mar is gá. Beidh cuma ar an HTML rud éigin cosúil le:
>>> f = ContactForm(data)\n>>> print(f)\n<div class="required"><label for="id_subject" class="required">Subject:</label> ...\n<div class="required"><label for="id_message" class="required">Message:</label> ...\n<div class="required"><label for="id_contact_email" class="required">Contact email:</label> ...\n<div><label for="id_urgent">Urgent:</label> ...\n>>> f["subject"].label_tag()\n<label class="required" for="id_subject">Subject:</label>\n>>> f["subject"].legend_tag()\n<legend class="required" for="id_subject">Subject:</legend>\n>>> f["subject"].label_tag(attrs={"class": "foo"})\n<label for="id_subject" class="foo required">Subject:</label>\n>>> f["subject"].legend_tag(attrs={"class": "foo"})\n<legend for="id_subject" class="foo required">Subject:</legend>\nYou may further modify the rendering of form rows by using a\ncustom BoundField.
\nSpecifies the renderer to use for the form.\nDefaults to None which means to use the default renderer specified by the\nFORM_RENDERER setting.
Is féidir leat é seo a shocrú mar thréith aicme agus tú ag dearbhú d'fhoirm nó an argóint renderer a úsáid chuig Foirm. __init__ () `. Mar shampla:
from django import forms\n\n\nclass MyForm(forms.Form):\n default_renderer = MyRenderer()\nnó:
\nform = MyForm(renderer=MyRenderer())\nIn the as_p(), as_ul() and as_table() shortcuts, the fields are\ndisplayed in the order in which you define them in your form class. For\nexample, in the ContactForm example, the fields are defined in the order\nsubject, message, contact_email, urgent. To reorder the HTML\noutput, change the order in which those fields are listed in the class.
Tá roinnt bealaí eile ann chun an t-ordú a shaincheapadh:
\nDe réir réamhshocraithe form.field_order=None, a choimeádann an t-ord ina sainmhíníonn tú na réimsí i do rang foirme. Más liosta d'ainmneacha réimsí é field_order`, ordaítear na réimsí mar a shonraíonn an liosta agus cuirtear réimsí eile leis an ordú réamhshocraithe. Déantar neamhaird ar ainmneacha réimse anaithnid sa liosta Fágann sé seo gur féidir réimse i bhfo-aicme a dhíchumasú tríd é a shocrú go ``None ``gan ordú a athshainiú.
Is féidir leat an argóint Form.field_Order a úsáid chuig a:class: Form chun an t-ordú réimse a shárú. Má shainmhíníonn a:class: ~django.forms.form: attr: ~form.field_order agus chuimsíonn tú field_order nuair a chuirtear an Form` i bhfeidhm, ansin beidh tosaíocht ag an field_ord` deireanach.
Féadfaidh tú na réimsí a athshocrú am ar bith ag baint úsáide as ``order_fields () ``le liosta ainmneacha réimse mar atá in:attr: ~django.forms.form.field_order.
\nIf you render a bound Form object, the act of rendering will automatically\nrun the form's validation if it hasn't already happened, and the HTML output\nwill include the validation errors as a <ul class="errorlist">.
The following:
\n>>> data = {\n... "subject": "",\n... "message": "Hi there",\n... "contact_email": "invalid email address",\n... "urgent": True,\n... }\n>>> ContactForm(data).as_div()\n... gives HTML like:
\n<div>\n <label for="id_subject">Subject:</label>\n <ul class="errorlist" id="id_subject_error"><li>This field is required.</li></ul>\n <input type="text" name="subject" maxlength="100" required aria-invalid="true" aria-describedby="id_subject_error" id="id_subject">\n</div>\n<div>\n <label for="id_message">Message:</label>\n <textarea name="message" cols="40" rows="10" required id="id_message">Hi there</textarea>\n</div>\n<div>\n <label for="id_contact_email">Contact email:</label>\n <ul class="errorlist" id="id_contact_email_error"><li>Enter a valid email address.</li></ul>\n <input type="email" name="contact_email" value="invalid email address" maxlength="320" required aria-invalid="true" aria-describedby="id_contact_email_error" id="id_contact_email">\n</div>\n<div>\n <label for="id_urgent">Urgent:</label>\n <input type="checkbox" name="urgent" id="id_urgent" checked>\n</div>\nDjango's default form templates will associate validation errors with their\ninput by using the aria-describedby HTML attribute when the field has an\nauto_id and a custom aria-describedby is not provided. If a custom\naria-describedby is set when defining the widget this will override the\ndefault value.
If the widget is rendered in a <fieldset> then aria-describedby is\nadded to this element, otherwise it is added to the widget's HTML element (e.g.\n<input>).
De réir réamhshocraithe, úsáideann foirmeacha Django.Forms.Utils.ErrorList chun earráidí bailíochtaithe a fhormáidiú. Is liosta cosúil le réad é ErrorList ina bhfuil initlist liosta na n-earráidí. Ina theannta sin tá na tréithe agus na modhanna seo a leanas ag an rang seo a leanas.
Na ranganna CSS le húsáid agus an liosta earráide á rindreáil. Cuirtear aon ranganna a chuirtear ar fáil leis an rang réamhshocraithe earrlista.
Specifies the renderer to use for\nErrorList. Defaults to None which means to use the default\nrenderer specified by the FORM_RENDERER setting.
An id for the field for which the errors relate. This allows an\nHTML id attribute to be added in the error template and is useful\nto associate the errors with the field. The default template uses the\nformat id="{{ field_id }}_error" and a value is provided by\nForm.add_error() using the field's auto_id.
Ainm an teimpléid a úsáidtear agus tú ag glaoch ar __str__ nó:meth: render. De réir réamhshocraithe is é seo django/forms/errors/list/default.html' atá ina seachfhreastalaí don teimpléad `ul.html'.
Ainm an teimpléid a úsáidtear agus tú ag glaoch: meth: .as_text. De réir réamhshocraithe is é seo django/forms/errors/list/text.html'. Déanann an teimpléad seo na hearráidí mar liosta de phointí piléar.
Ainm an teimpléid a úsáidtear agus tú ag glaoch: meth: .as_ul. De réir réamhshocraithe is é seo django/forms/errors/list/ul.html'. Déanann an teimpléad seo na hearráidí i gclibeanna `le timfhilleadh<li> ``leis na ranganna <ul>CSS mar a shainmhínítear ar:attr: .error_class.
Comhthéacs ar ais chun earráidí a rindreáil i dteimpléad.
\nIs é an comhthéacs atá ar fáil:
\n\nTugtar __str__ ar an modh rindreála chomh maith leis an modh:meth: .as_ul.
Tá na hargóintí go léir roghnach agus beidh siad réamhshocraithe:
\ntemplate_name: Luach ar ais ag: attr: .template_name
context: Luach ar ais ag: meth: .get_context
renderer: Luach ar ais ar:attr: .renderer
Déanann sé an liosta earráide ag baint úsáide as an teimpléad atá sainmhínithe ar:attr: .template_name_text.
\nDéanann sé an liosta earráide ag baint úsáide as an teimpléad atá sainmhínithe ar:attr: .template_name_ul.
\nMás mian leat rindreáil earráidí a shaincheapadh is féidir é seo a bhaint amach tríd an tréith: attr: .template_name 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-form-templates.
\nIs aicearraí iad na modhanna as_p () ``, `as_ul (), agus ``as_table () ``- ní hé sin an t-aon bhealach is féidir réad foirme a thaispeáint.
Úsáidtear chun tréithe HTML nó rochtana a thaispeáint do réimse amháin de shampla a:class: Form.
\nTaispeánann modh ``__str__ () ``an réada seo an HTML don réimse seo.
\nYou can use Form.bound_field_class and\nField.bound_field_class to specify a different BoundField class\nper form or per field, respectively.
See Saincheapadh Boundfield for examples of overriding a BoundField.
Chun ``Boundfield` amháin a aisghabháil, bain úsáid as comhréiteach cuardaigh foclóra ar d'fhoirm ag baint úsáide as ainm an réimse mar eochair:
\n>>> form = ContactForm()\n>>> print(form["subject"])\n<input type="text" name="subject" maxlength="100" required id="id_subject">\nChun gach rud ``Boundfield` a aisghabháil, athraigh an fhoirm:
\n>>> form = ContactForm()\n>>> for boundfield in form:\n... print(boundfield)\n...\n<input type="text" name="subject" maxlength="100" required id="id_subject">\n<textarea name="message" cols="40" rows="10" required id="id_message"></textarea>\n<input type="email" name="contact_email" maxlength="320" required id="id_contact_email">\n<input type="checkbox" name="urgent" id="id_urgent">\nTugann an t-aschur réimsi-shonrach onóir socrú auto_id réad foirme:
>>> f = ContactForm(auto_id=False)\n>>> print(f["message"])\n<textarea name="message" cols="40" rows="10" required></textarea>\n>>> f = ContactForm(auto_id="id_%s")\n>>> print(f["message"])\n<textarea name="message" cols="40" rows="10" required id="id_message"></textarea>\nBoundfieldLink to this heading#Returns an aria-describedby reference to associate a field with its\nhelp text and errors. Returns None if aria-describedby is set in\nWidget.attrs to preserve the user defined attribute when rendering\nthe form.
An tréith ID HTML don BoundField` seo. Tugann teaghrán folamh ar ais má tá: attr: Form.auto_id False.
Tugann an maoin seo na sonraí don seo: class: ~django.forms.BoundField a bhaintear ag an modh giuirléid 's:meth: ~django.forms.widget.value_from_datadict, nó None mura dtugadh é:
>>> unbound_form = ContactForm()\n>>> print(unbound_form["subject"].data)\nNone\n>>> bound_form = ContactForm(data={"subject": "My Subject"})\n>>> print(bound_form["subject"].data)\nMy Subject\n<ul class="errorlist">A: Ref: réad cosúil le liosta <ref-forms-error-list-format>`a thaispeántar mar HTML `` nuair a bheidh clóite:
\n>>> data = {"subject": "hi", "message": "", "contact_email": "", "urgent": ""}\n>>> f = ContactForm(data, auto_id=False)\n>>> print(f["message"])\n<input type="text" name="message" required aria-invalid="true">\n>>> f["message"].errors\n['This field is required.']\n>>> print(f["message"].errors)\n<ul class="errorlist"><li>This field is required.</li></ul>\n>>> f["subject"].errors\n[]\n>>> print(f["subject"].errors)\n\n>>> str(f["subject"].errors)\n''\nAgus réimse á rindreáil le hearráidí, socraítear aria-invalid="true" ar ghuirléid an réimse chun a léiriú go bhfuil earráid ann d'úsáideoirí léitheoirí scáileáin.
An sampla foirm:class: ~django.forms.field ón rang foirm a fhilleann seo:class: ~django.forms.boundfield.
\nTá an sampla:Class: ~django.forms.form ceangailte leis seo: class: ~Django.Forms.BoundField.
\nAn: attr: ~django.forms.field.help_text an réimse.
\nAn t-ainm a úsáidfear i dtréith HTML ``ainm ``an ghuirléid. Cuireann sé an fhoirm: attr: ~django.forms.form.prefix san áireamh.
\nÚsáid an maoin seo chun aitheantas an réimse seo a léiriú. Mar shampla, má tá ``á thógáil de láimh agat i do the <label>impléad (in ainneoin go ndéanfaidh: meth: `~BoundField.label_tag/:Meth: ~BoundField.Legend_Tag é seo duit):
\n<label for="{{ form.my_field.id_for_label }}">...</label>{{ my_field }}\nDe réir réamhshocraithe, is é seo ainm an réimse réamhshocraithe le id_ (“id_my_field`” don sampla thuas). Féadfaidh tú an ID a mhodhnú trí:attr: ~django.forms.widget.attrs ar ghuirléid an réimse. Mar shampla, réimse mar seo a dhearbhú:
my_field = forms.CharField(widget=forms.TextInput(attrs={"id": "myFIELD"}))\nagus ag baint úsáide as an teimpléad thuas, déanfaí rud éigin mar:
\n<label for="myFIELD">...</label><input id="myFIELD" type="text" name="my_field" required>\nÚsáid: attr: BoundField.initial chun sonraí tosaigh a aisghabháil do réimse foirme. Aisghabhann sé na sonraí ó:attr: Form.initial má tá sé i láthair, ar shlí eile iarracht: attr: Field.initial. Déantar luachanna inghlaonta a mheas. Féach:ref: ref-forms-initial-form-values le haghaidh tuilleadh samplaí.
\nBoundField.initial caches its return value, which is useful\nespecially when dealing with callables whose return values can change (e.g.\ndatetime.now or uuid.uuid4):
>>> from datetime import datetime\n>>> class DatedCommentForm(CommentForm):\n... created = forms.DateTimeField(initial=datetime.now)\n...\n>>> f = DatedCommentForm()\n>>> f["created"].initial\ndatetime.datetime(2021, 7, 27, 9, 5, 54)\n>>> f["created"].initial\ndatetime.datetime(2021, 7, 27, 9, 5, 54)\nUsing BoundField.initial is recommended over\nget_initial_for_field().
Tugann sé ar ais True má tá giuirléid seo:class: ~django.forms.BoundField i bhfolach.
An: Attr: ~django.forms.field.label an réimse. Úsáidtear é seo in:meth: ~BoundField.label_tag/:Meth: ~BoundField.LEGEND_TAG.
\nAinm an réimse seo sa fhoirm:
\n>>> f = ContactForm()\n>>> print(f["subject"].name)\nsubject\n>>> print(f["message"].name)\nmessage\nAinm an teimpléid a rinneadh le:meth: .BoundField.as_Field_Group.
\nMaoin ag tugadh luach an:attr: ~django.forms.field.template_name má tá sé socraithe ar bhealach eile: attr: ~django.forms.renderers.baserenderer.field_template_name.
\nTugann luach tréith use_fieldset ghuirléid BoundField seo ar ais.
Tugann ainm aicme íseal giuirléid an réimse fillte ar ais, agus baintear aon input nó giuirléid `. Féadfar é seo a úsáid agus foirmeacha á thógáil ina bhfuil an leagan amach ag brath ar an gcineál giuirléid. Mar shampla:
{% for field in form %}\n {% if field.widget_type == 'checkbox' %}\n # render one way\n {% else %}\n # render another way\n {% endif %}\n{% endfor %}\nBoundfieldLink to this heading#Déanann sé an réimse ag baint úsáide:meth: .BoundField.render le luachanna réamhshocraithe a thugann an BoundField`, lena n-áirítear a lipéad, téacs cabhrach agus earráidí ag baint úsáide as an teimpléad's:attr: ~django.forms.renderers.baserender.field.template_name má shocraítear ar arís eile: attr: ~django.forms.renderers.baserenderer.field.field.field.field.field_Teimpléad_ainm
\nTugann sé sreang HTML ar ais chun é seo a léiriú mar <input type="hidden">```.
\nCuirtear ``**kwargs ``chuig: meth: ~django.forms.boundfield.as_widget.
\nÚsáidtear an modh seo go domhanda go hinmheánach. Ba chóir duit giuirléid a úsáid ina ionad.
\nRenders the field by rendering the passed widget, adding any HTML\nattributes passed as attrs. If no widget is specified, then the\nfield's default widget will be used.
Úsáideann inmheánacha Django only_initial agus níor cheart é a shocrú go sainráite.
Nuair a úsáideann tú aicearraí rindreála Django, úsáidtear ranganna CSS chun réimsí nó réimsí foirme riachtanacha ina bhfuil earráidí a léiriú. Má tá foirm á rindreáil agat de láimh, is féidir leat rochtain a fháil ar na ranganna CSS seo ag baint úsáide as an modh css_classes:
\n>>> f = ContactForm(data={"message": ""})\n>>> f["message"].css_classes()\n'required'\nMás mian leat roinnt ranganna breise a sholáthar i dteannta leis an earráid agus na ranganna riachtanacha a d'fhéadfadh a bheith ag teastáil, is féidir leat na ranganna sin a sholáthar mar argóint:
\n>>> f = ContactForm(data={"message": ""})\n>>> f["message"].css_classes("foo bar")\n'foo bar required'\nTabhair ar ais an gcomhthéacs teimpléid chun an réimse a rin Is é an comhthéacs atá ar fáil ná “réimse” mar shampla an réimse ceangailte.
\nDéanann sé clib lipéad don réimse foirme ag baint úsáide as an teimpléad a shonraítear ar:attr: .form.template_name_label.
\nIs é an comhthéacs atá ar fáil:
\nfield: An cás seo den :class: Boundfield.
contents: De réir réamhshocraithe teaghrán comhcheangailte de:attr: BoundField.label agus:attr: Form.label_suffix (nó:attr: Field.label_suffix, má tá sé socraithe). Is féidir leis na hargóintí contents agus label_suffix a shárú é seo.
attrs: dict ina bhfuil for,: attr: Form.requred_CSS_Class, agus id. Gintear id ``ag giuirléid an réimse ``attrs nó:attr: BoundField.auto_id. Is féidir tréithe breise a sholáthar leis an argóint attrs.
use_tag: Boolean atá True má tá id` ag an lipéad. Má tá False fágann an teimpléad réamhshocraithe an ``tag ``.
tag: Sreang roghnach chun an chlib a shaincheapadh, réamhshocraithe go lipéad.
Chun clib lipéad réimse foirme a léiriú ar leithligh, is féidir leat a mhodh ``label_tag () `a ghlaoch:
\n>>> f = ContactForm(data={"message": ""})\n>>> print(f["message"].label_tag())\n<label for="id_message">Message:</label>\nMás mian leat an rindreáil a shaincheapadh is féidir é seo a bhaint amach tríd an tréith: attr: .form.template_name_label 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-form-templates.
\n<legend>Glaonna: Meth: .label_tag le tag = 'legend' chun clibeanna `a rinneadh an lipéad. <label>Tá sé seo úsáideach agus giuirléidí raidió agus bosca seiceála iolracha á rindreáil ina bhféad <legend>fadh ```a bheith níos oiriúnaí ná` `.
Tugtar ``as_field_group ``ar an modh rindreála. Tá gach argóint roghnach agus réamhshocraithe:
\nainm_teimpléad: :attr: .BoundField.Template_Ainm
context: Luach ar ais ag: meth: .boundfield.get_context
renderer: Luach ar ais ar:attr: .form.default_renderer
Trí template_name a rith is féidir leat an teimpléad a úsáidtear le haghaidh glao amháin a shaincheapadh.
Úsáid an modh seo chun amluach an réimse seo a léiriú mar a dhéanfadh “Giuirléid” é:
\n>>> initial = {"subject": "welcome"}\n>>> unbound_form = ContactForm(initial=initial)\n>>> bound_form = ContactForm(data={"subject": "hi"}, initial=initial)\n>>> print(unbound_form["subject"].value())\nwelcome\n>>> print(bound_form["subject"].value())\nhi\nBoundfieldLink to this heading#Define a custom BoundField class to use when rendering\nthe form. This takes precedence over the project-level\nBaseRenderer.bound_field_class (along with a custom\nFORM_RENDERER), but can be overridden by the field-level\nField.bound_field_class.
If not defined as a class variable, bound_field_class can be set via the\nbound_field_class argument in the Form or Field\nconstructor.
For compatibility reasons, a custom form field can still override\nField.get_bound_field() to use a custom class, though any of the\nprevious options are preferred.
You may want to use a custom BoundField if you need to access some\nadditional information about a form field in a template and using a subclass of\nField isn't sufficient.
For example, if you have a GPSCoordinatesField, and want to be able to\naccess additional information about the coordinates in a template, this could\nbe implemented as follows:
class GPSCoordinatesBoundField(BoundField):\n @property\n def country(self):\n """\n Return the country the coordinates lie in or None if it can't be\n determined.\n """\n value = self.value()\n if value:\n return get_country_from_coordinates(value)\n else:\n return None\n\n\nclass GPSCoordinatesField(Field):\n bound_field_class = GPSCoordinatesBoundField\nAnois is féidir leat rochtain a fháil ar an tír i dteimpléad le {{form.coordinates.country}}.
You may also want to customize the default form field template rendering. For\nexample, you can override BoundField.label_tag() to add a custom class:
class StyledLabelBoundField(BoundField):\n def label_tag(self, contents=None, attrs=None, label_suffix=None, tag=None):\n attrs = attrs or {}\n attrs["class"] = "wide"\n return super().label_tag(contents, attrs, label_suffix, tag)\n\n\nclass UserForm(forms.Form):\n bound_field_class = StyledLabelBoundField\n name = CharField()\nThis would update the default form rendering:
\n>>> f = UserForm()\n>>> print(f["name"].label_tag)\n<label for="id_name" class="wide">Name:</label>\nTo add a CSS class to the wrapping HTML element of all fields, a BoundField\ncan be overridden to return a different collection of CSS classes:
class WrappedBoundField(BoundField):\n def css_classes(self, extra_classes=None):\n parent_css_classes = super().css_classes(extra_classes)\n return f"field-class {parent_css_classes}".strip()\n\n\nclass UserForm(forms.Form):\n bound_field_class = WrappedBoundField\n name = CharField()\nThis would update the form rendering as follows:
\n>>> f = UserForm()\n>>> print(f)\n<div class="field-class"><label for="id_name">Name:</label><input type="text" name="name" required id="id_name"></div>\nAlternatively, to override the BoundField class at the project level,\nBaseRenderer.bound_field_class can be defined on a custom\nFORM_RENDERER:
mysite/renderers.pyfrom django.forms.renderers import DjangoTemplates\n\nfrom .forms import CustomBoundField\n\n\nclass CustomRenderer(DjangoTemplates):\n bound_field_class = CustomBoundField\nsettings.pyFORM_RENDERER = "mysite.renderers.CustomRenderer"\nTá sé beagán níos casta déileáil le foirmeacha a bhfuil réimsí Filefield agus Imagefield ná gnáthfhoirm.
Ar dtús, d'fhonn comhaid a uaslódáil, beidh ort a chinntiú go sainmhíníonn d'eilimint ```` an enctype` i gceart mar <form>```"multipart/form-sona"``:
\n<form enctype="multipart/form-data" method="post" action="/foo/">\nAr an dara dul síos, nuair a úsáideann tú an fhoirm, ní mór duit na sonraí comhad a cheangal. Láimhseálfar sonraí comhaid ar leithligh le gnáthshonraí foirme, mar sin nuair a bhíonn FileField` agus ImageField i d'fhoirm, beidh ort an dara argóint a shonrú nuair a cheanglaíonn tú d'fhoirm. Mar sin má leathnaímid ár bhFoirm Teagmhála chun ImageField ar a dtugtar ``mugshot ``a áireamh, ní mór dúinn na sonraí comhaid ina bhfuil an íomhá mugshot a cheangal:
# Bound form with an image field\n>>> from django.core.files.uploadedfile import SimpleUploadedFile\n>>> data = {\n... "subject": "hello",\n... "message": "Hi there",\n... "contact_email": "foo@example.com",\n... "urgent": True,\n... }\n>>> file_data = {"mugshot": SimpleUploadedFile("face.jpg", b"file data")}\n>>> f = ContactFormWithMugshot(data, file_data)\nGo praiticiúil, de ghnáth sonróidh tú Request.Files mar fhoinse sonraí comhad (díreach mar a úsáideann tú Request.post mar fhoinse sonraí foirme):
# Bound form with an image field, data from the request\n>>> f = ContactFormWithMugshot(request.POST, request.FILES)\nTá foirm neamhcheangailte a thógáil mar an gcéanna agus i gcónaí - fág an dá shonraí foirme* agus* sonraí comhaid:
\n# Unbound form with an image field\n>>> f = ContactFormWithMugshot()\nMá tá tuairimí nó teimpléid in-athúsáidte á scríobh agat, b'fhéidir nach bhfuil a fhios agat roimh am an bhfoirm ilpháirteach í d'fhoirm nó nach bhfuil. Insíonn an modh ``is_multipart () ``duit an bhfuil ionchódú ilpháirteach ag teastáil ón bhfoirm le haghaidh aighneachta:
\n>>> f = ContactFormWithMugshot()\n>>> f.is_multipart()\nTrue\nSeo sampla den chaoi a bhféadfá é seo a úsáid i dteimpléad:
\n{% if form.is_multipart %}\n <form enctype="multipart/form-data" method="post" action="/foo/">\n{% else %}\n <form method="post" action="/foo/">\n{% endif %}\n{{ form }}\n</form>\nMá tá iliomad ranganna Foirme agat a roinneann réimsí, is féidir leat fo-aicmiú a úsáid chun iomarcaíocht a bhaint.
Nuair a dhéanann tú rang saincheaptha ``Foirm ``a fho-aicmiú, beidh gach réimse den tuismitheoir aicme (anna) san fho-aicme mar thoradh air, agus na réimsí a shainmhíníonn tú sa fho-aicme ina dhiaidh sin.
\nIn this example, ContactFormWithDepartment contains all the fields from\nContactForm, plus an additional field, department. The ContactForm\nfields are ordered first:
>>> class ContactFormWithDepartment(ContactForm):\n... department = forms.CharField()\n...\n>>> f = ContactFormWithDepartment(auto_id=False)\n>>> print(f)\n<div>Subject:<input type="text" name="subject" maxlength="100" required></div>\n<div>Message:<textarea name="message" cols="40" rows="10" required></textarea></div>\n<div>Contact email:<input type="email" name="contact_email" required></div>\n<div>Urgent:<input type="checkbox" name="urgent"></div>\n<div>Department:<input type="text" name="department" required></div>\nIs féidir foirmeacha iolracha a fho-aicmiú, ag caitheamh le foirmeacha mar mheascáin. Sa sampla seo, tá fo-aicmí Beatleform agus InstrumentForm araon (san ord sin), agus cuimsíonn a liosta réimsí na réimsí ó na tuismitheoireachtaí:
>>> from django import forms\n>>> class PersonForm(forms.Form):\n... first_name = forms.CharField()\n... last_name = forms.CharField()\n...\n>>> class InstrumentForm(forms.Form):\n... instrument = forms.CharField()\n...\n>>> class BeatleForm(InstrumentForm, PersonForm):\n... haircut_type = forms.CharField()\n...\n>>> b = BeatleForm(auto_id=False)\n>>> print(b)\n<div>First name:<input type="text" name="first_name" required></div>\n<div>Last name:<input type="text" name="last_name" required></div>\n<div>Instrument:<input type="text" name="instrument" required></div>\n<div>Haircut type:<input type="text" name="haircut_type" required></div>\nIs féidir Field a bhaint go dearbhaithe ó rang tuismitheoirí trí ainm an réimse a shocrú go ``None ``ar an bhfo-aicme. Mar shampla:
>>> from django import forms\n\n>>> class ParentForm(forms.Form):\n... name = forms.CharField()\n... age = forms.IntegerField()\n...\n\n>>> class ChildForm(ParentForm):\n... name = None\n...\n\n>>> list(ChildForm().fields)\n['age']\nIs féidir leat roinnt foirmeacha Django a chur taobh istigh de chlib <form> amháin. Chun a spás ainmneacha féin a thabhairt do gach Form, bain úsáid as an argóint eochairfhocal ``prefix`:
>>> mother = PersonForm(prefix="mother")\n>>> father = PersonForm(prefix="father")\n>>> print(mother)\n<div><label for="id_mother-first_name">First name:</label><input type="text" name="mother-first_name" required id="id_mother-first_name"></div>\n<div><label for="id_mother-last_name">Last name:</label><input type="text" name="mother-last_name" required id="id_mother-last_name"></div>\n>>> print(father)\n<div><label for="id_father-first_name">First name:</label><input type="text" name="father-first_name" required id="id_father-first_name"></div>\n<div><label for="id_father-last_name">Last name:</label><input type="text" name="father-last_name" required id="id_father-last_name"></div>\nIs féidir an réimír a shonrú freisin ar an rang foirme:
\n>>> class PersonForm(forms.Form):\n... ...\n... prefix = "person"\n...\n