# Django 6.0.7 documentation

# Widgets

En widget är Djangos representation av ett HTML-inmatningselement. Widgeten hanterar rendering av HTML och extrahering av data från en GET/POST-ordbok som motsvarar widgeten.

Den HTML som genereras av de inbyggda widgetarna använder HTML5-syntax och riktar sig till `<!DOCTYPE html>`. Exempelvis används booleska attribut som `checked` i stället för XHTML-stilen `checked='checked'`.

Tips

Widgets ska inte förväxlas med formulärsfält. Formulärfält hanterar logiken för validering av indata och används direkt i mallar. Widgets hanterar rendering av HTML-formulärets inmatningselement på webbsidan och extrahering av inskickade rådata. Widgets behöver dock assigned till formulärfält.

## Ange widgetar

När du anger ett fält i ett formulär kommer Django att använda en standardwidget som är lämplig för den typ av data som ska visas. För att ta reda på vilken widget som används för vilket fält, se dokumentationen om Inbyggda Field-klasser.

Men om du vill använda en annan widget för ett fält kan du använda argumentet `widget` i fältdefinitionen. Till exempel:

    from django import forms

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

Detta skulle ange ett formulär med en kommentar som använder en större `Textarea`-widget i stället för standardwidgeten `TextInput`.

## Ställa in argument för widgets

Många widgetar har valfria extra argument; de kan anges när widgeten definieras på fältet. I följande exempel anges attributet `years` för en `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,
        )

Se inbyggda widgetar för mer information om vilka widgetar som finns tillgängliga och vilka argument de accepterar.

## Anpassa widgetinstanser

När Django renderar en widget som HTML, renderar den bara mycket minimal markup - Django lägger inte till klassnamn eller andra widgetspecifika attribut. Detta innebär till exempel att alla `TextInput`-widgets kommer att se likadana ut på dina webbsidor.

Det finns två sätt att anpassa widgetar: per widget instance och per widget class.

### Styling av widgetinstanser

Om du vill att en widgetinstans ska se annorlunda ut än en annan måste du ange ytterligare attribut när widgetobjektet instansieras och tilldelas ett formulärfält (och kanske lägga till några regler i dina CSS-filer).

Ta till exempel följande formulär:

    from django import forms

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

Detta formulär kommer att innehålla `TextInput`-widgetar för namn- och kommentarsfälten, och en `URLInput`-widget för url-fältet. Varje widget har standardrendering - ingen CSS-klass, inga extra attribut:

    >>> f = CommentForm(auto_id=False)
    >>> print(f)
    <div>Name:<input type="text" name="name" required></div>
    <div>Url:<input type="url" name="url" required></div>
    <div>Comment:<input type="text" name="comment" required></div>

På en riktig webbsida vill du förmodligen anpassa detta. Du kanske vill ha ett större inmatningselement för kommentaren, och du kanske vill att widgeten ”name” ska ha någon speciell CSS-klass. Det är också möjligt att ange attributet ’type’ för att använda en annan HTML5-ingångstyp. För att göra detta använder du argumentet `Widget.attrs` när du skapar widgeten:

    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"}))

Du kan också ändra en widget i formulärdefinitionen:

    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")

Om fältet inte deklareras direkt i formuläret (t.ex. fält i modellformulär) kan du använda attributet `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 kommer då att inkludera de extra attributen i den återgivna utdata:

    >>> f = CommentForm(auto_id=False)
    >>> print(f)
    <div>Name:<input type="text" name="name" class="special" required></div>
    <div>Url:<input type="url" name="url" required></div>
    <div>Comment:<input type="text" name="comment" size="40" required></div>

Du kan också ställa in HTML `id` med hjälp av `attrs`. Se `BoundField.id_for_label` för ett exempel.

### Styling av widgetklasser

Med widgets är det möjligt att lägga till tillgångar (`css` och `javascript`) och mer djupgående anpassa deras utseende och beteende.

I ett nötskal måste du underklassa widgeten och antingen definiera en ”Media” inre klass eller skapa en ”media” egenskap.

Dessa metoder kräver lite avancerad Python-programmering och beskrivs i detalj i ämnesguiden Form Assets.

## Klasser för baswidgetar

Baswidgetklasserna `Widget` och `MultiWidget` är underklasser till alla inbyggda widgetar och kan fungera som en grund för anpassade widgetar.

### `Widget`

