Django 2.1

Widgets




django

Widgets

एक विजेट Django के एक HTML इनपुट तत्व का प्रतिनिधित्व करता है। विजेट HTML के प्रतिपादन और GET / POST शब्दकोश से डेटा के निष्कर्षण को संभालता है जो विजेट से मेल खाता है।

अंतर्निहित विजेट द्वारा उत्पन्न HTML HTML5 सिंटैक्स का उपयोग करता है, लक्ष्यीकरण <!DOCTYPE html> । उदाहरण के लिए, यह बूलियन विशेषताओं का उपयोग करता है जैसे कि checked की गई XHTML शैली के बजाय checked='checked' की checked='checked'

टिप

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

विगेट्स निर्दिष्ट करना

जब भी आप किसी फ़ॉर्म पर फ़ील्ड निर्दिष्ट करते हैं, तो Django एक डिफ़ॉल्ट विजेट का उपयोग करेगा जो प्रदर्शित होने वाले डेटा के प्रकार के लिए उपयुक्त है। किस फ़ील्ड पर किस विजेट का उपयोग किया जाता है, यह जानने के लिए, अंतर्निहित फ़ील्ड कक्षाओं के बारे में दस्तावेज़ देखें।

हालाँकि, यदि आप किसी फ़ील्ड के लिए एक अलग विजेट का उपयोग करना चाहते हैं, तो आप फ़ील्ड परिभाषा पर widget तर्क का उपयोग कर सकते हैं। उदाहरण के लिए:

from django import forms

class CommentForm(forms.Form):
    name = forms.CharField()
    url = forms.URLField()
    comment = forms.CharField(widget=forms.Textarea)

यह डिफ़ॉल्ट TextInput विजेट के बजाय एक बड़े Textarea विजेट का उपयोग करने वाली टिप्पणी के साथ एक प्रपत्र निर्दिष्ट करेगा।

विगेट्स के लिए तर्क सेट करना

कई विजेट्स में वैकल्पिक अतिरिक्त तर्क हैं; जब वे फ़ील्ड पर विजेट को परिभाषित करते हैं, तो उन्हें सेट किया जा सकता है। निम्न उदाहरण में, SelectDateWidget लिए years विशेषता सेट की SelectDateWidget :

from django import forms

BIRTH_YEAR_CHOICES = ('1980', '1981', '1982')
FAVORITE_COLORS_CHOICES = (
    ('blue', 'Blue'),
    ('green', 'Green'),
    ('black', 'Black'),
)

class SimpleForm(forms.Form):
    birth_year = forms.DateField(widget=forms.SelectDateWidget(years=BIRTH_YEAR_CHOICES))
    favorite_colors = forms.MultipleChoiceField(
        required=False,
        widget=forms.CheckboxSelectMultiple,
        choices=FAVORITE_COLORS_CHOICES,
    )

निर्मित विगेट्स के बारे में अधिक जानकारी के लिए देखें कि कौन से विजेट उपलब्ध हैं और वे कौन से तर्क स्वीकार करते हैं।

विजेट विजेट से विरासत में मिला

Select के साथ विजेट विजेट से विरासत में मिलने वाले विजेट। वे उपयोगकर्ता को चुनने के लिए विकल्पों की सूची के साथ प्रस्तुत करते हैं। अलग-अलग विजेट इस पसंद को अलग तरह से पेश करते हैं; विजेट का Select स्वयं ही एक <select> HTML सूची प्रतिनिधित्व का उपयोग करता है, जबकि RadioSelect रेडियो बटन का उपयोग करता है।

ChoiceField विजेट डिफ़ॉल्ट रूप से ChoiceField फ़ील्ड पर उपयोग किए ChoiceField हैं। विजेट पर प्रदर्शित विकल्प ChoiceField से विरासत में ChoiceField और ChoiceField.choices बदलने से ChoiceField.choices अपडेट Select.choices । उदाहरण के लिए:

>>> from django import forms
>>> CHOICES = (('1', 'First',), ('2', 'Second',))
>>> choice_field = forms.ChoiceField(widget=forms.RadioSelect, choices=CHOICES)
>>> choice_field.choices
[('1', 'First'), ('2', 'Second')]
>>> choice_field.widget.choices
[('1', 'First'), ('2', 'Second')]
>>> choice_field.widget.choices = ()
>>> choice_field.choices = (('1', 'First and only',),)
>>> choice_field.widget.choices
[('1', 'First and only')]

विजेट जो एक Select.choices पेशकश करते हैं, हालांकि उन क्षेत्रों के साथ उपयोग किया जा सकता है जो पसंद पर आधारित नहीं हैं - जैसे कि CharField - लेकिन यह एक ChoiceField आधारित क्षेत्र का उपयोग करने के लिए अनुशंसित है जब विकल्प मॉडल के लिए अंतर्निहित होते हैं और न केवल प्रतिनिधित्ववादी विजेट।

