Django 2.1 - The Forms API

प्रपत्र एपीआई




django

प्रपत्र एपीआई

इस दस्तावेज़ के बारे में

इस दस्तावेज़ में Django के रूपों एपीआई की बारीक जानकारी शामिल है। आपको पहले रूपों के साथ काम करने का परिचय पढ़ना चाहिए।

बाउंड और अनबाउंड फॉर्म

एक Form इंस्टेंस या तो डेटा के एक सेट के लिए बाध्य है, या अनबाउंड है

  • यदि यह डेटा के सेट के लिए बाध्य है, तो यह उस डेटा को मान्य करने और HTML में प्रदर्शित डेटा के साथ HTML के रूप में रेंडर करने में सक्षम है।
  • यदि यह अनबाउंड है , तो यह सत्यापन नहीं कर सकता (क्योंकि मान्य करने के लिए कोई डेटा नहीं है!), लेकिन यह अभी भी HTML के रूप में रिक्त प्रपत्र को प्रस्तुत कर सकता है।
class Form [source]

एक अनबाउंड Form उदाहरण बनाने के लिए, बस कक्षा को तुरंत लिखें:

>>> f = ContactForm()

किसी प्रपत्र में डेटा को बाइंड करने के लिए, डेटा को अपने Form क्लास कंस्ट्रक्टर के पहले पैरामीटर के रूप में डिक्शनरी के रूप में पास करें:

>>> data = {'subject': 'hello',
...         'message': 'Hi there',
...         'sender': '[email protected]',
...         'cc_myself': True}
>>> f = ContactForm(data)

इस शब्दकोश में, चाबियाँ फ़ील्ड नाम हैं, जो आपके Form क्लास में विशेषताओं के अनुरूप हैं। मान वे डेटा हैं जिन्हें आप सत्यापित करने का प्रयास कर रहे हैं। ये आमतौर पर तार होंगे, लेकिन कोई आवश्यकता नहीं है कि वे तार हों; आप जिस प्रकार का डेटा पास करते हैं, वह Field पर निर्भर करता है, जैसा कि हम एक क्षण में देखेंगे।

Form.is_bound

यदि आपको रनटाइम पर बाध्य और अनबाउंड फॉर्म इंस्टेंस के बीच अंतर करने की आवश्यकता है, तो फॉर्म की is_bound विशेषता का is_bound :

>>> f = ContactForm()
>>> f.is_bound
False
>>> f = ContactForm({'subject': 'hello'})
>>> f.is_bound
True

ध्यान दें कि खाली शब्दकोश पास करने से खाली डेटा के साथ एक बाध्य रूप बनता है:

>>> f = ContactForm({})
>>> f.is_bound
True

यदि आपके पास एक बाध्य Form उदाहरण है और आप डेटा को किसी भी तरह से बदलना चाहते हैं, या यदि आप कुछ डेटा के लिए एक अनबाउंड Form आवृत्ति को बाँधना चाहते हैं, तो दूसरा Form उदाहरण बनाएँ। Form में डेटा को बदलने का कोई तरीका नहीं है। एक बार Form इंस्टेंस बन जाने के बाद, आपको इसके डेटा को अपरिवर्तनीय मानना ​​चाहिए, चाहे उसके पास डेटा हो या न हो।

डेटा को मान्य करने के लिए फ़ॉर्म का उपयोग करना

Form.clean()

अपने Form पर एक clean() पद्धति लागू Form जब आपको अन्योन्याश्रित क्षेत्रों के लिए कस्टम सत्यापन जोड़ना होगा। उदाहरण के उपयोग के लिए एक-दूसरे पर निर्भर क्षेत्रों की सफाई और सत्यापन देखें।

Form.is_valid()

Form ऑब्जेक्ट का प्राथमिक कार्य डेटा को मान्य करना है। एक बाध्य Form उदाहरण के साथ, सत्यापन को चलाने के लिए is_valid() विधि को कॉल करें और एक बूलियन को निर्दिष्ट करें कि क्या डेटा की पुष्टि की गई थी:

>>> data = {'subject': 'hello',
...         'message': 'Hi there',
...         'sender': '[email protected]',
...         'cc_myself': True}
>>> f = ContactForm(data)
>>> f.is_valid()
True

आइए कुछ अमान्य डेटा के साथ प्रयास करें। इस मामले में, subject रिक्त है (एक त्रुटि, क्योंकि सभी फ़ील्ड डिफ़ॉल्ट रूप से आवश्यक हैं) और sender एक मान्य ईमेल पता नहीं है:

>>> data = {'subject': '',
...         'message': 'Hi there',
...         'sender': 'invalid email address',
...         'cc_myself': True}
>>> f = ContactForm(data)
>>> f.is_valid()
False
Form.errors

त्रुटि संदेशों तक पहुँचने के लिए errors विशेषता एक्सेस करें:

>>> f.errors
{'sender': ['Enter a valid email address.'], 'subject': ['This field is required.']}

इस शब्दकोश में, चाबियाँ क्षेत्र के नाम हैं, और मान त्रुटि संदेशों का प्रतिनिधित्व करने वाले तारों की सूची हैं। त्रुटि संदेशों को सूचियों में संग्रहीत किया जाता है क्योंकि किसी फ़ील्ड में एकाधिक त्रुटि संदेश हो सकते हैं।

आप पहली बार कॉल करने के लिए बिना errors को एक्सेस कर सकते errors is_valid() । फॉर्म का डेटा पहली बार तब मान्य किया जाएगा जब आप या तो कॉल करते is_valid() या एक्सेस errors

सत्यापन रूटीन केवल एक बार कॉल किया जाएगा, भले ही आप कितनी बार errors उपयोग करें या is_valid() कॉल करें। इसका अर्थ है कि यदि सत्यापन के दुष्प्रभाव हैं, तो वे दुष्प्रभाव केवल एक बार ही शुरू हो जाएंगे।

Form.errors.as_data()

एक मूल रिटर्न देता है जो फ़ील्ड्स को उनके मूल ValidationError उदाहरणों में मैप करता है।

>>> f.errors.as_data()
{'sender': [ValidationError(['Enter a valid email address.'])],
'subject': [ValidationError(['This field is required.'])]}

इस विधि का उपयोग कभी भी करें, आपको इसके code द्वारा किसी त्रुटि की पहचान करने की आवश्यकता है। यह किसी दिए गए त्रुटि के उपस्थित होने पर त्रुटि संदेश को फिर से लिखने या कस्टम तर्क लिखने जैसी चीजों को सक्षम बनाता है। यह एक कस्टम प्रारूप (जैसे XML) में त्रुटियों को क्रमबद्ध करने के लिए भी इस्तेमाल किया जा सकता है; उदाहरण के लिए, as_json() पर निर्भर करता है।

as_data() विधि की आवश्यकता पश्चगामी संगतता के कारण है। जैसे ही उनके द्वारा प्रदान किए गए त्रुटि संदेश Form.errors डिक्शनरी में जोड़े गए, पहले ValidationError उदाहरण खो गए थे। आदर्श रूप से Form.errors ने Form.errors इंस्टेंस और तरीकों को संग्रहीत किया होगा, जो as_ उपसर्ग के साथ उन्हें प्रस्तुत कर सकते हैं, लेकिन यह कोड को तोड़ने के लिए अन्य तरीके से नहीं किया जाना चाहिए, जो Form.errors में प्रदान किए गए त्रुटि संदेशों की Form.errors

Form.errors.as_json(escape_html=False)

JSON के रूप में क्रमबद्ध त्रुटियों को लौटाता है।

>>> f.errors.as_json()
{"sender": [{"message": "Enter a valid email address.", "code": "invalid"}],
"subject": [{"message": "This field is required.", "code": "required"}]}

डिफ़ॉल्ट रूप से, as_json() अपने आउटपुट से बच नहीं पाता है। यदि आप इसका उपयोग किसी ऐसी चीज के लिए कर रहे हैं जैसे AJAX एक फॉर्म व्यू के लिए अनुरोध करता है, जहां ग्राहक प्रतिक्रिया की व्याख्या करता है और पेज में त्रुटियां डालता है, तो आप क्रॉस की संभावना से बचने के लिए क्लाइंट-साइड पर परिणामों से बचना सुनिश्चित करेंगे। -साइट स्क्रिप्टिंग अटैक। यह जावास्क्रिप्ट की तरह jQuery का उपयोग करने के लिए तुच्छ है - बस .html() बजाय $(el).text(errorText) उपयोग करें।