class Widget(attrs=None)

  This abstract class cannot be rendered, but provides the basic attribute `attrs`. You may also implement or override the `render()` method on custom widgets.

  attrs

    En ordlista som innehåller HTML-attribut som ska ställas in på den renderade widgeten.

        >>> 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">'

    Om du tilldelar ett värde av `True` eller `False` till ett attribut, kommer det att återges som ett HTML5 booleskt attribut:

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

    Ett attribut som har standardvärdet `True`. Om det sätts till `False` kommer mikrosekunderna i värdena `datetime` och `time` att sättas till `0`.

  format_value(value)

    Rensar och returnerar ett värde för användning i widgetmallen. `värde` garanteras inte vara giltig indata, därför bör implementeringar av underklasser programmeras defensivt.

  get_context(name, value, attrs)

    Returnerar en ordbok med värden som ska användas vid rendering av widgetmallen. Som standard innehåller ordboken en enda nyckel, `'widget'`, som är en ordboksrepresentation av widgeten som innehåller följande nycklar:

    - `'namn'`: Namnet på fältet från argumentet `name`.

    - `'is_hidden'`: En boolean som anger om denna widget är dold eller inte.

    - `'required'`: En boolean som anger om fältet för den här widgeten är obligatoriskt eller inte.

    - `'värde'`: Det värde som returneras av `format_value()`.

    - `'attrs'`: HTML-attribut som ska ställas in på den renderade widgeten. Kombinationen av attributet `attrs` och argumentet `attrs`.

    - `'template_name'`: Värdet av `self.template_name`.

    underklasser till `Widget` kan tillhandahålla anpassade kontextvärden genom att åsidosätta denna metod.

  id_for_label(id_)

    Returnerar HTML ID-attributet för denna widget för användning av en `<label>`, givet fältets ID. Returnerar en tom sträng om ett ID inte är tillgängligt.

    Denna hook är nödvändig eftersom vissa widgetar har flera HTML-element och därmed flera ID:n. I så fall bör den här metoden returnera ett ID-värde som motsvarar det första ID:t i widgetens taggar.

  render(name, value, attrs=None, renderer=None)

    Renderar en widget till HTML med hjälp av den angivna renderaren. Om `renderer` är `None` används renderaren från inställningen `FORM_RENDERER`.

  value_from_datadict(data, files, name)

    Givet en ordbok med data och denna widgets namn, returnerar värdet av denna widget. `files` kan innehålla data som kommer från `request.FILES`. Returnerar `None` om inget värde har angetts. Observera också att `value_from_datadict` kan anropas mer än en gång under hanteringen av formulärdata, så om du anpassar det och lägger till dyr bearbetning bör du implementera någon cachemekanism själv.

  value_omitted_from_data(data, files, name)

    Med hjälp av ordböckerna `data` och `files` och widgetens namn returneras om det finns data eller filer för widgeten eller inte.

    Metodens resultat påverkar om ett fält i ett modellformulär faller tillbaka till sin standard eller inte.

    Specialfall är `CheckboxInput`, `CheckboxSelectMultiple` och `SelectMultiple`, som alltid returnerar `False` eftersom en avmarkerad kryssruta och omarkerad `<select multiple>` inte visas i data från en HTML-formulärinlämning, så det är okänt om användaren skickade in ett värde eller inte.

  use_fieldset

    Ett attribut för att identifiera om widgeten ska grupperas i en `<fieldset>` med en `<legend>` när den renderas. Standardvärdet är `False` men är `True` när widgeten innehåller flera `<input>` taggar som `CheckboxSelectMultiple`, `RadioSelect`, `MultiWidget`, `SplitDateTimeWidget`, och `SelectDateWidget`.

  use_required_attribute(initial)

    Med tanke på ett formulärfälts `initial`-värde returneras huruvida widgeten kan återges med HTML-attributet `required` eller inte. Formulär använder den här metoden tillsammans med `Field.required` och `Form.use_required_attribute` för att avgöra om attributet `required` ska visas eller inte för varje fält.

    Som standard returneras `False` för dolda widgetar och `True` annars. Specialfall är `FileInput` och `ClearableFileInput`, som returnerar `False` när `initial` är inställt, och `CheckboxSelectMultiple`, som alltid returnerar `False` eftersom webbläsarvalidering skulle kräva att alla kryssrutor är markerade istället för minst en.

    Override this method in custom widgets that aren’t compatible with browser validation. For example, a WYSIWYG text editor widget backed by a hidden `textarea` element may want to always return `False` to avoid browser validation on the hidden field.

### `MultiWidget`