विजेट उदाहरणों को अनुकूलित करना

जब Django HTML के रूप में एक विजेट प्रदान करता है, तो यह केवल बहुत ही न्यूनतम मार्कअप प्रस्तुत करता है - Django वर्ग के नाम, या किसी अन्य विजेट-विशिष्ट विशेषताओं को नहीं जोड़ता है। इसका अर्थ है, उदाहरण के लिए, सभी TextInput विजेट आपके वेब पृष्ठों पर समान दिखाई देंगे।

विजेट को अनुकूलित करने के दो तरीके हैं: प्रति विजेट उदाहरण और प्रति विजेट वर्ग

स्टाइलिंग विजेट उदाहरण

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

उदाहरण के लिए, निम्नलिखित सरल रूप लें:

from django import forms

class CommentForm(forms.Form):
    name = forms.CharField()
    url = forms.URLField()
    comment = forms.CharField()

इस फॉर्म में तीन डिफ़ॉल्ट TextInput विजेट शामिल होंगे, डिफ़ॉल्ट रेंडरिंग के साथ - कोई CSS क्लास नहीं, कोई अतिरिक्त विशेषताएँ नहीं। इसका मतलब यह है कि प्रत्येक विजेट के लिए प्रदान किए गए इनपुट बॉक्स बिल्कुल उसी तरह प्रदान किए जाएंगे:

>>> f = CommentForm(auto_id=False)
>>> f.as_table()
<tr><th>Name:</th><td><input type="text" name="name" 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>

एक वास्तविक वेब पेज पर, आप शायद हर विजेट को एक जैसा नहीं देखना चाहते। आप टिप्पणी के लिए एक बड़ा इनपुट तत्व चाहते हैं, और आप चाहते हो सकता है कि 'नाम' विजेट में कुछ विशेष सीएसएस वर्ग हो। नए HTML5 इनपुट प्रकारों का लाभ उठाने के लिए 'प्रकार' विशेषता को निर्दिष्ट करना भी संभव है। ऐसा करने के लिए, आप विजेट बनाते समय Widget.attrs तर्क का उपयोग करते हैं:

class CommentForm(forms.Form):
    name = forms.CharField(widget=forms.TextInput(attrs={'class': 'special'}))
    url = forms.URLField()
    comment = forms.CharField(widget=forms.TextInput(attrs={'size': '40'}))

आप प्रपत्र में एक विजेट को संशोधित कर सकते हैं:

class CommentForm(forms.Form):
    name = forms.CharField()
    url = forms.URLField()
    comment = forms.CharField()

    name.widget.attrs.update({'class': 'special'})
    comment.widget.attrs.update(size='40')

या यदि फ़ील्ड को सीधे फॉर्म पर घोषित नहीं किया जाता है (जैसे कि मॉडल फॉर्म फ़ील्ड), तो आप Form.fields विशेषता का उपयोग कर सकते हैं:

class CommentForm(forms.ModelForm):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.fields['name'].widget.attrs.update({'class': 'special'})
        self.fields['comment'].widget.attrs.update(size='40')

तब Django प्रदान किए गए आउटपुट में अतिरिक्त विशेषताओं को शामिल करेगा:

>>> f = CommentForm(auto_id=False)
>>> f.as_table()
<tr><th>Name:</th><td><input type="text" name="name" class="special" 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" size="40" required></td></tr>

आप Widget.attrs का उपयोग करके HTML id भी सेट कर सकते हैं। एक उदाहरण के लिए BoundField.id_for_label देखें।

स्टाइलिंग विजेट कक्षाएं

विगेट्स के साथ, संपत्ति ( css और javascript ) को जोड़ना संभव है और उनकी उपस्थिति और व्यवहार को अधिक गहराई से अनुकूलित करना है।

संक्षेप में, आपको विजेट को उप-वर्ग करना होगा और या तो एक "मीडिया" आंतरिक वर्ग को परिभाषित करना होगा या एक "मीडिया" संपत्ति बनाना होगा

इन विधियों में कुछ उन्नत पायथन प्रोग्रामिंग शामिल है और इसे फॉर्म एसेट्स विषय गाइड में विस्तार से वर्णित किया गया है।

बेस विजेट कक्षाएं

बेस विजेट क्लासेस Widget और MultiWidget सभी अंतर्निहित विजेट्स द्वारा उप- MultiWidget किए MultiWidget हैं और कस्टम विजेट्स की नींव के रूप में काम कर सकते हैं।

Widget

class Widget(attrs=None) [source]