यदि किसी कारण से आप क्लाइंट-साइड escape_html=True का उपयोग नहीं करना चाहते हैं, तो आप escape_html=True भी सेट कर सकते हैं escape_html=True और त्रुटि संदेश से बच जाएंगे ताकि आप उन्हें सीधे HTML में उपयोग कर सकें।

Form.errors.get_json_data(escape_html=False)
Django 2.0 में नया:

JSON को क्रमबद्ध करने के लिए उपयुक्त शब्दकोश के रूप में त्रुटियों को लौटाता है। as_json() क्रमबद्ध JSON देता है, जबकि यह त्रुटि डेटा को क्रमबद्ध करने से पहले देता है।

escape_html पैरामीटर के रूप में वर्णित है। as_json()

Form.add_error(field, error)

यह विधि Form.clean() विधि के भीतर या पूरी तरह से फॉर्म के बाहर से विशिष्ट क्षेत्रों में त्रुटियों को जोड़ने की अनुमति देती है; उदाहरण के लिए एक दृश्य से।

field तर्क उस field का नाम है जिसमें त्रुटियों को जोड़ा जाना चाहिए। यदि इसका मान None , तो त्रुटि को गैर-फ़ील्ड त्रुटि के रूप में माना जाएगा जैसा कि Form.non_field_errors() द्वारा लौटाया गया है।

error तर्क एक साधारण स्ट्रिंग, या अधिमानतः ValidationError का एक उदाहरण हो सकता है। प्रपत्र त्रुटियों को परिभाषित करते समय सर्वोत्तम प्रथाओं के लिए उठता हुआ वैधरण देखें।

ध्यान दें कि Form.add_error() स्वचालित रूप से संबंधित फ़ील्ड को cleaned_data से निकाल देता है।

Form.has_error(field, code=None)

यह विधि एक बूलियन को यह बताकर लौटाती है कि क्या किसी क्षेत्र में एक विशिष्ट त्रुटि code साथ त्रुटि है। यदि code None , तो यह True होगा यदि फ़ील्ड में कोई त्रुटि है।

गैर-फ़ील्ड त्रुटियों के लिए जाँच करने के लिए field पैरामीटर के रूप में NON_FIELD_ERRORS उपयोग करें।

Form.non_field_errors()

यह विधि errors से त्रुटियों की सूची errors जो किसी विशेष क्षेत्र से संबद्ध नहीं हैं। इसमें ValidationError s शामिल हैं जो Form.clean() में उठाए गए हैं और Form.add_error(None, "...") का उपयोग करके त्रुटियां जोड़ी गई हैं।

अनबाउंड रूपों का व्यवहार

किसी भी डेटा के साथ एक फॉर्म को मान्य करना व्यर्थ है, लेकिन, रिकॉर्ड के लिए, यहां अनबाउंड फॉर्म के साथ क्या होता है:

>>> f = ContactForm()
>>> f.is_valid()
False
>>> f.errors
{}

गतिशील प्रारंभिक मूल्य

Form.initial

रनटाइम पर फॉर्म फ़ील्ड के प्रारंभिक मूल्य को घोषित करने के लिए initial का उपयोग करें। उदाहरण के लिए, आप वर्तमान सत्र के उपयोगकर्ता नाम के साथ एक username फ़ील्ड भरना चाहते हैं।

इसे पूरा करने के लिए, initial तर्क का प्रयोग Form । यह तर्क, यदि दिया गया है, तो प्रारंभिक मूल्यों के लिए एक शब्दकोश मानचित्रण फ़ील्ड नाम होना चाहिए। केवल वे फ़ील्ड शामिल करें जिनके लिए आप एक प्रारंभिक मान निर्दिष्ट कर रहे हैं; हर क्षेत्र को अपने रूप में शामिल करना आवश्यक नहीं है। उदाहरण के लिए:

>>> f = ContactForm(initial={'subject': 'Hi there!'})

इन मूल्यों को केवल अनबाउंड रूपों के लिए प्रदर्शित किया जाता है, और यदि विशेष मूल्य प्रदान नहीं किया जाता है, तो उन्हें फ़ॉलबैक मान के रूप में उपयोग नहीं किया जाता है।

यदि कोई Field initial को परिभाषित करता है और आप Form त्वरित करते समय initial शामिल करते हैं, तो बाद के initial की पूर्ववर्तीता होगी। इस उदाहरण में, initial को क्षेत्र स्तर और प्रपत्र उदाहरण स्तर दोनों पर प्रदान किया जाता है, और बाद में पूर्ववर्तीता प्राप्त होती है:

>>> from django import forms
>>> class CommentForm(forms.Form):
...     name = forms.CharField(initial='class')
...     url = forms.URLField()
...     comment = forms.CharField()
>>> f = CommentForm(initial={'name': 'instance'}, auto_id=False)
>>> print(f)
<tr><th>Name:</th><td><input type="text" name="name" value="instance" required></td></tr>
<tr><th>Url:</th><td><input type="url" name="url" required></td></tr>
<tr><th>Comment:</th><td><input type="text" name="comment" required></td></tr>
Form.get_initial_for_field(field, field_name)

प्रपत्र फ़ील्ड के लिए प्रारंभिक डेटा प्राप्त करने के लिए get_initial_for_field() का उपयोग करें। यह उस क्रम में initial और initial डेटा पुनर्प्राप्त करता है, और किसी भी initial करने योग्य प्रारंभिक मूल्यों का मूल्यांकन करता है।

कौन सा फॉर्म डेटा बदल रहा है यह जाँचना

Form.has_changed()

अपने Form पर has_changed() पद्धति का उपयोग करें जब आपको यह जांचने की आवश्यकता हो कि क्या प्रारंभिक डेटा को प्रारंभिक डेटा से बदल दिया गया है।

>>> data = {'subject': 'hello',
...         'message': 'Hi there',
...         'sender': '[email protected]',
...         'cc_myself': True}
>>> f = ContactForm(data, initial=data)
>>> f.has_changed()
False

जब फ़ॉर्म सबमिट किया जाता है, तो हम इसे फिर से बनाते हैं और मूल डेटा प्रदान करते हैं ताकि तुलना की जा सके:

>>> f = ContactForm(request.POST, initial=data)
>>> f.has_changed()

has_changed() True होगा यदि request.POST से डेटा has_changed() initial या False में प्रदान किए गए से भिन्न होता है अन्यथा। परिणाम फ़ील्ड में प्रत्येक फ़ील्ड के लिए Field.has_changed() कॉल करके गणना की जाती है।

Form.changed_data

changed_data विशेषता उन फ़ील्ड्स के नामों की सूची लौटाती है, जिनके फ़ॉर्म के बाउंड डेटा में मान (आमतौर पर request.POST ) initial में प्रदान किए गए से भिन्न होते हैं। यदि कोई डेटा भिन्न नहीं है, तो यह एक खाली सूची देता है।

>>> f = ContactForm(request.POST, initial=data)
>>> if f.has_changed():
...     print("The following fields changed: %s" % ", ".join(f.changed_data))

फार्म से खेतों तक पहुंचना

Form.fields

आप इसकी fields विशेषता से Form आवृत्ति के फ़ील्ड तक पहुँच सकते हैं:

>>> for row in f.fields.values(): print(row)
...
<django.forms.fields.CharField object at 0x7ffaac632510>
<django.forms.fields.URLField object at 0x7ffaac632f90>
<django.forms.fields.CharField object at 0x7ffaac3aa050>
>>> f.fields['name']
<django.forms.fields.CharField object at 0x7ffaac6324d0>

Form में प्रस्तुत किए गए तरीके को बदलने के लिए आप Form उदाहरण के क्षेत्र को बदल सकते हैं:

>>> f.as_table().split('\n')[0]
'<tr><th>Name:</th><td><input name="name" type="text" value="instance" required></td></tr>'
>>> f.fields['name'].label = "Username"
>>> f.as_table().split('\n')[0]
'<tr><th>Username:</th><td><input name="name" type="text" value="instance" required></td></tr>'

base_fields विशेषता को बदलने के लिए सावधान रहें क्योंकि यह संशोधन एक ही पायथन प्रक्रिया के बाद के सभी base_fields उदाहरणों को प्रभावित करेगा:

>>> f.base_fields['name'].label = "Username"
>>> another_f = CommentForm(auto_id=False)
>>> another_f.as_table().split('\n')[0]
'<tr><th>Username:</th><td><input name="name" type="text" value="class" required></td></tr>'

"स्वच्छ" डेटा तक पहुँचना

Form.cleaned_data

Form क्लास में प्रत्येक फ़ील्ड न केवल डेटा को मान्य करने के लिए ज़िम्मेदार है, बल्कि "सफाई" के लिए भी है - इसे एक सुसंगत प्रारूप के लिए सामान्य करता है। यह एक अच्छी सुविधा है, क्योंकि यह एक विशेष क्षेत्र के लिए डेटा को विभिन्न तरीकों से इनपुट करने की अनुमति देता है, जिसके परिणामस्वरूप हमेशा अनुरूप आउटपुट होता है।

उदाहरण के लिए, DateField Python datetime.date ऑब्जेक्ट में इनपुट को सामान्य करता है। भले ही आप इसे '1994-07-15' प्रारूप में एक स्ट्रिंग पास कर दें, चाहे DateField ऑब्जेक्ट, या कई अन्य फॉर्मेट, DateField हमेशा इसे DateField ऑब्जेक्ट तक सामान्य कर देगा, जब तक यह वैध है।

एक बार जब आप डेटा के सेट के साथ एक Form इंस्टेंस बना लेते हैं और इसे सत्यापित करते हैं, तो आप इसके cleaned_data विशेषता के माध्यम से स्वच्छ डेटा तक पहुंच सकते हैं:

>>> data = {'subject': 'hello',
...         'message': 'Hi there',
...         'sender': '[email protected]',
...         'cc_myself': True}
>>> f = ContactForm(data)
>>> f.is_valid()
True
>>> f.cleaned_data
{'cc_myself': True, 'message': 'Hi there', 'sender': '[email protected]', 'subject': 'hello'}

ध्यान दें कि कोई भी टेक्स्ट-आधारित फ़ील्ड - जैसे कि CharField या EmailField - हमेशा इनपुट को एक स्ट्रिंग में साफ़ करता है। हम बाद में इस दस्तावेज़ में एन्कोडिंग निहितार्थ को कवर करेंगे।

यदि आपका डेटा मान्य नहीं करता है, तो cleaned_data शब्दकोश में केवल मान्य फ़ील्ड हैं:

>>> data = {'subject': '',
...         'message': 'Hi there',
...         'sender': 'invalid email address',
...         'cc_myself': True}
>>> f = ContactForm(data)
>>> f.is_valid()
False
>>> f.cleaned_data
{'cc_myself': True, 'message': 'Hi there'}

cleaned_data में हमेशा Form में परिभाषित फ़ील्ड के लिए एक कुंजी होगी, भले ही आप Form को परिभाषित करते समय अतिरिक्त डेटा पास करते हों। इस उदाहरण में, हम cleaned_data लिए अतिरिक्त फ़ील्ड का एक गुच्छा पास करते हैं, लेकिन cleaned_data में केवल फॉर्म के फ़ील्ड शामिल हैं:

>>> data = {'subject': 'hello',
...         'message': 'Hi there',
...         'sender': '[email protected]',
...         'cc_myself': True,
...         'extra_field_1': 'foo',
...         'extra_field_2': 'bar',
...         'extra_field_3': 'baz'}
>>> f = ContactForm(data)
>>> f.is_valid()
True
>>> f.cleaned_data # Doesn't contain extra_field_1, etc.
{'cc_myself': True, 'message': 'Hi there', 'sender': '[email protected]', 'subject': 'hello'}

जब Form वैध होता है, तो cleaned_data में उसके सभी फ़ील्ड के लिए एक कुंजी और मान शामिल होगा, भले ही डेटा में कुछ वैकल्पिक फ़ील्ड के लिए कोई मान शामिल न हो। इस उदाहरण में, डेटा डिक्शनरी में nick_name फ़ील्ड के लिए कोई मान शामिल नहीं है, लेकिन cleaned_data में इसे खाली स्थान के साथ शामिल किया गया है:

>>> from django import forms
>>> class OptionalPersonForm(forms.Form):
...     first_name = forms.CharField()
...     last_name = forms.CharField()
...     nick_name = forms.CharField(required=False)
>>> data = {'first_name': 'John', 'last_name': 'Lennon'}
>>> f = OptionalPersonForm(data)
>>> f.is_valid()
True
>>> f.cleaned_data
{'nick_name': '', 'first_name': 'John', 'last_name': 'Lennon'}

इस उपरोक्त उदाहरण में, cleaned_data लिए cleaned_data मान रिक्त स्ट्रिंग पर सेट किया गया है, क्योंकि nick_name CharField , और CharField s रिक्त मानों को एक रिक्त स्ट्रिंग के रूप में मानता है। प्रत्येक फ़ील्ड प्रकार जानता है कि उसका "रिक्त" मान क्या है - जैसे, DateField , यह खाली स्ट्रिंग के बजाय None । इस मामले में प्रत्येक क्षेत्र के व्यवहार के बारे में पूरी जानकारी के लिए, नीचे दिए गए "अंतर्निहित Field वर्ग" अनुभाग में प्रत्येक फ़ील्ड के लिए "खाली मान" नोट देखें।

आप विशेष प्रपत्र फ़ील्ड (उनके नाम के आधार पर) या पूरे के रूप में फॉर्म के लिए सत्यापन करने के लिए कोड लिख सकते हैं (विभिन्न क्षेत्रों के संयोजन पर विचार)। इसके बारे में अधिक जानकारी फॉर्म और फील्ड सत्यापन में है

HTML के रूप में आउटपुट स्वरूप

Form ऑब्जेक्ट का दूसरा कार्य खुद को HTML के रूप में प्रस्तुत करना है। ऐसा करने के लिए, बस इसे print :

>>> f = ContactForm()
>>> print(f)
<tr><th><label for="id_subject">Subject:</label></th><td><input id="id_subject" type="text" name="subject" maxlength="100" required></td></tr>
<tr><th><label for="id_message">Message:</label></th><td><input type="text" name="message" id="id_message" required></td></tr>
<tr><th><label for="id_sender">Sender:</label></th><td><input type="email" name="sender" id="id_sender" required></td></tr>
<tr><th><label for="id_cc_myself">Cc myself:</label></th><td><input type="checkbox" name="cc_myself" id="id_cc_myself"></td></tr>

यदि प्रपत्र डेटा के लिए बाध्य है, तो HTML आउटपुट में वह डेटा उचित रूप से शामिल होगा। उदाहरण के लिए, यदि किसी क्षेत्र को <input type="text"> द्वारा दर्शाया जाता है, तो डेटा value विशेषता में होगा। यदि किसी फ़ील्ड को <input type="checkbox"> द्वारा दर्शाया जाता है, तो उस HTML में उपयुक्त होने पर checked शामिल होगी:

>>> data = {'subject': 'hello',
...         'message': 'Hi there',
...         'sender': '[email protected]',
...         'cc_myself': True}
>>> f = ContactForm(data)
>>> print(f)
<tr><th><label for="id_subject">Subject:</label></th><td><input id="id_subject" type="text" name="subject" maxlength="100" value="hello" required></td></tr>
<tr><th><label for="id_message">Message:</label></th><td><input type="text" name="message" id="id_message" value="Hi there" required></td></tr>
<tr><th><label for="id_sender">Sender:</label></th><td><input type="email" name="sender" id="id_sender" value="[email protected]" required></td></tr>
<tr><th><label for="id_cc_myself">Cc myself:</label></th><td><input type="checkbox" name="cc_myself" id="id_cc_myself" checked></td></tr>