class MultiWidget(widgets, attrs=None)

  En widget som består av flera widgetar. `MultiWidget` arbetar hand i hand med `MultiValueField`.

  `MultiWidget` har ett obligatoriskt argument:

  widgets

    En iterabel som innehåller de widgetar som behövs. Till exempel:

        >>> from django.forms import MultiWidget, TextInput
        >>> widget = MultiWidget(widgets=[TextInput, TextInput])
        >>> widget.render("name", ["john", "paul"])
        '<input type="text" name="name_0" value="john"><input type="text" name="name_1" value="paul">'

    Du kan tillhandahålla en ordbok för att ange anpassade suffix för attributet `name` på varje subwidget. I det här fallet kommer nyckeln för varje par `(nyckel, widget)` att läggas till widgetens `namn` för att generera attributvärdet. Du kan ange den tomma strängen (`''`) för en enda nyckel, för att undertrycka suffixet för en widget. Till exempel:

        >>> widget = MultiWidget(widgets={"": TextInput, "last": TextInput})
        >>> widget.render("name", ["john", "paul"])
        '<input type="text" name="name" value="john"><input type="text" name="name_last" value="paul">'

  Och en nödvändig metod:

  decompress(value)

    Denna metod tar ett enda ”komprimerat” värde från fältet och returnerar en lista med ”dekomprimerade” värden. Inmatningsvärdet kan antas vara giltigt, men inte nödvändigtvis icke-tomt.

    Denna metod måste implementeras av underklassen, och eftersom värdet kan vara tomt måste implementeringen vara defensiv.

    Tanken bakom ”dekomprimering” är att det är nödvändigt att ”dela upp” det kombinerade värdet för formulärfältet i värden för varje widget.

    Ett exempel på detta är hur `SplitDateTimeWidget` förvandlar ett `datetime`-värde till en lista med datum och tid uppdelade i två separata värden:

        from django.forms import MultiWidget

        class SplitDateTimeWidget(MultiWidget):
            # ...

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

    Tips

    Observera att `MultiValueField` har en kompletterande metod `compress()` med motsatt ansvar - att kombinera rensade värden för alla medlemsfält till ett.

  Det ger ett anpassat sammanhang:

  get_context(name, value, attrs)

    Förutom nyckeln `'widget'` som beskrivs i `Widget.get_context()`, lägger `MultiWidget` till en nyckel `widget['subwidgets']`.

    Dessa kan loopas över i widgetmallen:

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

  Här är ett exempel på en widget som underklassar `MultiWidget` för att visa ett datum med dag, månad och år i olika valboxar. Denna widget är avsedd att användas med en `DateField` snarare än en `MultiValueField`, därför har vi implementerat `value_from_datadict()`:

      from datetime import date
      from django import forms

      class DateSelectorWidget(forms.MultiWidget):
          def __init__(self, attrs=None):
              days = {day: day for day in range(1, 32)}
              months = {month: month for month in range(1, 13)}
              years = {year: year for year in [2018, 2019, 2020]}
              widgets = [
                  forms.Select(attrs=attrs, choices=days),
                  forms.Select(attrs=attrs, choices=months),
                  forms.Select(attrs=attrs, choices=years),
              ]
              super().__init__(widgets, attrs)

          def decompress(self, value):
              if isinstance(value, date):
                  return [value.day, value.month, value.year]
              elif isinstance(value, str):
                  year, month, day = value.split("-")
                  return [day, month, year]
              return [None, None, None]

          def value_from_datadict(self, data, files, name):
              day, month, year = super().value_from_datadict(data, files, name)
              # DateField expects a single string that it can parse into a date.
              return "{}-{}-{}".format(year, month, day)

  Konstruktören skapar flera `Select` widgetar i en lista. Metoden `super()` använder denna lista för att konfigurera widgeten.

  Den nödvändiga metoden `decompress()` delar upp ett `datetime.date`-värde i värdena för dag, månad och år som motsvarar varje widget. Om ett ogiltigt datum valdes, till exempel den icke-existerande 30 februari, skickar `DateField` den här metoden en sträng istället, så det måste analyseras. Den sista `return` hanterar när `value` är `None`, vilket innebär att vi inte har några standardvärden för våra underwidgets.

  Standardimplementeringen av `value_from_datadict()` returnerar en lista med värden som motsvarar varje `Widget`. Detta är lämpligt när man använder en `MultiWidget` med en `MultiValueField`. Men eftersom vi vill använda denna widget med en `DateField`, som tar ett enda värde, har vi åsidosatt denna metod. Implementationen här kombinerar data från underwidgetarna till en sträng i det format som `DateField` förväntar sig.