इस अमूर्त वर्ग का प्रतिपादन नहीं किया जा सकता है, लेकिन यह मूल विशेषता प्रदान करता है। आप कस्टम विजेट पर render() पद्धति को लागू या ओवरराइड भी कर सकते हैं।

attrs

HTML विशेषता वाला एक शब्दकोश प्रदान किए गए विजेट पर सेट किया जाना चाहिए।

>>> from django import forms
>>> name = forms.TextInput(attrs={'size': 10, 'title': 'Your name'})
>>> name.render('name', 'A name')
'<input title="Your name" type="text" name="name" value="A name" size="10">'

यदि आप किसी विशेषता के लिए True या False का मान असाइन करते हैं, तो उसे HTML5 बूलियन विशेषता के रूप में प्रस्तुत किया जाएगा:

>>> name = forms.TextInput(attrs={'required': True})
>>> name.render('name', 'A name')
'<input name="name" type="text" value="A name" required>'
>>>
>>> name = forms.TextInput(attrs={'required': False})
>>> name.render('name', 'A name')
'<input name="name" type="text" value="A name">'
supports_microseconds

एक विशेषता जो True को डिफॉल्ट करती है। यदि False सेट किया जाता है, तो datetime और time मानों के माइक्रोसेकंड भाग को 0 सेट किया जाएगा।

format_value(value) [source]

विजेट टेम्पलेट में उपयोग के लिए एक मूल्य को साफ करता है और वापस करता है। value मान्य इनपुट होने की गारंटी नहीं है, इसलिए उपवर्ग कार्यान्वयन रक्षात्मक रूप से कार्यक्रम करना चाहिए।

get_context(name, value, attrs) [source]

विजेट टेम्प्लेट को प्रस्तुत करते समय उपयोग करने के लिए मूल्यों का शब्दकोश देता है। डिफ़ॉल्ट रूप से, शब्दकोश में एक कुंजी होती है, 'widget' , जो निम्नलिखित कुंजियों वाले विजेट का एक शब्दकोष है।

  • 'name' : name तर्क से क्षेत्र का name
  • 'is_hidden' : यह दर्शाने वाला बूलियन है कि यह विजेट छिपा है या नहीं।
  • 'required' : यह दर्शाने वाला बूलियन है कि इस विजेट के लिए फ़ील्ड की आवश्यकता है या नहीं।
  • 'value' : format_value() द्वारा लौटाया गया मान।
  • 'attrs' : HTML विशेषताओं को प्रदान किए गए विजेट पर सेट किया जाना है। Widget.attrs विशेषता का संयोजन और attrs तर्क।
  • 'template_name' : self.template_name का self.template_name

Widget उपवर्ग इस पद्धति को ओवरराइड करके कस्टम संदर्भ मान प्रदान कर सकते हैं।

id_for_label(id_) [source]

फ़ील्ड के ID को देखते हुए <label> द्वारा उपयोग किए जाने के लिए इस विजेट की HTML आईडी विशेषता देता है। अगर कोई आईडी उपलब्ध None तो None लौटाता है।

यह हुक आवश्यक है क्योंकि कुछ विजेट में कई HTML तत्व होते हैं और इस प्रकार, कई आईडी होते हैं। उस स्थिति में, इस पद्धति को एक आईडी मान लौटाया जाना चाहिए जो विजेट के टैग में पहली आईडी से मेल खाता है।

render(name, value, attrs=None, renderer=None) [source]

दिए गए रेंडर का उपयोग करके HTML पर एक विजेट रेंडर करें। यदि renderer None , तो FORM_RENDERER सेटिंग से रेंडरर का उपयोग किया जाता है।

value_from_datadict(data, files, name) [source]

डेटा के एक शब्दकोश और इस विजेट के नाम को देखते हुए, इस विजेट का मान लौटाता है। files request.FILES से आने वाला डेटा हो सकता है। यदि कोई मूल्य प्रदान नहीं किया गया तो None लौटाता है। यह भी ध्यान दें कि फॉर्म डेटा को संभालने के दौरान value_from_datadict को एक से अधिक बार कॉल किया जा सकता है, इसलिए यदि आप इसे कस्टमाइज़ करते हैं और महंगी प्रोसेसिंग को जोड़ते हैं, तो आपको कुछ कैशिंग तंत्र को स्वयं लागू करना चाहिए।

value_omitted_from_data(data, files, name) [source]

data और files शब्दकोशों और इस विजेट के नाम को देखते हुए, विजेट के लिए डेटा या फाइलें हैं या नहीं, यह लौटाता है।

विधि का परिणाम प्रभावित करता है कि मॉडल रूप में कोई फ़ील्ड अपने डिफ़ॉल्ट पर वापस आती है या नहीं।