यह डिफ़ॉल्ट आउटपुट एक दो-कॉलम HTML तालिका है, जिसमें प्रत्येक क्षेत्र के लिए <tr> । निम्नलिखित पर ध्यान दें:

  • लचीलेपन के लिए, आउटपुट में <table> और </table> टैग शामिल नहीं हैं, और न ही इसमें <form> और </form> टैग या <input type="submit"> टैग शामिल हैं। ऐसा करना आपका काम है।
  • प्रत्येक फ़ील्ड प्रकार में एक डिफ़ॉल्ट HTML प्रतिनिधित्व होता है। CharField का प्रतिनिधित्व <input type="text"> और EmailField द्वारा <input type="email">BooleanField का प्रतिनिधित्व <input type="checkbox"> । ध्यान दें कि ये केवल समझदार चूक हैं; आप विगेट्स का उपयोग करके किसी HTML को दिए गए फ़ील्ड के लिए उपयोग करने के लिए निर्दिष्ट कर सकते हैं, जिसे हम शीघ्र ही समझाएंगे।
  • प्रत्येक टैग का HTML name सीधे उसके विशेषता नाम से ContactForm वर्ग में लिया जाता है।
  • प्रत्येक फ़ील्ड के लिए पाठ लेबल - जैसे 'Subject:' , 'Message:' और 'Cc myself:' सभी अंडरस्कोर को रिक्त स्थान में परिवर्तित करके और पहले अक्षर को ऊपरी आवरण में लाकर फ़ील्ड नाम से उत्पन्न होता है। फिर, ध्यान दें कि ये केवल समझदार चूक हैं; आप मैन्युअल रूप से लेबल भी निर्दिष्ट कर सकते हैं।
  • प्रत्येक पाठ लेबल एक HTML <label> टैग में घिरा हुआ है, जो इसकी id माध्यम से उपयुक्त फॉर्म फ़ील्ड को इंगित करता है। इसकी id , बदले में, 'id_' को फ़ील्ड नाम से 'id_' तैयार 'id_'id विशेषताओं और <label> टैग को सर्वोत्तम प्रथाओं का पालन करने के लिए डिफ़ॉल्ट रूप से आउटपुट में शामिल किया जाता है, लेकिन आप उस व्यवहार को बदल सकते हैं।
  • आउटपुट HTML5 सिंटैक्स का उपयोग करता है, लक्ष्यीकरण <!DOCTYPE html> । उदाहरण के लिए, यह बूलियन विशेषताओं का उपयोग करता है जैसे कि checked की गई XHTML शैली के बजाय checked='checked' की checked='checked'

यद्यपि आप किसी प्रपत्र को print करते समय <table> आउटपुट डिफ़ॉल्ट आउटपुट शैली है, अन्य आउटपुट शैली उपलब्ध हैं। प्रत्येक शैली प्रपत्र ऑब्जेक्ट पर एक विधि के रूप में उपलब्ध है, और प्रत्येक रेंडरिंग विधि एक स्ट्रिंग लौटाती है।

as_p()

Form.as_p()

as_p() प्रत्येक फ़ील्ड के साथ <p> टैग की एक श्रृंखला के रूप में रूप प्रदान करता है, जिसमें एक फ़ील्ड होता है:

>>> f = ContactForm()
>>> f.as_p()
'<p><label for="id_subject">Subject:</label> <input id="id_subject" type="text" name="subject" maxlength="100" required></p>\n<p><label for="id_message">Message:</label> <input type="text" name="message" id="id_message" required></p>\n<p><label for="id_sender">Sender:</label> <input type="text" name="sender" id="id_sender" required></p>\n<p><label for="id_cc_myself">Cc myself:</label> <input type="checkbox" name="cc_myself" id="id_cc_myself"></p>'
>>> print(f.as_p())
<p><label for="id_subject">Subject:</label> <input id="id_subject" type="text" name="subject" maxlength="100" required></p>
<p><label for="id_message">Message:</label> <input type="text" name="message" id="id_message" required></p>
<p><label for="id_sender">Sender:</label> <input type="email" name="sender" id="id_sender" required></p>
<p><label for="id_cc_myself">Cc myself:</label> <input type="checkbox" name="cc_myself" id="id_cc_myself"></p>

as_ul()

Form.as_ul()

as_ul() प्रपत्र को <li> टैग की एक श्रृंखला के रूप में प्रस्तुत करता है, जिसमें प्रत्येक <li> एक फ़ील्ड से युक्त होता है। इसमें <ul> या </ul> , ताकि आप लचीलेपन के लिए <ul> पर कोई HTML विशेषताएँ निर्दिष्ट कर सकें:

>>> f = ContactForm()
>>> f.as_ul()
'<li><label for="id_subject">Subject:</label> <input id="id_subject" type="text" name="subject" maxlength="100" required></li>\n<li><label for="id_message">Message:</label> <input type="text" name="message" id="id_message" required></li>\n<li><label for="id_sender">Sender:</label> <input type="email" name="sender" id="id_sender" required></li>\n<li><label for="id_cc_myself">Cc myself:</label> <input type="checkbox" name="cc_myself" id="id_cc_myself"></li>'
>>> print(f.as_ul())
<li><label for="id_subject">Subject:</label> <input id="id_subject" type="text" name="subject" maxlength="100" required></li>
<li><label for="id_message">Message:</label> <input type="text" name="message" id="id_message" required></li>
<li><label for="id_sender">Sender:</label> <input type="email" name="sender" id="id_sender" required></li>
<li><label for="id_cc_myself">Cc myself:</label> <input type="checkbox" name="cc_myself" id="id_cc_myself"></li>

as_table()

Form.as_table()

अंत में, as_table() HTML <table> रूप में फ़ॉर्म को आउटपुट करता है। यह बिलकुल print जैसा ही है। वास्तव में, जब आप एक फॉर्म ऑब्जेक्ट print करते हैं, तो वह पर्दे के पीछे अपनी as_table() विधि कहता है:

>>> f = ContactForm()
>>> f.as_table()
'<tr><th><label for="id_subject">Subject:</label></th><td><input id="id_subject" type="text" name="subject" maxlength="100" required></td></tr>\n<tr><th><label for="id_message">Message:</label></th><td><input type="text" name="message" id="id_message" required></td></tr>\n<tr><th><label for="id_sender">Sender:</label></th><td><input type="email" name="sender" id="id_sender" required></td></tr>\n<tr><th><label for="id_cc_myself">Cc myself:</label></th><td><input type="checkbox" name="cc_myself" id="id_cc_myself"></td></tr>'
>>> print(f)
<tr><th><label for="id_subject">Subject:</label></th><td><input id="id_subject" type="text" name="subject" maxlength="100" required></td></tr>
<tr><th><label for="id_message">Message:</label></th><td><input type="text" name="message" id="id_message" required></td></tr>
<tr><th><label for="id_sender">Sender:</label></th><td><input type="email" name="sender" id="id_sender" required></td></tr>
<tr><th><label for="id_cc_myself">Cc myself:</label></th><td><input type="checkbox" name="cc_myself" id="id_cc_myself"></td></tr>

आवश्यक या गलत रूप वाली पंक्तियों को स्टाइल करना

Form.error_css_class
Form.required_css_class

यह उन पंक्तियों और फ़ील्ड्स की शैली के लिए बहुत सामान्य है जिनकी आवश्यकता है या उनमें त्रुटियाँ हैं। उदाहरण के लिए, आप बोल्ड और हाइलाइट त्रुटियों को लाल रंग में आवश्यक रूप में प्रस्तुत करना चाहते हैं।

Form क्लास में कुछ ऐसे हुक होते हैं, जिनका उपयोग आप class विशेषताओं को आवश्यक पंक्तियों में या त्रुटियों वाली पंक्तियों में जोड़ने के लिए कर सकते हैं: बस Form.error_css_class और / या Form.required_css_class विशेषताएँ सेट करें:

from django import forms

class ContactForm(forms.Form):
    error_css_class = 'error'
    required_css_class = 'required'

    # ... and the rest of your fields here

एक बार जब आप ऐसा कर लेते हैं, तो पंक्तियों को आवश्यकतानुसार "error" और / या "required" कक्षाएं दी जाएंगी। HTML कुछ इस तरह दिखाई देगा:

>>> f = ContactForm(data)
>>> print(f.as_table())
<tr class="required"><th><label class="required" for="id_subject">Subject:</label>    ...
<tr class="required"><th><label class="required" for="id_message">Message:</label>    ...
<tr class="required error"><th><label class="required" for="id_sender">Sender:</label>      ...
<tr><th><label for="id_cc_myself">Cc myself:<label> ...
>>> f['subject'].label_tag()
<label class="required" for="id_subject">Subject:</label>
>>> f['subject'].label_tag(attrs={'class': 'foo'})
<label for="id_subject" class="foo required">Subject:</label>