## Inbyggda widgetar

Django tillhandahåller en representation av alla grundläggande HTML-widgets, plus några vanligt förekommande grupper av widgets i modulen `django.forms.widgets`, inklusive inmatning av text, olika kryssrutor och väljare, uppladdning av filer och hantering av flervärdesinmatning.

### Widgets som hanterar inmatning av text

Dessa widgets använder HTML-elementen `input` och `textarea`.

#### `TextInput`

class TextInput

  - inmatningstyp: ”text

  - `template_name`: `'django/forms/widgets/text.html'`

  - Renderas som: `<input type="text" ...>`

#### `NummerInmatning`

class NumberInput

  - inmatningstyp: ”tal

  - `template_name`: `'django/forms/widgets/number.html'`

  - Renderas som: `<input type="number" ...>`

  Tänk på att inte alla webbläsare stöder inmatning av lokaliserade siffror i inmatningstyperna `number`. Django själv undviker att använda dem för fält som har sin `localize` egenskap inställd på `True`.

#### `EmailInput`

class EmailInput

  - `input_type`: `'email'`

  - `template_name`: `'django/forms/widgets/email.html'`

  - Renderas som: `<input type="email" ...>`

#### `URLInput`

class URLInput

  - inmatningstyp: ”url

  - `template_name`: `'django/forms/widgets/url.html'`

  - Renderas som: `<input type="url" ...>`

#### `FärgInmatning`

class ColorInput

  - inmatningstyp: ”färg

  - `template_name`:`'django/forms/widgets/color.html'`

  - Renderas som: `<input type="color" ...>`

#### `SökningInput`

class SearchInput

  - `input_type`: `'search'`

  - `template_name`: `'django/forms/widgets/search.html'`

  - Renderas som: `<input type="search" ...>`

#### `TelInput`

class TelInput

  - inmatningstyp: ”tel

  - `template_name`: `'django/forms/widgets/tel.html'`

  - Renderas som: `<input type="tel" ...>`

  Webbläsare utför ingen validering på klientsidan som standard eftersom telefonnummerformat varierar så mycket runt om i världen. Du kan lägga till några genom att ställa in `pattern`, `minlength` eller `maxlength` i argumentet `Widget.attrs`.

  Dessutom kan du lägga till validering på serversidan till ditt formulärfält med en validerare som `RegexValidator` eller via tredjepartspaket, t.ex. django-phonenumber-field.

#### `LösenordInmatning`

class PasswordInput

  - inmatningstyp: ”Lösenord

  - `template_name`: `'django/forms/widgets/password.html'`

  - Renderas som: `<input type="password" ...>`

  Tar emot ett valfritt argument:

  render_value

    Bestämmer om widgeten ska ha ett värde ifyllt när formuläret visas igen efter ett valideringsfel (standard är `False`).

#### `HiddenInput`

class HiddenInput

  - inmatningstyp: ”dold

  - `template_name`: `'django/forms/widgets/hidden.html'`

  - Renderas som: `<input type="hidden" ...>`

  Observera att det också finns en widget av typen `MultipleHiddenInput` som innehåller en uppsättning dolda inmatningselement.

#### `DatumInmatning`

class DateInput

  - inmatningstyp: ”text

  - `template_name`: `'django/forms/widgets/date.html'`

  - Renderas som: `<input type="text" ...>`

  Tar samma argument som `TextInput`, med ytterligare ett valfritt argument:

  format

    Det format som fältets initiala värde ska visas i.

  Om inget `format`-argument anges är standardformatet det första formatet som hittas i `DATE_INPUT_FORMATS` och respekterar Lokalisering av format. formaten `%U`, `%W` och `%j` stöds inte av den här widgeten.

  Using the HTML5 ”date” input type

  If you are targeting browsers that support the HTML5 ”date” input type, you can override the `input_type` attribute to enable the browser’s native date picker:

      class MyDateInput(forms.DateInput):
          input_type = "date"
          format = "%Y-%m-%d"

  Alternatively:

      DateInput(attrs={"type": "date"}, format="%Y-%m-%d")

  HTML5 date inputs expect values in the ISO format `YYYY-MM-DD`. If a different format is provided, the field may appear empty even when a value exists. Setting the `format` attribute controls how Django provides the value, but the browser controls how it is displayed. Hence, the `format` attribute and the `DATE_INPUT_FORMATS` setting will have no effect on the displayed value.