विशेष मामले हैं CheckboxInput , CheckboxSelectMultiple , और SelectMultiple , जो हमेशा False रिटर्न करते हैं क्योंकि एक अनियंत्रित चेकबॉक्स और अचयनित <select multiple> एचटीएमएल फॉर्म जमा करने के डेटा में दिखाई नहीं देते हैं, इसलिए अज्ञात है कि क्या उपयोगकर्ता ने एक मूल्य प्रस्तुत किया है या नहीं।

use_required_attribute(initial) [source]

प्रपत्र फ़ील्ड के initial मान को देखते हुए, विजेट required HTML विशेषता के साथ प्रदान किया जा सकता है या नहीं। प्रपत्र Field.required के लिए इस विधि का उपयोग करते हैं। यह निर्धारित करने के लिए कि क्या प्रत्येक फ़ील्ड के लिए required विशेषता प्रदर्शित करना है या नहीं।

डिफ़ॉल्ट रूप से, छिपे हुए विजेट के लिए False रिटर्न देता है और अन्यथा True है। विशेष मामले ClearableFileInput , जो initial सेट नहीं होने पर False रिटर्न देता है, और CheckboxSelectMultiple , जो हमेशा False रिटर्न करता है क्योंकि ब्राउज़र सत्यापन को कम से कम एक के बजाय सभी चेकबॉक्स की जांच करनी होगी।

कस्टम विगेट्स में इस विधि को ओवरराइड करें जो ब्राउज़र सत्यापन के अनुकूल नहीं हैं। उदाहरण के लिए, एक छिपी हुई textarea तत्व द्वारा समर्थित एक WSYSIWG टेक्स्ट एडिटर विजेट, छिपे हुए फ़ील्ड पर ब्राउज़र सत्यापन से बचने के लिए हमेशा False लौटा सकता है।

MultiWidget

class MultiWidget(widgets, attrs=None) [source]

एक विजेट जो कई विजेट से बना है। MultiWidget साथ MultiWidget हाथ से काम करता है।

MultiWidget में एक आवश्यक तर्क है:

widgets

विगेट्स युक्त एक चलने योग्य की जरूरत है।

और एक आवश्यक विधि:

decompress(value) [source]

यह विधि क्षेत्र से एक एकल "संपीड़ित" मान लेती है और "विघटित" मूल्यों की सूची लौटाती है। इनपुट मान को मान्य माना जा सकता है, लेकिन जरूरी नहीं कि खाली न हो।

इस विधि को उपवर्ग द्वारा लागू किया जाना चाहिए , और चूंकि मूल्य खाली हो सकता है, इसलिए कार्यान्वयन रक्षात्मक होना चाहिए।

"विघटन" के पीछे तर्क यह है कि फॉर्म फ़ील्ड के संयुक्त मूल्य को प्रत्येक विजेट के लिए मानों में "विभाजित" करना आवश्यक है।

इसका एक उदाहरण यह है कि कैसे SplitDateTimeWidget तिथि और समय दो अलग-अलग मूल्यों में विभाजित होने के साथ एक सूची में SplitDateTimeWidget मान बदल जाता है:

from django.forms import MultiWidget

class SplitDateTimeWidget(MultiWidget):

    # ...

    def decompress(self, value):
        if value:
            return [value.date(), value.time()]
        return [None, None]

टिप

ध्यान दें कि MultiValueField में एक विपरीत विधि के साथ एक पूरक विधि compress() - सभी सदस्य क्षेत्रों के साफ किए गए मूल्यों को एक में मिलाने के लिए।

यह कुछ कस्टम संदर्भ प्रदान करता है:

get_context(name, value, attrs) [source]

Widget.get_context() में वर्णित 'widget' कुंजी के अलावा, Widget.get_context() एक widget['subwidgets'] कुंजी जोड़ता है।

इन्हें विजेट टेम्प्लेट में बंद किया जा सकता है:

{% for subwidget in widget.subwidgets %}
    {% include widget.template_name with widget=subwidget %}
{% endfor %}

यहाँ एक उदाहरण विजेट है जो MultiWidget को विभिन्न चुनिंदा बॉक्सों में दिन, महीने और वर्ष के साथ प्रदर्शित करने के लिए उप-वर्ग MultiWidget है। यह विजेट एक DateField बजाय एक DateField साथ उपयोग करने का इरादा है, इस प्रकार हमने value_from_datadict() लागू किया है:

from datetime import date
from django.forms import widgets