फॉर्म एलिमेंट के HTML id विशेषताओं और <label> टैग को कॉन्फ़िगर करना

Form.auto_id

डिफ़ॉल्ट रूप से, रेंडरिंग विधियों में शामिल हैं:

  • HTML id फॉर्म एलिमेंट्स पर विशेषता देती है।
  • <label> आसपास संबंधित <label> टैग। एक HTML <label> टैग नामित करता है कि कौन सा लेबल पाठ किस फार्म तत्व से जुड़ा है। यह छोटी वृद्धि रूपों को सहायक उपकरणों के लिए अधिक उपयोगी और अधिक सुलभ बनाती है। <label> टैग का उपयोग करना हमेशा एक अच्छा विचार है।

id विशेषता मान, प्रपत्र फ़ील्ड नामों के लिए id_ को id_ करके बनाए जाते हैं। यह व्यवहार कॉन्फ़िगर करने योग्य है, हालाँकि, यदि आप id कन्वेंशन को बदलना चाहते हैं या HTML id विशेषताओं और <label> टैग को पूरी तरह से हटा सकते हैं।

id और लेबल व्यवहार को नियंत्रित करने के लिए Form कंस्ट्रक्टर को auto_id तर्क का उपयोग करें। यह तर्क True , False या एक स्ट्रिंग होना चाहिए।

यदि auto_id False , तो प्रपत्र आउटपुट में <label> टैग और id विशेषताएँ शामिल नहीं होंगी:

>>> f = ContactForm(auto_id=False)
>>> print(f.as_table())
<tr><th>Subject:</th><td><input type="text" name="subject" maxlength="100" required></td></tr>
<tr><th>Message:</th><td><input type="text" name="message" required></td></tr>
<tr><th>Sender:</th><td><input type="email" name="sender" required></td></tr>
<tr><th>Cc myself:</th><td><input type="checkbox" name="cc_myself"></td></tr>
>>> print(f.as_ul())
<li>Subject: <input type="text" name="subject" maxlength="100" required></li>
<li>Message: <input type="text" name="message" required></li>
<li>Sender: <input type="email" name="sender" required></li>
<li>Cc myself: <input type="checkbox" name="cc_myself"></li>
>>> print(f.as_p())
<p>Subject: <input type="text" name="subject" maxlength="100" required></p>
<p>Message: <input type="text" name="message" required></p>
<p>Sender: <input type="email" name="sender" required></p>
<p>Cc myself: <input type="checkbox" name="cc_myself"></p>

यदि auto_id True सेट है, तो फ़ॉर्म आउटपुट में <label> टैग शामिल होंगे और प्रत्येक फॉर्म फ़ील्ड के लिए फ़ील्ड नाम को अपनी id रूप में उपयोग करेंगे:

>>> f = ContactForm(auto_id=True)
>>> print(f.as_table())
<tr><th><label for="subject">Subject:</label></th><td><input id="subject" type="text" name="subject" maxlength="100" required></td></tr>
<tr><th><label for="message">Message:</label></th><td><input type="text" name="message" id="message" required></td></tr>
<tr><th><label for="sender">Sender:</label></th><td><input type="email" name="sender" id="sender" required></td></tr>
<tr><th><label for="cc_myself">Cc myself:</label></th><td><input type="checkbox" name="cc_myself" id="cc_myself"></td></tr>
>>> print(f.as_ul())
<li><label for="subject">Subject:</label> <input id="subject" type="text" name="subject" maxlength="100" required></li>
<li><label for="message">Message:</label> <input type="text" name="message" id="message" required></li>
<li><label for="sender">Sender:</label> <input type="email" name="sender" id="sender" required></li>
<li><label for="cc_myself">Cc myself:</label> <input type="checkbox" name="cc_myself" id="cc_myself"></li>
>>> print(f.as_p())
<p><label for="subject">Subject:</label> <input id="subject" type="text" name="subject" maxlength="100" required></p>
<p><label for="message">Message:</label> <input type="text" name="message" id="message" required></p>
<p><label for="sender">Sender:</label> <input type="email" name="sender" id="sender" required></p>
<p><label for="cc_myself">Cc myself:</label> <input type="checkbox" name="cc_myself" id="cc_myself"></p>

यदि auto_id एक स्ट्रिंग है जिसे प्रारूप वर्ण '%s' युक्त सेट किया गया है, तो प्रपत्र आउटपुट में <label> टैग शामिल होंगे, और प्रारूप स्ट्रिंग के आधार पर id विशेषताएँ उत्पन्न होंगी। उदाहरण के लिए, एक प्रारूप स्ट्रिंग 'field_%s' , subject नामक फ़ील्ड को id मान 'field_subject' । हमारे उदाहरण को जारी रखें:

>>> f = ContactForm(auto_id='id_for_%s')
>>> print(f.as_table())
<tr><th><label for="id_for_subject">Subject:</label></th><td><input id="id_for_subject" type="text" name="subject" maxlength="100" required></td></tr>
<tr><th><label for="id_for_message">Message:</label></th><td><input type="text" name="message" id="id_for_message" required></td></tr>
<tr><th><label for="id_for_sender">Sender:</label></th><td><input type="email" name="sender" id="id_for_sender" required></td></tr>
<tr><th><label for="id_for_cc_myself">Cc myself:</label></th><td><input type="checkbox" name="cc_myself" id="id_for_cc_myself"></td></tr>
>>> print(f.as_ul())
<li><label for="id_for_subject">Subject:</label> <input id="id_for_subject" type="text" name="subject" maxlength="100" required></li>
<li><label for="id_for_message">Message:</label> <input type="text" name="message" id="id_for_message" required></li>
<li><label for="id_for_sender">Sender:</label> <input type="email" name="sender" id="id_for_sender" required></li>
<li><label for="id_for_cc_myself">Cc myself:</label> <input type="checkbox" name="cc_myself" id="id_for_cc_myself"></li>
>>> print(f.as_p())
<p><label for="id_for_subject">Subject:</label> <input id="id_for_subject" type="text" name="subject" maxlength="100" required></p>
<p><label for="id_for_message">Message:</label> <input type="text" name="message" id="id_for_message" required></p>
<p><label for="id_for_sender">Sender:</label> <input type="email" name="sender" id="id_for_sender" required></p>
<p><label for="id_for_cc_myself">Cc myself:</label> <input type="checkbox" name="cc_myself" id="id_for_cc_myself"></p>

यदि auto_id किसी अन्य सही मान पर सेट है - जैसे कि एक स्ट्रिंग जिसमें %s शामिल नहीं है - तो पुस्तकालय ऐसा कार्य करेगा जैसे कि auto_id True

डिफ़ॉल्ट रूप से, auto_id स्ट्रिंग 'id_%s'

Form.label_suffix

एक अनुवाद योग्य स्ट्रिंग (अंग्रेजी में एक बृहदान्त्र (:) के लिए डिफ़ॉल्ट) जो किसी भी लेबल नाम के बाद जोड़ा जाएगा जब कोई प्रपत्र प्रदान किया जाता है।

उस चरित्र को कस्टमाइज़ करना संभव है, या label_suffix पैरामीटर का उपयोग करके इसे पूरी तरह से छोड़ दिया label_suffix :

>>> f = ContactForm(auto_id='id_for_%s', label_suffix='')
>>> print(f.as_ul())
<li><label for="id_for_subject">Subject</label> <input id="id_for_subject" type="text" name="subject" maxlength="100" required></li>
<li><label for="id_for_message">Message</label> <input type="text" name="message" id="id_for_message" required></li>
<li><label for="id_for_sender">Sender</label> <input type="email" name="sender" id="id_for_sender" required></li>
<li><label for="id_for_cc_myself">Cc myself</label> <input type="checkbox" name="cc_myself" id="id_for_cc_myself"></li>
>>> f = ContactForm(auto_id='id_for_%s', label_suffix=' ->')
>>> print(f.as_ul())
<li><label for="id_for_subject">Subject -></label> <input id="id_for_subject" type="text" name="subject" maxlength="100" required></li>
<li><label for="id_for_message">Message -></label> <input type="text" name="message" id="id_for_message" required></li>
<li><label for="id_for_sender">Sender -></label> <input type="email" name="sender" id="id_for_sender" required></li>
<li><label for="id_for_cc_myself">Cc myself -></label> <input type="checkbox" name="cc_myself" id="id_for_cc_myself"></li>