#### `DateTimeInput`

class DateTimeInput

  - inmatningstyp: ”text

  - `template_name`: `'django/forms/widgets/datetime.html'`

  - Renderas som: `<input type="text" ...>`

  Tar samma argument som `TextInput`, med ytterligare ett valfritt argument:

  format

    Det format som fältets initiala värde ska visas i.

  Om inget `format`-argument anges är standardformatet det första formatet som hittas i `DATETIME_INPUT_FORMATS` och respekterar Lokalisering av format. formaten `%U`, `%W` och `%j` stöds inte av den här widgeten.

  Som standard är mikrosekunderdelen av tidsvärdet alltid satt till `0`. Om mikrosekunder krävs, använd en subklass med attributet `supports_microseconds` satt till `True`.

#### `TimeInput`

class TimeInput

  - inmatningstyp: ”text

  - `template_name`: `'django/forms/widgets/time.html'`

  - Renderas som: `<input type="text" ...>`

  Tar samma argument som `TextInput`, med ytterligare ett valfritt argument:

  format

    Det format som fältets initiala värde ska visas i.

  Om inget `format`-argument anges är standardformatet det första formatet som hittas i `TIME_INPUT_FORMATS` och respekterar Lokalisering av format.

  För behandling av mikrosekunder, se `DateTimeInput`.

#### `Textarea`

class Textarea

  - `template_name`: `'django/forms/widgets/textarea.html'`

  - Återges som: `.<textarea>.</textarea>.`

### Väljare och kryssrutor

Dessa widgets använder HTML-elementen `<select>`, `<input type="checkbox">` och `<input type="radio">`.

Widgetar som återger flera val har ett attribut `option_template_name` som anger den mall som används för att återge varje val. Till exempel:, för widgeten `Select`, `select_option.html` renderar `<option>` för en `<select>`.

#### `CheckboxInput`

class CheckboxInput

  - inmatningstyp: ”Checkbox

  - `template_name`: `'django/forms/widgets/checkbox.html'`

  - Renderas som: `<input type="checkbox" ...>`

  Tar emot ett valfritt argument:

  check_test

    En anropsbar funktion som tar värdet i `CheckboxInput` och returnerar `True` om kryssrutan ska markeras för det värdet.

#### `Välj`

class Select

  - `template_name`: `'django/forms/widgets/select.html'`

  - `option_template_name`: `'django/forms/widgets/select_option.html'`

  - Renderas som: ``<select><option …>…``</select>

  choices

    Detta attribut är valfritt om formulärfältet inte har något `choices`-attribut. Om det gör det kommer det att åsidosätta allt du anger här när attributet uppdateras på `Field`.

#### `NullBooleanSelect`

class NullBooleanSelect

  - `template_name`: `'django/forms/widgets/select.html'`

  - `option_template_name`: `'django/forms/widgets/select_option.html'`

  Välj widget med alternativen ”Okänd”, ”Ja” och ”Nej

#### `VäljMultipel`

class SelectMultiple

  - `template_name`: `'django/forms/widgets/select.html'`

  - `option_template_name`: `'django/forms/widgets/select_option.html'`

  Liknar `Select`, men tillåter flera val: `.<select multiple>.</select>.`

#### `RadioSelect`

class RadioSelect

  - `template_name`: `'django/forms/widgets/radio.html'`

  - `option_template_name`: `'django/forms/widgets/radio_option.html'`

  Liknar `Select`, men återges som en lista med alternativknappar inom `<div>` taggar:

      <div>
        <div><input type="radio" name="..."></div>
        ...
      </div>

  Om du vill ha mer detaljerad kontroll över den genererade markeringen kan du loopa över radioknapparna i mallen. Anta ett formulär `myform` med ett fält `beatles` som använder en `RadioSelect` som sin widget:

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

  Detta skulle generera följande HTML:

      <fieldset>
          <legend>Radio buttons</legend>
          <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>
      </fieldset>

  Det inkluderade taggarna `<label>`. För att bli mer detaljerad kan du använda varje radioknapps attribut `tag`, `choice_label` och `id_for_label`. Till exempel:, den här mallen…

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

  …kommer att resultera i följande HTML:

      <fieldset>
          <legend>Radio buttons</legend>
          <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>
      </fieldset>

  Om du bestämmer dig för att inte loopa över alternativknapparna - t.ex. om din mall innehåller `{{ myform.beatles }}` - kommer de att matas ut i en `<div>` med `<div>`-taggar, enligt ovan.

  Den yttre behållaren `<div>` får widgetens `id`-attribut, om det är definierat, eller `BoundField.auto_id` annars.

  När du loopar över radioknapparna innehåller taggarna `label` och `input` attributen `for` respektive `id`. Varje radioknapp har ett `id_for_label`-attribut för att mata ut elementets ID.