class DateSelectorWidget(widgets.MultiWidget):
    def __init__(self, attrs=None):
        # create choices for days, months, years
        # example below, the rest snipped for brevity.
        years = [(year, year) for year in (2011, 2012, 2013)]
        _widgets = (
            widgets.Select(attrs=attrs, choices=days),
            widgets.Select(attrs=attrs, choices=months),
            widgets.Select(attrs=attrs, choices=years),
        )
        super().__init__(_widgets, attrs)

    def decompress(self, value):
        if value:
            return [value.day, value.month, value.year]
        return [None, None, None]

    def value_from_datadict(self, data, files, name):
        datelist = [
            widget.value_from_datadict(data, files, name + '_%s' % i)
            for i, widget in enumerate(self.widgets)]
        try:
            D = date(
                day=int(datelist[0]),
                month=int(datelist[1]),
                year=int(datelist[2]),
            )
        except ValueError:
            return ''
        else:
            return str(D)

निर्माणकर्ता एक टपल में कई Select विजेट बनाता है। super क्लास विजेट को सेटअप करने के लिए इस ट्यूपल का उपयोग करता है।

प्रत्येक विजेट के अनुरूप दिन, महीने, और वर्ष मानों में आवश्यक विधि decompress() एक datetime.date मान को तोड़ता है। ध्यान दें कि विधि उस मामले को कैसे संभालती है जहां value None

value_from_datadict() का डिफ़ॉल्ट कार्यान्वयन प्रत्येक Widget अनुरूप मानों की एक सूची देता है। यह MultiWidget साथ MultiWidget का उपयोग करते समय उचित है, लेकिन चूंकि हम इस विजेट को DateField साथ उपयोग करना चाहते हैं, जो एकल मूल्य लेता है, इसलिए हमने इस पद्धति को सभी सबविजेट्स के डेटा को डेटाइमटाइम में संयोजित करने के लिए ओवरराइड किया है। विधि POST शब्दकोश से डेटा निकालता है और तारीख का निर्माण और सत्यापन करता है। यदि यह मान्य है, तो हम स्ट्रिंग लौटाते हैं, अन्यथा, हम एक रिक्त स्ट्रिंग लौटाते हैं, जो form.is_valid का कारण form.is_validform.is_valid को वापस करने के लिए।

निर्मित विगेट्स

Django सभी बुनियादी HTML विगेट्स का प्रतिनिधित्व प्रदान करता है, साथ ही django.forms.widgets मॉड्यूल के कुछ सामान्य रूप से उपयोग किए जाने वाले समूहों का भी पाठ , विभिन्न चेकबॉक्स और चयनकर्ताओं , फ़ाइलों को अपलोड करने , और बहु-मूल्यवान इनपुट से निपटने सहित

पाठ का इनपुट संभालने वाले विजेट

ये विजेट HTML एलिमेंट्स input और textarea

TextInput

class TextInput [source]
  • input_type : 'text'
  • template_name : 'django/forms/widgets/text.html'
  • रेंडरर्स के रूप में: <input type="text" ...>

NumberInput

class NumberInput [source]
  • input_type : 'number'
  • template_name : 'django/forms/widgets/number.html'
  • रेंडरर्स के रूप में: <input type="number" ...>

सावधान रहें कि सभी ब्राउज़र number इनपुट प्रकारों में स्थानीयकृत संख्या दर्ज करने का समर्थन नहीं करते हैं। Django खुद ही उन क्षेत्रों के लिए उनका उपयोग करने से बचता है जहां उनकी localize संपत्ति True सेट है।

EmailInput

class EmailInput [source]
  • input_type : 'email'
  • template_name : 'django/forms/widgets/email.html'
  • रेंडरर्स के रूप में: <input type="email" ...>

URLInput

class URLInput [source]
  • input_type : 'url'
  • template_name : 'django/forms/widgets/url.html'
  • रेंडरर्स के रूप में: <input type="url" ...>

PasswordInput

class PasswordInput [source]
  • input_type : 'password'
  • template_name : 'django/forms/widgets/password.html'
  • रेंडरर्स के रूप में: <input type="password" ...>

एक वैकल्पिक तर्क लेता है:

render_value

यह निर्धारित करता है कि एक सत्यापन त्रुटि के बाद जब फॉर्म को फिर से प्रदर्शित किया जाता है, तो विजेट में एक मूल्य भरा होगा (डिफ़ॉल्ट False )।

HiddenInput

class HiddenInput [source]
  • input_type : 'hidden'
  • template_name : 'django/forms/widgets/hidden.html'
  • रेंडरर्स के रूप में: <input type="hidden" ...>

ध्यान दें कि एक MultipleHiddenInput विजेट भी है जो छिपे हुए इनपुट तत्वों के एक सेट को एन्क्रिप्ट करता है।

DateInput

class DateInput [source]
  • input_type : 'text'
  • template_name : 'django/forms/widgets/date.html'
  • रेंडरर्स के रूप में: <input type="text" ...>