ध्यान दें कि लेबल प्रत्यय केवल तभी जोड़ा जाता है यदि लेबल का अंतिम वर्ण विराम चिह्न वर्ण नहीं है (अंग्रेजी में, वे हैं ? , ? या ? :)।

फ़ील्ड्स अपने स्वयं के label_suffix को भी परिभाषित कर सकते हैं। यह Form.label_suffix पर वरीयता Form.label_suffix label_suffix पैरामीटर से label_tag() का उपयोग करके रनटाइम पर भी प्रत्यय को ओवरराइड किया जा सकता है।

Form.use_required_attribute

True (डिफ़ॉल्ट) पर सेट होने पर, आवश्यक फ़ॉर्म फ़ील्ड में required HTML विशेषता होगी।

Formsets रूप में गलत ब्राउजर सत्यापन से बचने के लिए use_required_attribute=False साथ तत्काल फॉर्म को use_required_attribute=False

किसी प्रपत्र के विजेट के रेंडरिंग को कॉन्फ़िगर करना

Form.default_renderer

प्रपत्र के लिए उपयोग करने के लिए renderer निर्दिष्ट करता है। None को None चूक जिसका अर्थ है कि FORM_RENDERER सेटिंग द्वारा निर्दिष्ट डिफ़ॉल्ट रेंडरर का उपयोग करना।

आप इसे अपने फॉर्म की घोषणा करते समय एक वर्ग की विशेषता के रूप में सेट कर सकते हैं या Form.__init__() को renderer तर्क का उपयोग कर सकते हैं। उदाहरण के लिए:

from django import forms

class MyForm(forms.Form):
    default_renderer = MyRenderer()

या:

form = MyForm(renderer=MyRenderer())

फील्ड ऑर्डर पर नोट्स

में as_p() , as_ul() और as_table() शॉर्टकट, खेतों जिस क्रम में आप उन्हें अपने प्रपत्र वर्ग में परिभाषित में प्रदर्शित होते हैं। उदाहरण के लिए, में ContactForm उदाहरण के लिए, खेतों क्रम में परिभाषित कर रहे हैं subject , message , sender , cc_myself । HTML आउटपुट को पुन: व्यवस्थित करने के लिए, बस उस क्रम को बदलें जिसमें उन फ़ील्ड को कक्षा में सूचीबद्ध किया गया है।

आदेश को अनुकूलित करने के कई अन्य तरीके हैं:

Form.field_order

डिफ़ॉल्ट रूप से Form.field_order=None , जो उस क्रम को बनाए रखता है जिसमें आप अपनी फॉर्म क्लास में फ़ील्ड्स को परिभाषित करते हैं। यदि field_order फ़ील्ड नामों की सूची है, तो फ़ील्ड को सूची द्वारा निर्दिष्ट किया जाता है और शेष फ़ील्ड डिफ़ॉल्ट क्रम के अनुसार जोड़ दिए जाते हैं। सूची में अज्ञात फ़ील्ड नामों की अनदेखी की जाती है। यह उप- None क्रम में एक फ़ील्ड को अक्षम करने के लिए इसे फिर से परिभाषित करने के बिना सेट करने के लिए संभव बनाता है ।

आप फ़ील्ड ऑर्डर को ओवरराइड Form.field_order करने के लिए तर्क का भी उपयोग कर सकते हैं Form । यदि एक Form परिभाषित करता है और आप शामिल हैं जब तत्काल , तो बाद में पूर्ववर्ती होगा। field_order field_order Form field_order

Form.order_fields(field_order)

आप order_fields() फ़ील्ड नामों की सूची के साथ किसी भी समय फ़ील्ड को पुनर्व्यवस्थित कर सकते हैं field_order

त्रुटियों को कैसे प्रदर्शित किया जाता है

यदि आप किसी बाउंड Form ऑब्जेक्ट को रेंडर करते हैं, तो रेंडरिंग का कार्य स्वचालित रूप से फॉर्म के सत्यापन को चलाएगा यदि यह पहले से ही नहीं हुआ है, और HTML आउटपुट <ul class="errorlist"> में फ़ील्ड के पास सत्यापन त्रुटियों को शामिल किया जाएगा । त्रुटि संदेशों की विशेष स्थिति आपके द्वारा उपयोग किए जा रहे आउटपुट विधि पर निर्भर करती है:

>>> data = {'subject': '',
...         'message': 'Hi there',
...         'sender': 'invalid email address',
...         'cc_myself': True}
>>> f = ContactForm(data, auto_id=False)
>>> print(f.as_table())
<tr><th>Subject:</th><td><ul class="errorlist"><li>This field is required.</li></ul><input type="text" name="subject" maxlength="100" required></td></tr>
<tr><th>Message:</th><td><input type="text" name="message" value="Hi there" required></td></tr>
<tr><th>Sender:</th><td><ul class="errorlist"><li>Enter a valid email address.</li></ul><input type="email" name="sender" value="invalid email address" required></td></tr>
<tr><th>Cc myself:</th><td><input checked type="checkbox" name="cc_myself"></td></tr>
>>> print(f.as_ul())
<li><ul class="errorlist"><li>This field is required.</li></ul>Subject: <input type="text" name="subject" maxlength="100" required></li>
<li>Message: <input type="text" name="message" value="Hi there" required></li>
<li><ul class="errorlist"><li>Enter a valid email address.</li></ul>Sender: <input type="email" name="sender" value="invalid email address" required></li>
<li>Cc myself: <input checked type="checkbox" name="cc_myself"></li>
>>> print(f.as_p())
<p><ul class="errorlist"><li>This field is required.</li></ul></p>
<p>Subject: <input type="text" name="subject" maxlength="100" required></p>
<p>Message: <input type="text" name="message" value="Hi there" required></p>
<p><ul class="errorlist"><li>Enter a valid email address.</li></ul></p>
<p>Sender: <input type="email" name="sender" value="invalid email address" required></p>
<p>Cc myself: <input checked type="checkbox" name="cc_myself"></p>

त्रुटि सूची प्रारूप को अनुकूलित करना

डिफ़ॉल्ट रूप से, फ़ॉर्म django.forms.utils.ErrorList सत्यापन त्रुटियों को प्रारूपित करने के लिए उपयोग करते हैं। यदि आप त्रुटियों को प्रदर्शित करने के लिए एक वैकल्पिक वर्ग का उपयोग करना चाहते हैं, तो आप उसे निर्माण समय में पास कर सकते हैं:

>>> from django.forms.utils import ErrorList
>>> class DivErrorList(ErrorList):
...     def __str__(self):
...         return self.as_divs()
...     def as_divs(self):
...         if not self: return ''
...         return '<div class="errorlist">%s</div>' % ''.join(['<div class="error">%s</div>' % e for e in self])
>>> f = ContactForm(data, auto_id=False, error_class=DivErrorList)
>>> f.as_p()
<div class="errorlist"><div class="error">This field is required.</div></div>
<p>Subject: <input type="text" name="subject" maxlength="100" required></p>
<p>Message: <input type="text" name="message" value="Hi there" required></p>
<div class="errorlist"><div class="error">Enter a valid email address.</div></div>
<p>Sender: <input type="email" name="sender" value="invalid email address" required></p>
<p>Cc myself: <input checked type="checkbox" name="cc_myself"></p>

अधिक दानेदार उत्पादन

as_p() , as_ul() , और as_table() तरीकों बस शॉर्टकट हैं - वे एक ही तरीका है एक रूप वस्तु प्रदर्शित किया जा सकता नहीं कर रहे हैं।

class BoundField [source]

Form उदाहरण के एकल क्षेत्र के लिए HTML या अभिगम विशेषताएँ प्रदर्शित करने के लिए उपयोग किया जाता है ।

__str__() इस ऑब्जेक्ट की विधि इस फ़ील्ड के लिए HTML प्रदर्शित करती है।

किसी एकल को पुनः प्राप्त करने के लिए BoundField , फ़ील्ड के नाम को कुंजी के रूप में उपयोग करते हुए अपने रूप पर शब्दकोश लुकअप सिंटैक्स का प्रयोग करें

>>> form = ContactForm()
>>> print(form['subject'])
<input id="id_subject" type="text" name="subject" maxlength="100" required>