#### `CheckboxSelectMultiple`

class CheckboxSelectMultiple

  - `template_name`: `'django/forms/widgets/checkbox_select.html'`

  - `option_template_name`: `'django/forms/widgets/checkbox_option.html'`

  Liknar `SelectMultiple`, men återges som en lista med kryssrutor:

      <div>
        <div><input type="checkbox" name="..." ></div>
        ...
      </div>

  Den yttre behållaren `<div>` får widgetens `id`-attribut, om det är definierat, eller `BoundField.auto_id` annars.

Precis som i `RadioSelect` kan du loopa över de enskilda kryssrutorna för widgetens val. Till skillnad från `RadioSelect` kommer kryssrutorna inte att innehålla HTML-attributet `required` om fältet är obligatoriskt eftersom webbläsarvalidering skulle kräva att alla kryssrutor är markerade istället för minst en.

När man loopar över kryssrutorna innehåller taggarna `label` och `input` attributen `for` respektive `id`. Varje kryssruta har ett `id_for_label`-attribut för att mata ut elementets ID.

### Widgets för filuppladdning

#### `FileInput`

class FileInput

  - `template_name`: `'django/forms/widgets/file.html'`

  - Renderas som: `<input type="file" ...>`

#### `Rensa filinmatning`

class ClearableFileInput

  - `template_name`: `'django/forms/widgets/clearable_file_input.html'`

  - Renderas som: `<input type="file" ...>` med en extra kryssruta för att rensa fältets värde, om fältet inte är obligatoriskt och har initiala data.

### Sammansatta widgetar

#### `MultipleHiddenInput`

class MultipleHiddenInput

  - `template_name`: `'django/forms/widgets/multiple_hidden.html'`

  - Renderas som: flera `<input type="hidden" ...>` taggar

  En widget som hanterar flera dolda widgetar för fält som har en lista med värden.

#### `SplitDateTimeWidget`

class SplitDateTimeWidget

  - `template_name`: `'django/forms/widgets/splitdatetime.html'`

  Omslag (med hjälp av `MultiWidget`) runt två widgets: `DateInput` för datum och `TimeInput` för tid. Måste användas med `SplitDateTimeField` snarare än `DateTimeField`.

  `SplitDateTimeWidget` har flera valfria argument:

  date_format

    Liknande `DateInput.format`

  time_format

    Liknande `TimeInput.format`

  date_attrs
  time_attrs

    Liknar `Widget.attrs`. En dictionary som innehåller HTML-attribut som ska ställas in på de renderade widgetarna `DateInput` respektive `TimeInput`. Om dessa attribut inte är inställda används istället `Widget.attrs`.

#### `SplitHiddenDateTimeWidget`

class SplitHiddenDateTimeWidget

  - `template_name`: `'django/forms/widgets/splithiddendatetime.html'`

  Liknar `SplitDateTimeWidget`, men använder `HiddenInput` för både datum och tid.

#### `SelectDateWidget`

class SelectDateWidget

  - `template_name`: `'django/forms/widgets/select_date.html'`

  Omslag runt tre `Select` widgets: en vardera för månad, dag och år.

  Tar emot flera valfria argument:

  years

    En valfri lista/tupel av år som ska användas i valboxen ”year”. Standard är en lista som innehåller det aktuella året och de kommande 9 åren.

  months

    Ett valfritt antal månader som ska användas i valboxen ”månader”.

    Diktens nycklar motsvarar månadsnumret (1-indexerat) och värdena är de visade månaderna:

        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

    Om `DateField` inte krävs kommer `SelectDateWidget` att ha ett tomt val längst upp i listan (som är `---` som standard). Du kan ändra texten på denna etikett med attributet `empty_label`. `empty_label` kan vara en `sträng`, `lista` eller `tupel`. När en sträng används kommer alla valboxar att ha ett tomt val med denna etikett. Om `empty_label` är en `list` eller `tuple` med 3 strängelement, kommer valboxarna att ha sin egen anpassade etikett. Etiketterna bör vara i denna ordning `('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"),
            ),
        )