TextInput रूप में एक ही तर्क लेता है, एक और वैकल्पिक तर्क के साथ:

format

वह प्रारूप जिसमें इस फ़ील्ड का प्रारंभिक मूल्य प्रदर्शित किया जाएगा।

यदि कोई format तर्क प्रदान नहीं किया गया है, तो डिफ़ॉल्ट स्वरूप DATE_INPUT_FORMATS में पाया गया पहला प्रारूप है और DATE_INPUT_FORMATS का सम्मान करता है।

DateTimeInput

class DateTimeInput [source]
  • input_type : 'text'
  • template_name : 'django/forms/widgets/datetime.html'
  • रेंडरर्स के रूप में: <input type="text" ...>

TextInput रूप में एक ही तर्क लेता है, एक और वैकल्पिक तर्क के साथ:

format

वह प्रारूप जिसमें इस फ़ील्ड का प्रारंभिक मूल्य प्रदर्शित किया जाएगा।

यदि कोई format तर्क प्रदान नहीं किया गया है, तो डिफ़ॉल्ट प्रारूप DATETIME_INPUT_FORMATS में पाया गया पहला प्रारूप है और प्रारूप स्थानीयकरण का सम्मान करता है।

डिफ़ॉल्ट रूप से, समय मान का माइक्रोसेकंड हिस्सा हमेशा 0 सेट होता है। यदि माइक्रोसेकंड आवश्यक हैं, तो True सेट support_microseconds विशेषता के साथ एक उपवर्ग का उपयोग करें।

TimeInput

class TimeInput [source]
  • input_type : 'text'
  • template_name : 'django/forms/widgets/time.html'
  • रेंडरर्स के रूप में: <input type="text" ...>

TextInput रूप में एक ही तर्क लेता है, एक और वैकल्पिक तर्क के साथ:

format

वह प्रारूप जिसमें इस फ़ील्ड का प्रारंभिक मूल्य प्रदर्शित किया जाएगा।

यदि कोई format तर्क प्रदान नहीं किया गया है, तो डिफ़ॉल्ट प्रारूप TIME_INPUT_FORMATS में पाया गया पहला प्रारूप है और TIME_INPUT_FORMATS का सम्मान करता है।

माइक्रोसेकंड के उपचार के लिए, DateTimeInput देखें।

Textarea

class Textarea [source]
  • template_name : 'django/forms/widgets/textarea.html'
  • रेंडरर्स के रूप में: <textarea>...</textarea>

चयनकर्ता और चेकबॉक्स विजेट

ये विजेट HTML तत्वों <select> , <input type="checkbox"> , और <input type="radio">

कई विकल्प प्रदान करने वाले विजेट में एक option_template_name विशेषता होती है जो प्रत्येक विकल्प को प्रस्तुत करने के लिए उपयोग किए जाने वाले टेम्पलेट को निर्दिष्ट करता है। उदाहरण के लिए, Select विजेट के लिए, select_option.html <select> लिए <select>

CheckboxInput

class CheckboxInput [source]
  • input_type : 'checkbox'
  • template_name : 'django/forms/widgets/checkbox.html'
  • रेंडरर्स के रूप में: <input type="checkbox" ...>

एक वैकल्पिक तर्क लेता है:

check_test

एक कॉल करने योग्य, जो CheckboxInput का मान लेता है और चेकबॉक्स को उस मान के लिए चेक किया जाना चाहिए, तो True

Select

class Select [source]
  • template_name : 'django/forms/widgets/select.html'
  • option_template_name : 'django/forms/widgets/select_option.html'
  • रेंडरर्स के रूप में: <select><option ...>...</select>
choices

यह विशेषता वैकल्पिक होती है जब प्रपत्र फ़ील्ड में choices विशेषता नहीं होती है। यदि ऐसा होता है, तो यह आपके द्वारा यहां सेट की गई किसी भी चीज़ को ओवरराइड करेगा जब फ़ीचर को Field पर अपडेट किया गया हो।

NullBooleanSelect

class NullBooleanSelect [source]
  • template_name : 'django/forms/widgets/select.html'
  • option_template_name : 'django/forms/widgets/select_option.html'

'अज्ञात', 'हां' और 'नहीं' विकल्पों के साथ विजेट चुनें

SelectMultiple

class SelectMultiple [source]
  • template_name : 'django/forms/widgets/select.html'
  • option_template_name : 'django/forms/widgets/select_option.html'

Select समान, लेकिन एकाधिक चयन की अनुमति देता है: <select multiple>...</select> एकाधिक का चयन <select multiple>...</select>

RadioSelect