सभी BoundField ऑब्जेक्ट्स को पुनः प्राप्त करने के लिए , फ़ॉर्म को पुन : टाइप करें:

>>> form = ContactForm()
>>> for boundfield in form: print(boundfield)
<input id="id_subject" type="text" name="subject" maxlength="100" required>
<input type="text" name="message" id="id_message" required>
<input type="email" name="sender" id="id_sender" required>
<input type="checkbox" name="cc_myself" id="id_cc_myself">

फ़ील्ड-विशिष्ट आउटपुट प्रपत्र ऑब्जेक्ट की auto_id सेटिंग का सम्मान करता है :

>>> f = ContactForm(auto_id=False)
>>> print(f['message'])
<input type="text" name="message" required>
>>> f = ContactForm(auto_id='id_%s')
>>> print(f['message'])
<input type="text" name="message" id="id_message" required>

की विशेषताएँ BoundField

BoundField.auto_id

इसके लिए HTML ID विशेषता BoundField । यदि Form.auto_id है तो एक खाली स्ट्रिंग लौटाता है False

BoundField.data

यह गुण BoundField विजेट की value_from_datadict() विधि द्वारा निकाले गए इस डेटा के लिए , या None यदि यह नहीं दिया गया था:

>>> unbound_form = ContactForm()
>>> print(unbound_form['subject'].data)
None
>>> bound_form = ContactForm(data={'subject': 'My Subject'})
>>> print(bound_form['subject'].data)
My Subject
BoundField.errors

एक सूची जैसी वस्तु जो HTML के रूप में प्रदर्शित <ul class="errorlist"> होने पर मुद्रित होती है:

>>> data = {'subject': 'hi', 'message': '', 'sender': '', 'cc_myself': ''}
>>> f = ContactForm(data, auto_id=False)
>>> print(f['message'])
<input type="text" name="message" required>
>>> f['message'].errors
['This field is required.']
>>> print(f['message'].errors)
<ul class="errorlist"><li>This field is required.</li></ul>
>>> f['subject'].errors
[]
>>> print(f['subject'].errors)

>>> str(f['subject'].errors)
''
BoundField.field

Field प्रपत्र श्रेणी से प्रपत्र आवृत्ति जिसे यह BoundField लपेटता है।

BoundField.form

इस Form उदाहरण के BoundField लिए बाध्य है।

BoundField.help_text

help_text क्षेत्र की।

BoundField.html_name

वह नाम जो विजेट की HTML name विशेषता में उपयोग किया जाएगा । यह फॉर्म prefix को ध्यान में रखता है।

BoundField.id_for_label

इस फ़ील्ड की ID रेंडर करने के लिए इस गुण का उपयोग करें। उदाहरण के लिए, यदि आप मैन्युअल रूप <label> से अपने टेम्पलेट में निर्माण कर रहे हैं (इस तथ्य के बावजूद कि label_tag() यह आपके लिए ऐसा करेगा):

<label for="{{ form.my_field.id_for_label }}">...</label>{{ my_field }}

डिफ़ॉल्ट रूप से, यह उपर्युक्त उदाहरण के लिए id_ (" id_my_field ") द्वारा उपसर्गित क्षेत्र का नाम होगा । आप attrs फ़ील्ड के विजेट पर सेटिंग करके आईडी को संशोधित कर सकते हैं । उदाहरण के लिए, इस तरह से एक क्षेत्र घोषित करना:

my_field = forms.CharField(widget=forms.TextInput(attrs={'id': 'myFIELD'}))

और ऊपर दिए गए टेम्पलेट का उपयोग करके, कुछ इस तरह प्रस्तुत करना होगा:

<label for="myFIELD">...</label><input id="myFIELD" type="text" name="my_field" required>
BoundField.is_hidden

True यदि यह BoundField विजेट छिपा हुआ है तो लौटाता है।

BoundField.label

label क्षेत्र की। में इसका उपयोग किया जाता है label_tag()

BoundField.name

फार्म में इस क्षेत्र का नाम:

>>> f = ContactForm()
>>> print(f['subject'].name)
subject
>>> print(f['message'].name)
message

के तरीके BoundField

BoundField.as_hidden(attrs=None, **kwargs) [source]

एक के रूप में यह प्रतिनिधित्व करने के लिए HTML की एक स्ट्रिंग लौटाता है <input type="hidden">

**kwargs को पारित किया जाता है as_widget()

इस पद्धति का मुख्य रूप से आंतरिक रूप से उपयोग किया जाता है। आपको इसके बजाय एक विजेट का उपयोग करना चाहिए।

BoundField.as_widget(widget=None, attrs=None, only_initial=False) [source]

पास किए गए विजेट को रेंडर करके फ़ील्ड को रेंडर करते हैं, जो किसी भी HTML विशेषताओं को जोड़ते हैं attrs । यदि कोई विजेट निर्दिष्ट नहीं है, तो फ़ील्ड के डिफ़ॉल्ट विजेट का उपयोग किया जाएगा।

only_initial Django इंटर्न द्वारा उपयोग किया जाता है और इसे स्पष्ट रूप से सेट नहीं किया जाना चाहिए।

BoundField.css_classes() [source]

जब आप Django के रेंडरिंग शॉर्टकट का उपयोग करते हैं, तो सीएसएस कक्षाओं का उपयोग आवश्यक फॉर्म फ़ील्ड या फ़ील्ड में त्रुटियों को इंगित करने के लिए किया जाता है। यदि आप मैन्युअल रूप से रेंडर कर रहे हैं, तो आप css_classes विधि का उपयोग करके इन CSS कक्षाओं तक पहुँच सकते हैं :

>>> f = ContactForm(data={'message': ''})
>>> f['message'].css_classes()
'required'

यदि आप त्रुटि और आवश्यक कक्षाओं के अलावा कुछ अतिरिक्त कक्षाएं प्रदान करना चाहते हैं, तो आप उन कक्षाओं को तर्क के रूप में प्रदान कर सकते हैं:

>>> f = ContactForm(data={'message': ''})
>>> f['message'].css_classes('foo bar')
'foo bar required'
BoundField.label_tag(contents=None, attrs=None, label_suffix=None) [source]

प्रपत्र फ़ील्ड के लेबल टैग को अलग से प्रस्तुत करने के लिए, आप इसकी label_tag() विधि को कॉल कर सकते हैं :

>>> f = ContactForm(data={'message': ''})
>>> print(f['message'].label_tag())
<label for="id_message">Message:</label>

आप contents पैरामीटर प्रदान कर सकते हैं जो ऑटो-जनरेटेड लेबल टैग को बदल देगा। एक attrs शब्दकोश में <label> टैग के लिए अतिरिक्त विशेषताएँ हो सकती हैं ।

उत्पन्न होने वाले HTML में फॉर्म का Form.label_suffix (एक कॉलन, डिफ़ॉल्ट रूप से) या, यदि सेट किया गया है, तो वर्तमान फ़ील्ड शामिल है label_suffix । वैकल्पिक label_suffix पैरामीटर आपको किसी भी पहले से सेट प्रत्यय को ओवरराइड करने की अनुमति देता है। उदाहरण के लिए, आप चयनित फ़ील्ड पर लेबल को छिपाने के लिए एक खाली स्ट्रिंग का उपयोग कर सकते हैं। यदि आपको किसी टेम्पलेट में ऐसा करने की आवश्यकता है, तो आप पैरामीटर को पास करने की अनुमति देने के लिए एक कस्टम फ़िल्टर लिख सकते हैं label_tag

BoundField.value() [source]

इस फ़ील्ड के कच्चे मान को रेंडर करने के लिए इस विधि का उपयोग करें क्योंकि इसे a Widget : द्वारा प्रस्तुत किया जाएगा।

>>> initial = {'subject': 'welcome'}
>>> unbound_form = ContactForm(initial=initial)
>>> bound_form = ContactForm(data={'subject': 'hi'}, initial=initial)
>>> print(unbound_form['subject'].value())
welcome
>>> print(bound_form['subject'].value())
hi

अनुकूलित BoundField

यदि आपको टेम्प्लेट में प्रपत्र फ़ील्ड के बारे में कुछ अतिरिक्त जानकारी प्राप्त करने और Field पर्याप्त नहीं होने के उपवर्ग का उपयोग करने की आवश्यकता है, तो भी अनुकूलित करने पर विचार करें BoundField