class RadioSelect [source]
  • template_name : 'django/forms/widgets/radio.html'
  • option_template_name : 'django/forms/widgets/radio_option.html'

Select समान, लेकिन <li> टैग के भीतर रेडियो बटन की सूची के रूप में प्रदान किया गया:

<ul>
  <li><input type="radio" name="..."></li>
  ...
</ul>

उत्पन्न मार्कअप पर अधिक बारीक नियंत्रण के लिए, आप टेम्पलेट में रेडियो बटन पर लूप कर सकते हैं। एक फार्म myform साथ एक फॉर्म myform मानते हुए जो अपने विजेट के रूप में RadioSelect का उपयोग करता है:

{% for radio in myform.beatles %}
<div class="myradio">
    {{ radio }}
</div>
{% endfor %}

यह निम्नलिखित HTML उत्पन्न करेगा:

<div class="myradio">
    <label for="id_beatles_0"><input id="id_beatles_0" name="beatles" type="radio" value="john" required> John</label>
</div>
<div class="myradio">
    <label for="id_beatles_1"><input id="id_beatles_1" name="beatles" type="radio" value="paul" required> Paul</label>
</div>
<div class="myradio">
    <label for="id_beatles_2"><input id="id_beatles_2" name="beatles" type="radio" value="george" required> George</label>
</div>
<div class="myradio">
    <label for="id_beatles_3"><input id="id_beatles_3" name="beatles" type="radio" value="ringo" required> Ringo</label>
</div>

जिसमें <label> टैग शामिल थे। अधिक दानेदार पाने के लिए, आप प्रत्येक रेडियो बटन के tag , choice_label और id_for_label विशेषताओं का उपयोग कर सकते हैं। उदाहरण के लिए, यह टेम्प्लेट ...

{% for radio in myform.beatles %}
    <label for="{{ radio.id_for_label }}">
        {{ radio.choice_label }}
        <span class="radio">{{ radio.tag }}</span>
    </label>
{% endfor %}

… निम्नलिखित HTML में परिणाम देगा:

<label for="id_beatles_0">
    John
    <span class="radio"><input id="id_beatles_0" name="beatles" type="radio" value="john" required></span>
</label>

<label for="id_beatles_1">
    Paul
    <span class="radio"><input id="id_beatles_1" name="beatles" type="radio" value="paul" required></span>
</label>

<label for="id_beatles_2">
    George
    <span class="radio"><input id="id_beatles_2" name="beatles" type="radio" value="george" required></span>
</label>

<label for="id_beatles_3">
    Ringo
    <span class="radio"><input id="id_beatles_3" name="beatles" type="radio" value="ringo" required></span>
</label>

यदि आप रेडियो बटन पर लूप नहीं करने का निर्णय लेते हैं - उदाहरण के लिए, यदि आपके टेम्प्लेट में {{ myform.beatles }} - तो वे <ul> <li> टैग के साथ <li> <ul> <li> टैग में आउटपुट होंगे।

बाहरी <ul> कंटेनर को विजेट की id विशेषता प्राप्त होती है, यदि परिभाषित हो, या BoundField.auto_id अन्यथा।

रेडियो बटन पर लूपिंग करते समय, label और input टैग क्रमशः और id विशेषताओं के for शामिल होते हैं। प्रत्येक रेडियो बटन में तत्व आईडी को आउटपुट करने के लिए एक id_for_label विशेषता होती है।

CheckboxSelectMultiple

class CheckboxSelectMultiple [source]
  • template_name : 'django/forms/widgets/checkbox_select.html'
  • option_template_name : 'django/forms/widgets/checkbox_option.html'

SelectMultiple समान, लेकिन चेकबॉक्स की सूची के रूप में प्रस्तुत किया गया:

<ul>
  <li><input type="checkbox" name="..." ></li>
  ...
</ul>

बाहरी <ul> कंटेनर को विजेट की id विशेषता प्राप्त होती है, यदि परिभाषित हो, या BoundField.auto_id अन्यथा।

RadioSelect तरह, आप विजेट की पसंद के लिए अलग-अलग चेकबॉक्स पर लूप कर सकते हैं। RadioSelect विपरीत, चेकबॉक्स में required HTML विशेषता शामिल नहीं होगी यदि फ़ील्ड आवश्यक है क्योंकि ब्राउज़र सत्यापन के लिए कम से कम एक के बजाय सभी चेकबॉक्स की जांच करनी होगी।

चेकबॉक्स पर लूपिंग करते समय, label और input टैग क्रमशः और id विशेषताओं के for शामिल होते हैं। प्रत्येक चेकबॉक्स में एक id_for_label तत्व की आईडी को आउटपुट करने की विशेषता है।

फ़ाइल अपलोड विजेट

FileInput

class FileInput [source]
  • template_name : 'django/forms/widgets/file.html'
  • रेंडरर्स के रूप में: <input type="file" ...>

ClearableFileInput

class ClearableFileInput [source]
  • template_name : 'django/forms/widgets/clearable_file_input.html'
  • रेंडर्स: <input type="file" ...> फील्ड की वैल्यू क्लियर करने के लिए अतिरिक्त चेकबॉक्स इनपुट के साथ, अगर फील्ड की आवश्यकता नहीं है और शुरुआती डेटा है।

समग्र विगेट्स

MultipleHiddenInput

class MultipleHiddenInput [source]
  • template_name : 'django/forms/widgets/multiple_hidden.html'
  • रेंडरर्स के रूप में: एकाधिक <input type="hidden" ...> टैग

एक विजेट जो मानों की सूची वाले फ़ील्ड के लिए कई छिपे हुए विजेट्स को संभालता है।

choices

यह विशेषता वैकल्पिक होती है जब प्रपत्र फ़ील्ड में choices विशेषता नहीं होती है। यदि ऐसा होता है, तो यह आपके द्वारा यहां सेट की गई किसी भी चीज़ को ओवरराइड करेगा जब फ़ीचर को Field पर अपडेट किया गया हो।

SplitDateTimeWidget

class SplitDateTimeWidget [source]
  • template_name : 'django/forms/widgets/splitdatetime.html'

दो विजेट के आसपास रैपर ( MultiWidget का उपयोग करते MultiWidget ): तारीख के लिए TimeInput और समय के लिए TimeInput DateTimeField बजाय SplitDateTimeField साथ उपयोग किया जाना चाहिए।

SplitDateTimeWidget में कई वैकल्पिक तर्क हैं:

date_format

DateInput.format समान

time_format

TimeInput.format समान

date_attrs
time_attrs
Django 2.0 में नया:

Widget.attrs समान। HTML विशेषताओं वाला एक शब्दकोश क्रमशः TimeInput DateInput और TimeInput विगेट्स पर सेट किया जाना चाहिए। यदि ये विशेषताएँ सेट नहीं हैं, तो इसके बजाय Widget.attrs का उपयोग किया जाता है।

SplitHiddenDateTimeWidget

class SplitHiddenDateTimeWidget [source]
  • template_name : 'django/forms/widgets/splithiddendatetime.html'

SplitDateTimeWidget तरह SplitDateTimeWidget , लेकिन डेट और टाइम दोनों के लिए HiddenInput का HiddenInput करता है।

SelectDateWidget

class SelectDateWidget [source]
  • template_name : 'django/forms/widgets/select_date.html'

तीन चयनकर्ता के चारों ओर आवरण: महीने, दिन और वर्ष के लिए प्रत्येक।

कई वैकल्पिक तर्क देता है:

years

"वर्ष" चयन बॉक्स में उपयोग करने के लिए वर्षों की एक वैकल्पिक सूची / टपल। डिफ़ॉल्ट एक सूची है जिसमें वर्तमान वर्ष और अगले 9 वर्ष शामिल हैं।

months

"महीनों" के चयन बॉक्स में उपयोग करने के लिए महीनों का एक वैकल्पिक तानाशाही।

माह संख्या (1-अनुक्रमित) के लिए तानाशाहों की कुंजियां और मूल्य प्रदर्शित महीने हैं:

MONTHS = {
    1:_('jan'), 2:_('feb'), 3:_('mar'), 4:_('apr'),
    5:_('may'), 6:_('jun'), 7:_('jul'), 8:_('aug'),
    9:_('sep'), 10:_('oct'), 11:_('nov'), 12:_('dec')
}
empty_label

यदि DateField की आवश्यकता नहीं है, तो SelectDateWidget में सूची के शीर्ष पर एक खाली विकल्प होगा (जो कि डिफ़ॉल्ट रूप से --- है)। आप इस लेबल के पाठ को empty_label विशेषता के साथ बदल सकते हैं। empty_label एक string , list या tuple । जब एक स्ट्रिंग का उपयोग किया जाता है, तो सभी चयनित बक्से में प्रत्येक इस लेबल के साथ एक खाली विकल्प होगा। यदि empty_label 3 स्ट्रिंग तत्वों की एक list या tuple है, तो चयनित बक्सों का अपना कस्टम लेबल होगा। लेबल इस क्रम में होना चाहिए ('year_label', 'month_label', 'day_label')

# A custom empty label with string
field1 = forms.DateField(widget=SelectDateWidget(empty_label="Nothing"))

# A custom empty label with tuple
field1 = forms.DateField(
    widget=SelectDateWidget(
        empty_label=("Choose Year", "Choose Month", "Choose Day"),
    ),
)