एक कस्टम फ़ॉर्म फ़ील्ड ओवरराइड कर सकता है get_bound_field() :

Field.get_bound_field(form, field_name) [source]

Form क्षेत्र का नाम और उदाहरण लेता है । टेम्पलेट में फ़ील्ड का उपयोग करते समय रिटर्न वैल्यू का उपयोग किया जाएगा। सबसे अधिक संभावना है कि यह एक उपवर्ग का उदाहरण होगा BoundField

यदि आपके पास GPSCoordinatesField उदाहरण के लिए, और टेम्पलेट में निर्देशांक के बारे में अतिरिक्त जानकारी प्राप्त करने में सक्षम होना चाहते हैं, तो इसे निम्नानुसार लागू किया जा सकता है:

class GPSCoordinatesBoundField(BoundField):
    @property
    def country(self):
        """
        Return the country the coordinates lie in or None if it can't be
        determined.
        """
        value = self.value()
        if value:
            return get_country_from_coordinates(value)
        else:
            return None

class GPSCoordinatesField(Field):
    def get_bound_field(self, form, field_name):
        return GPSCoordinatesBoundField(form, self, field_name)

अब आप एक टेम्पलेट के साथ देश में पहुँच सकते हैं {{ form.coordinates.country }}

बाइंडिंग फ़ाइलों को एक प्रपत्र में

फॉर्म FileField और ImageField फ़ील्ड्स के साथ डील करना सामान्य फॉर्म की तुलना में थोड़ा अधिक जटिल है।

सबसे पहले, क्रम फ़ाइलों को अपलोड करने के लिए, आप सुनिश्चित करें कि आपके बनाने की आवश्यकता होगी <form> तत्व सही ढंग से परिभाषित करता है enctype के रूप में "multipart/form-data" :

<form enctype="multipart/form-data" method="post" action="/foo/">

दूसरे, जब आप फ़ॉर्म का उपयोग करते हैं, तो आपको फ़ाइल डेटा को बाइंड करने की आवश्यकता होती है। फ़ाइल डेटा सामान्य रूप डेटा के लिए अलग से नियंत्रित किया जाता है, इसलिए जब आपके प्रपत्र में शामिल है एक FileField और ImageField , आप एक दूसरा तर्क है जब आप अपने प्रपत्र बाँध निर्दिष्ट करने के लिए की आवश्यकता होगी। इसलिए यदि हम अपने कॉन्टेक्टफार्म को विस्तारित करने के लिए ImageField कहते हैं mugshot , तो हमें मगशॉट इमेज वाले फाइल डेटा को बांधने की जरूरत है:

# Bound form with an image field
>>> from django.core.files.uploadedfile import SimpleUploadedFile
>>> data = {'subject': 'hello',
...         'message': 'Hi there',
...         'sender': '[email protected]',
...         'cc_myself': True}
>>> file_data = {'mugshot': SimpleUploadedFile('face.jpg', <file data>)}
>>> f = ContactFormWithMugshot(data, file_data)

व्यवहार में, आप आमतौर पर request.FILES फ़ाइल डेटा के स्रोत के रूप में निर्दिष्ट करेंगे (जैसे आप request.POST फॉर्म डेटा के स्रोत के रूप में उपयोग करते हैं):

# Bound form with an image field, data from the request
>>> f = ContactFormWithMugshot(request.POST, request.FILES)

एक अनबाउंड फॉर्म का निर्माण हमेशा की तरह ही होता है - डेटा और फाइल डेटा दोनों को छोड़ दें :

# Unbound form with an image field
>>> f = ContactFormWithMugshot()

मल्टीपर्ट रूपों के लिए परीक्षण

Form.is_multipart()

यदि आप पुन: प्रयोज्य दृश्य या टेम्प्लेट लिख रहे हैं, तो आप समय से पहले नहीं जान सकते हैं कि आपका फॉर्म मल्टीपार्ट है या नहीं। is_multipart() विधि आपको बताता है कि प्रपत्र प्रस्तुत करने के लिए बहुखण्डीय एन्कोडिंग की आवश्यकता है या नहीं:

>>> f = ContactFormWithMugshot()
>>> f.is_multipart()
True

यहां एक उदाहरण दिया गया है कि आप इसका उपयोग कैसे कर सकते हैं:

{% if form.is_multipart %}
    <form enctype="multipart/form-data" method="post" action="/foo/">
{% else %}
    <form method="post" action="/foo/">
{% endif %}
{{ form }}
</form>

उपवर्गों का गठन

यदि आपके पास कई Form वर्ग हैं जो फ़ील्ड साझा करते हैं, तो आप अतिरेक को हटाने के लिए उपयोग कर सकते हैं।

जब आप एक कस्टम Form वर्ग को उप- वर्ग करते हैं, तो परिणामी उपवर्ग में मूल वर्ग (es) के सभी फ़ील्ड शामिल होंगे, इसके बाद आपके द्वारा उपवर्ग में परिभाषित फ़ील्ड।

इस उदाहरण में, ContactFormWithPriority से सभी क्षेत्रों में शामिल है ContactForm , के साथ साथ एक अतिरिक्त क्षेत्र, priorityContactForm खेतों पहले आदेश दिया जाता है:

>>> class ContactFormWithPriority(ContactForm):
...     priority = forms.CharField()
>>> f = ContactFormWithPriority(auto_id=False)
>>> print(f.as_ul())
<li>Subject: <input type="text" name="subject" maxlength="100" required></li>
<li>Message: <input type="text" name="message" required></li>
<li>Sender: <input type="email" name="sender" required></li>
<li>Cc myself: <input type="checkbox" name="cc_myself"></li>
<li>Priority: <input type="text" name="priority" required></li>

मिश्रणों के रूप में उपचार करते हुए, कई रूपों को उप-वर्ग करना संभव है। इस उदाहरण में, BeatleForm दोनों उपवर्गों PersonForm और InstrumentForm (इसी क्रम में), और अपने क्षेत्र सूची जनक वर्गों से क्षेत्रों में शामिल हैं:

>>> from django import forms
>>> class PersonForm(forms.Form):
...     first_name = forms.CharField()
...     last_name = forms.CharField()
>>> class InstrumentForm(forms.Form):
...     instrument = forms.CharField()
>>> class BeatleForm(InstrumentForm, PersonForm):
...     haircut_type = forms.CharField()
>>> b = BeatleForm(auto_id=False)
>>> print(b.as_ul())
<li>First name: <input type="text" name="first_name" required></li>
<li>Last name: <input type="text" name="last_name" required></li>
<li>Instrument: <input type="text" name="instrument" required></li>
<li>Haircut type: <input type="text" name="haircut_type" required></li>

उप- Field क्षेत्र None पर फ़ील्ड का नाम सेट करके मूल रूप से मूल श्रेणी से वंशानुगत निकालना संभव है । उदाहरण के लिए:

>>> from django import forms

>>> class ParentForm(forms.Form):
...     name = forms.CharField()
...     age = forms.IntegerField()

>>> class ChildForm(ParentForm):
...     name = None

>>> list(ChildForm().fields)
['age']

रूपों के लिए उपसर्ग

Form.prefix

आप एक <form> टैग के अंदर कई Django फॉर्म डाल सकते हैं । प्रत्येक Form अपने स्वयं के नाम स्थान देने के लिए, prefix कीवर्ड तर्क का उपयोग करें :

>>> mother = PersonForm(prefix="mother")
>>> father = PersonForm(prefix="father")
>>> print(mother.as_ul())
<li><label for="id_mother-first_name">First name:</label> <input type="text" name="mother-first_name" id="id_mother-first_name" required></li>
<li><label for="id_mother-last_name">Last name:</label> <input type="text" name="mother-last_name" id="id_mother-last_name" required></li>
>>> print(father.as_ul())
<li><label for="id_father-first_name">First name:</label> <input type="text" name="father-first_name" id="id_father-first_name" required></li>
<li><label for="id_father-last_name">Last name:</label> <input type="text" name="father-last_name" id="id_father-last_name" required></li>

उपसर्ग फॉर्म क्लास पर भी निर्दिष्ट किया जा सकता है:

>>> class PersonForm(forms.Form):
...     ...
...     prefix = 'person'

Original text