Использование форм

Об этом документе

Этот документ представляет собой введение в основы веб-форм и то, как они обрабатываются Django. Для получения дополнительной информации по конкретным аспектам Forms API, см Формы API , формы полей и Неактивированные форм и полей .

Если вы не собираетесь создавать веб-сайты и приложения, которые ничего не делают, кроме публикации контента, и не принимают никаких данных от посетителей, вам нужно понимать и используйте формы.

Django предоставляет ряд инструментов и библиотек, которые помогут вам создавать формы ввода для посетителей сайта, а затем помочь обработать эти данные и ответить на них.

HTML-формы

В HTML форма - это набор элементов внутри тегов, <form>...</form> которые позволяют посетителю выполнять такие действия, как ввод текста, выбор параметров, манипулирование объектами или элементами управления и т. Д., А затем d 'отправить эту информацию на сервер.

Некоторые из этих элементов интерфейса формы - поля ввода текста или флажки - встроены в HTML. Другие элементы намного сложнее; интерфейс, который отображает средство выбора даты или позволяет перемещать курсор или управлять другим графическим элементом, обычно использует код JavaScript и CSS, а также элементы <input> формы HTML для создания таких эффектов.

В дополнение к своим элементам <input> форма должна определять две вещи:

  • где  : URL-адрес, по которому должны быть возвращены данные, соответствующие вводу пользователя
  • комментарий  : метод HTTP, используемый для возврата данных

Например, форма входа для администрирования Django содержит несколько элементов <input> : один из type="text" для имени пользователя, один из type="password" для пароля и один из type="submit" для кнопки «Войти». Он также содержит скрытые текстовые поля, которые пользователь не видит, но которые Django использует для определения того, что делать после входа в систему.

Он также сообщает браузеру, что данные формы должны быть отправлены на URL-адрес, указанный в атрибуте action тега <form> ( /admin/ ), и что они должны быть отправлены с использованием механизма HTTP, указанного в атрибуте method ( post ).

При нажатии кнопки данные возвращаются в .<input type="submit" value="Connexion"> /admin/

GET и POST

GET и POST являются единственными методами HTTP, которые можно использовать в формах.

Форма входа в систему Django возвращается с использованием метода POST , посредством которого браузер объединяет данные формы, кодирует их для передачи, отправляет на сервер, а затем получает ответ.

GET , с другой стороны, объединяет предоставленные данные в строку и использует ее для создания URL. URL-адрес содержит адрес, на который должны быть отправлены данные, а также предоставленные ключи и значения. Вы можете увидеть пример этого, если выполните поиск в документации Django, так как это даст URL-адрес формы https://docs.djangoproject.com/search/?q=forms&release=1 .

GET и POST обычно используются для разных целей.

Любой запрос, который может использоваться для изменения состояния системы, например запрос, который применяет изменения к базе данных, должен использовать POST . GET следует использовать только для запросов, которые не влияют на состояние системы.

GET Также не подходит для формы изменения пароля, так как пароль будет отображаться в открытом виде в URL-адресе, а также в истории браузера и журналах сервера. Он также не подходит для больших данных или для двоичных данных, таких как изображение. Веб-приложение, использующее запросы GET административных форм, не будет безопасным: злоумышленник может легко смоделировать запрос формы, чтобы получить доступ к конфиденциальным частям системы. Запросы, POST сопровождаемые другими средствами защиты, такими как защита CSRF от Django, обеспечивают гораздо лучший контроль доступа.

С другой стороны, GET подходит для таких интерфейсов, как форма веб-поиска, поскольку URL-адреса, представляющие запрос, GET можно легко добавить в закладки, поделиться или повторно отправить.

Роль Django в формах

Управление формами - сложный бизнес. Рассмотрим приложение администратора Django, в котором необходимо подготовить множество данных разных типов для отображения в форме, созданной в HTML, отредактировать с помощью удобного интерфейса, отправить обратно на сервер, проверить и очистить и в конечном итоге сохранить или передать. для дальнейшей обработки.

Функциональность форм Django может упростить и автоматизировать большую часть этой работы, а также сделать это более безопасно, чем большинство программистов, написав свой собственный код.

Django обрабатывает три отдельные части работы, связанной с формой:

  • подготовка и реструктуризация данных для презентации
  • создание HTML-форм для данных
  • получение и обработка форм и данных, отправленных клиентом

Вы можете написать код, который делает все это вручную, но Django может сделать это за вас.

Формы в Django

Мы кратко описали HTML-формы, но HTML-объект <form> - это лишь часть необходимого механизма.

В контексте веб-приложения «форма» может относиться к этому тегу HTML <form> , к классу Form Django, который его создает, к структурированным данным, возвращаемым при отправке формы, или к сквозной операции этих различных частей.

Класс Form Django

В Form основе этой компонентной системы лежит класс Django. Так же, как модель Django описывает логическую структуру объекта, его поведение и то, как его части представляются нам, класс Form описывает форму и определяет, как она работает и выглядит.

Так же, как поля класса шаблона соответствуют полям базы данных, поля класса формы соответствуют элементам <input> HTML-формы (один ModelForm соответствует полям класса шаблона к элементам <input> HTML-формы через форму Form ; это составляет основу интерфейса администратора Django).

Поля формы сами по себе являются классами; они управляют данными формы и заботятся о проверке при получении данных формы. Поле DateField и поле FileField обрабатывают очень разные типы данных и должны выполнять разные действия.

Поле формы представлено в интерфейсе браузера как «компонент» HTML, элемент пользовательского интерфейса. Каждый тип поля по умолчанию содержит соответствующий класс виджетов , но при необходимости их можно переопределить.

Создание, обработка и рендеринг форм

При рендеринге объекта Django для отображения обычно это:

  1. получить элемент в поле зрения (например, получить его из базы данных)
  2. передать его в контекст шаблона
  3. преобразовать его в разметку HTML с помощью переменных шаблона

Отображение формы в шаблоне происходит во многом так же, как и для любого другого типа объекта, но есть некоторые заметные различия.

В случае экземпляра шаблона без данных в нем нет особого смысла делать что-либо с ним в шаблоне. С другой стороны, вполне разумно отображать пустую форму, что и нужно делать, когда кто-то хочет ее заполнить.

Поэтому, когда мы манипулируем экземпляром модели в представлении, мы обычно получаем его из базы данных. Когда мы манипулируем формой, мы обычно создаем ее экземпляр в представлении.

При создании экземпляра формы вы можете оставить его пустым или предварительно заполнить его, например:

  • данные из зарегистрированного экземпляра модели (как и в случае административных форм для редактирования)
  • данные, которые мы получили из других источников
  • данные, полученные при отправке HTML-формы

Последний из этих случаев является наиболее интересным, потому что он позволяет пользователям не только читать веб-сайт, но и возвращать информацию на веб-сайты.

Создание формы

Работа, которую нужно сделать

Предположим, вы хотите создать на своем сайте простую форму с целью получения имени пользователя. Вот что у вас должно получиться в браузере:

<form action="/your-name/" method="post">
    <label for="your_name">Your name: </label>
    <input id="your_name" type="text" name="your_name" value="{{ current_name }}">
    <input type="submit" value="OK">
</form>

Затем браузер будет знать, что он должен вернуть данные из формы в URL-адрес /your-name/ , используя метод POST . Он отобразит текстовое поле с надписью «Ваше имя:» и кнопку с надписью «ОК». Если контекст шаблона содержит переменную current_name , она будет использоваться для предварительного заполнения поля your_name .

Вам понадобится представление, которое создает шаблон, содержащий HTML-форму, и которое может предоставить поле current_name при необходимости.

После отправки формы запрос, POST отправленный на сервер, будет содержать данные формы.

Но также необходимо иметь представление, отвечающее на URL-адрес, /your-name/ которое позаботится о поиске пар ключ-значение в запросе, а затем их обработке.

Это очень простая форма. На практике форма может содержать десятки или сотни полей, многие из которых могут быть предварительно заполнены, и пользователю может потребоваться пройти несколько циклов отправки / редактирования, прежде чем вся операция будет завершена.

Вы можете ожидать, что браузер выполнит часть проверки даже до отправки формы. Возможно, некоторые поля будут намного сложнее, например, для выбора дат в календаре.

Учитывая все это, будет намного выгоднее, если Django выполнит большую часть работы сам.

Создание формы в Django

Класс Form

Мы уже знаем, как должна выглядеть наша HTML-форма. Наша отправная точка в Django следующая:

forms.py
from django import forms

class NameForm(forms.Form):
    your_name = forms.CharField(label='Your name', max_length=100)

Это определяет класс Form с одним полем ( your_name ). Мы присвоили этому полю дружественный ярлык; это будет отображаться в теге <label> во время отображения (хотя в этом случае отображаемое содержимое label фактически такое же, как то, что было бы сгенерировано автоматически, если бы мы ничего не сделали).

Максимальная длина поля определяется как max_length . Это делает две вещи: тег HTML <input> получает атрибут maxlength="100" (поэтому сам браузер предотвращает ввод большего количества символов), а позже, когда Django получает данные формы обратно, он проверяет эти данные. уважайте эту длину.

У экземпляра Form есть метод, is_valid() который выполняет процедуры проверки для всех его полей. Когда вызывается метод и все поля содержат действительные данные, это:

  • возвращается True ;
  • вставляет данные формы в атрибут cleaned_data .

Полная форма при первом отображении выглядит так:

<label for="your_name">Your name: </label>
<input id="your_name" type="text" name="your_name" maxlength="100" required>

Обратите внимание, что он не включает теги <form> или кнопку отправки . Эти элементы должны быть добавлены тем, кто пишет шаблон.

Вид

Данные формы, возвращаемые на сайт Django, обрабатываются представлением, обычно тем же, которое использовалось для создания формы. Это позволяет повторно использовать часть той же логики.

Чтобы обработать форму, нам нужно создать ее экземпляр в представлении по URL-адресу, где он должен появиться:

views.py
from django.http import HttpResponseRedirect
from django.shortcuts import render

from .forms import NameForm

def get_name(request):
    # if this is a POST request we need to process the form data
    if request.method == 'POST':
        # create a form instance and populate it with data from the request:
        form = NameForm(request.POST)
        # check whether it's valid:
        if form.is_valid():
            # process the data in form.cleaned_data as required
            # ...
            # redirect to a new URL:
            return HttpResponseRedirect('/thanks/')

    # if a GET (or any other method) we'll create a blank form
    else:
        form = NameForm()

    return render(request, 'name.html', {'form': form})

Если мы подходим к этому представлению с запросом GET , оно создает пустой экземпляр формы и помещает его в контекст шаблона для отображения. Это то, что вы ожидаете, когда впервые обращаетесь к рассматриваемому URL-адресу.

Если форма отправлена приложением POST , вид также создает экземпляр формы и в комплекте с данными , полученными из запроса: . Это называется «привязкой данных к форме» (теперь это связанная форма , «привязанная» на английском языке).form = NameForm(request.POST)

Метод is_valid() называется; если он не возвращается True , мы находимся на этапе шаблона, содержащего форму. Но на этот раз форма не является девственной ( не связанной или несвязанной ), поэтому HTML-форма будет заполнена ранее введенными данными, данными, которые можно изменить и исправить по мере необходимости.

Если is_valid() возвращается True , все проверенные данные формы доступны в атрибуте cleaned_data . Эти данные можно использовать для обновления базы данных или выполнения других операций перед отправкой браузеру перенаправления HTTP с указанием URL-адреса для перезагрузки.

Шаблон

В шаблоне особо нечего делать name.html :

<form action="/your-name/" method="post">
    {% csrf_token %}
    {{ form }}
    <input type="submit" value="Submit">
</form>

Все поля формы и их атрибуты будут преобразованы в HTML-теги из языка шаблонов Django.{{ form }}

Формы и защита от "подделки межсайтовых запросов" (CSRF)

Django поставляется с простой в использовании защитой от атак подделки межсайтовых запросов . При отправке формы методом POST CSRF и активной защитой необходимо использовать тег шаблона, csrf_token как в предыдущем примере. Однако, поскольку защита CSRF не связана напрямую с формами в шаблонах, этот тег опускается в следующих примерах в этом документе.

Типы компонентов HTML5 и проверка браузера

Если форма содержит поле типа URLField , EmailField или любой тип целочисленного поля, Django использует компоненты HTML5 (вход) типа url , email и number . По умолчанию браузеры часто применяют к этим полям собственную проверку, которая может быть более строгой, чем в Django. Если вы хотите , чтобы избежать этой проверки, добавьте атрибут novalidate в тег form или определить другой компонент формы для поля, как , например TextInput .

Теперь у нас есть рабочая веб-форма, определяемая экземпляром Form Django, обрабатываемая представлением и отображаемая как тег HTML <form> .

Это все, что вам нужно для начала, но инфраструктура форм может предложить гораздо больше. Как только вы поймете основы описанного выше процесса, будет полезно узнать о других функциях, которые предоставляет система форм, и немного больше узнать о базовом механизме.

Подробнее о классах Form Django

Все классы форм создаются как подклассы от django.forms.Form или django.forms.ModelForm . ModelForm можно рассматривать как подкласс Form . Form и ModelForm наследуют общее поведение от (частного) класса BaseForm , но эта деталь реализации редко имеет смысл.

Шаблоны и формы

Фактически, если форма предназначена для прямого добавления или изменения модели Django, ModelForm может сэкономить вам много времени, усилий и кода, поскольку она заботится о создании формы со всеми соответствующими полями и атрибутами. из класса Model .

Связанные и несвязанные экземпляры форм

Различие между связанными и несвязанными формами важно:

  • Пустая форма не имеет связанных данных. При представлении пользователю он будет либо пустым, либо содержать только значения по умолчанию.
  • Заполненная форма содержит отправленные данные, поэтому можно спросить, действительны ли эти данные. Если отображается недействительная заполненная форма, она может содержать встроенные сообщения об ошибках, сообщающие пользователю, какие данные следует исправить.

Атрибут is_bound формы указывает, были ли данные связаны с формой или нет.

Подробнее о полях

Вот несколько более полезная форма, чем наш минимальный пример выше, которую мы могли бы использовать для реализации функции «Связаться со мной» на личном веб-сайте:

forms.py
from django import forms

class ContactForm(forms.Form):
    subject = forms.CharField(max_length=100)
    message = forms.CharField(widget=forms.Textarea)
    sender = forms.EmailField()
    cc_myself = forms.BooleanField(required=False)

В предыдущей форме было одно поле your_name типа CharField . В этом случае форма имеет четыре поля: subject , message , sender и cc_myself . CharField , EmailField и BooleanField это всего лишь три из доступных типов полей; полный список можно найти в полях формы .

Компоненты формы («виджеты»)

Каждому полю формы соответствует класс Widget , который сам относится к компоненту формы HTML, например, например .<input type="text">

В большинстве случаев подходит компонент поля по умолчанию. Например, компонент поля по умолчанию CharField - это TextInput , который создает тег HTML. Если бы вместо этого вам понадобился тег , вам пришлось бы определить соответствующий компонент при определении поля формы, как мы это сделали для поля .<input type="text"> <textarea> message

Полевые данные

Какие бы данные ни отправлялись с формой, к тому моменту, когда они будут успешно проверены после вызова is_valid()is_valid() возвращены True ), проверенные данные формы уже находятся в словаре form.cleaned_data . Эти данные будут любезно преобразованы в типы Python.

Заметка

На этом этапе вы все еще можете напрямую получить доступ к незафиксированным данным request.POST , но проверенные данные более подходят.

В приведенном выше примере контактной формы cc_myself будет логическое значение. Аналогичным образом введите поля IntegerField и FloatField преобразуйте значения в типы Python int и float , соответственно.

Вот как можно обрабатывать данные формы в представлении, которое обрабатывает эту форму:

views.py
from django.core.mail import send_mail

if form.is_valid():
    subject = form.cleaned_data['subject']
    message = form.cleaned_data['message']
    sender = form.cleaned_data['sender']
    cc_myself = form.cleaned_data['cc_myself']

    recipients = ['[email protected]']
    if cc_myself:
        recipients.append(sender)

    send_mail(subject, message, sender, recipients)
    return HttpResponseRedirect('/thanks/')

выходка

Чтобы узнать больше об отправке электронной почты из Django, см. Отправка сообщений электронной почты .

Некоторые типы полей требуют дополнительной обработки. Например, файлы, загруженные через форму, должны обрабатываться по-другому (к ним можно получить доступ request.FILES , а не через request.POST ). Подробные сведения о том, как обрабатывать загрузку файлов с помощью формы, см. В разделе « Связывание загруженных файлов с формой» .

Формы и шаблоны

Все, что требуется для включения формы в шаблон, - это поместить экземпляр формы в контекст шаблона. Таким образом, если форма вызывается form в контексте, достаточно будет отобразить ее элементы и соответственно.{{ form }} <label> <input>

Параметры отображения формы

Надстройки HTML для форм в шаблонах

Помните, что HTML-рендеринг формы не включает <form> ни ограничивающий тег , ни компонент submit для отправки формы. Вы должны добавить эти элементы.

Однако есть и другие варианты для пар <label> / <input> :

  • {{ form.as_table }} отображает компоненты как ячейки таблицы внутри тегов <tr>
  • {{ form.as_p }} отображать компоненты в тегах <p>
  • {{ form.as_ul }} отображать компоненты в тегах <li>

Обратите внимание, что вам нужно будет самостоятельно добавлять элементы к содержимому продукта <table> или <ul> вокруг него.

Вот что отображается для нашего экземпляра :{{ form.as_p }} ContactForm

<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>
    <textarea name="message" id="id_message" required></textarea></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>

Обратите внимание, что каждое поле формы получает определенный атрибут идентификатора, на id_<nom-de-champ> который ссылается label соответствующий тег . Это важно для обеспечения доступа к формам для вспомогательных устройств, таких как программное обеспечение для чтения с экрана. Вы также можете настроить способ создания элементов label и id .

См. Раздел Отображение форм в HTML для получения дополнительной информации об этом.

Ручное отображение полей

Разрешение Django отображать поля формы одно за другим - не единственный вариант; вы можете легко отобразить поля самостоятельно (например, чтобы изменить их порядок отображения). Каждое поле доступно как атрибут формы с синтаксисом , который в шаблоне Django будет правильно отображать. Например :{{ form.nom_du_champ }}

{{ form.non_field_errors }}
<div class="fieldWrapper">
    {{ form.subject.errors }}
    <label for="{{ form.subject.id_for_label }}">Email subject:</label>
    {{ form.subject }}
</div>
<div class="fieldWrapper">
    {{ form.message.errors }}
    <label for="{{ form.message.id_for_label }}">Your message:</label>
    {{ form.message }}
</div>
<div class="fieldWrapper">
    {{ form.sender.errors }}
    <label for="{{ form.sender.id_for_label }}">Your email address:</label>
    {{ form.sender }}
</div>
<div class="fieldWrapper">
    {{ form.cc_myself.errors }}
    <label for="{{ form.cc_myself.id_for_label }}">CC yourself?</label>
    {{ form.cc_myself }}
</div>

<label> Полный тег также можно создать с помощью label_tag() . Например :

<div class="fieldWrapper">
    {{ form.subject.errors }}
    {{ form.subject.label_tag }}
    {{ form.subject }}
</div>

Отображение сообщений об ошибках формы

Цена этой гибкости - немного больше работы. До сих пор нам не приходилось беспокоиться о том, как отображать ошибки формы, потому что об этом позаботились мы. В этом примере мы должны были убедиться, что мы позаботились обо всех ошибках для каждого поля и любых ошибках для формы в целом. Обратите внимание на верхнюю часть формы и шаблон поиска ошибок в каждом поле.{{ form.non_field_errors }}

Синтаксис отображает список ошибок формы в виде неупорядоченного списка. Это могло бы выглядеть так:{{ form.nom_du_champ.errors }}

<ul class="errorlist">
    <li>Sender is required.</li>
</ul>

В списке есть класс CSS, errorlist позволяющий стилизовать его внешний вид. Если вы хотите дополнительно настроить отображение ошибок, вы можете сделать это с помощью цикла:

{% if form.subject.errors %}
    <ol>
    {% for error in form.subject.errors %}
        <li><strong>{{ error|escape }}</strong></li>
    {% endfor %}
    </ol>
{% endif %}

Ошибкам, не связанным с полями (или ошибкам скрытых полей, которые отображаются в верхней части формы при использовании таких утилит form.as_p() ), будет присвоен дополнительный класс, nonfield который поможет различать ошибки, относящиеся к конкретным полям. Например, будет выглядеть так:{{ form.non_field_errors }}

<ul class="errorlist nonfield">
    <li>Generic validation error</li>
</ul>

Подробнее об ошибках, форматировании и изменении атрибутов формы в шаблонах см. В API форм .

Циклы по полям формы

Если вы используете один и тот же HTML-код для всех полей формы, вы можете уменьшить дублирование кода, перебирая каждое поле в цикле с помощью оператора :{% for %}

{% for field in form %}
    <div class="fieldWrapper">
        {{ field.errors }}
        {{ field.label_tag }} {{ field }}
        {% if field.help_text %}
        <p class="help">{{ field.help_text|safe }}</p>
        {% endif %}
    </div>
{% endfor %}

Вот несколько полезных атрибутов поля:

{{ field.label }}
Например, метка поля .Adresse de courriel
{{ field.label_tag }}

Заголовок поля помещается в <label> соответствующий HTML-тег . Это включает параметр label_suffix формы. Например, по label_suffix умолчанию используется двоеточие:

<label for="id_email">Email address:</label>
{{ field.id_for_label }}
Атрибут, id используемый для этого поля ( id_email в примере выше). Если вы сами создаете метку поля, может быть полезно использовать ее вместо label_tag . Это также полезно, например, если у вас есть онлайн-код JavaScript и вы хотите избежать замораживания идентификатора поля.
{{ field.value }}
Например, значение поля [email protected] .
{{ field.html_name }}
Имя поля, как оно будет использоваться в имени поля тега input . Учитывает префикс формы, если он определен.
{{ field.help_text }}
Любой текст справки, связанный с элементом управления.
{{ field.errors }}
Отображает список, содержащий все ошибки проверки, соответствующие этому полю. Вы можете настроить представление ошибок с помощью цикла . В этом случае каждый объект цикла представляет собой строку символов, содержащую сообщение об ошибке.<ul class="errorlist"> {% for error in field.errors %}
{{ field.is_hidden }}
Этот атрибут действителен, True если поле формы является скрытым полем, в противном случае это так False . Это не особенно полезно в качестве переменной шаблона, но может быть полезно в условных тестах, таких как:
{% if field.is_hidden %}
   {# Do something special #}
{% endif %}
{{ field.field }}
Экземпляр Field класса формы, который BoundField адаптируется этим объектом . Вы можете использовать его для доступа к атрибутам Field , например .{{ char_field.field.max_length }}

Смотрите также

Полный список атрибутов и методов см BoundField . В разделе .

Циклы по скрытым и видимым полям

Если вы вручную отображаете форму в шаблоне без использования представления формы по умолчанию в Django, вам может потребоваться обрабатывать поля иначе, чем другие скрытые поля. Например, поскольку скрытые поля не создают видимого содержимого, отображение сообщений об ошибках «рядом» с полем может запутать пользователей; таким образом, необходимо по-разному управлять ошибками этого типа контроля.<input type="hidden">

Django предоставляет два метода, которые позволяют независимо выполнять цикл для видимых и скрытых полей: hidden_fields() и visible_fields() . Вот модификация предыдущего примера с использованием этих двух методов:

{# Include the hidden fields #}
{% for hidden in form.hidden_fields %}
{{ hidden }}
{% endfor %}
{# Include the visible fields #}
{% for field in form.visible_fields %}
    <div class="fieldWrapper">
        {{ field.errors }}
        {{ field.label_tag }} {{ field }}
    </div>
{% endfor %}

В этом примере вообще не обрабатываются ошибки для скрытых полей. В принципе, ошибка в скрытом поле является признаком злоупотребления формой, поскольку обычное взаимодействие с формой не меняет их. Однако вы также можете легко добавить форму отображения для этих ошибок формы.

Многоразовые шаблоны форм

Если ваш сайт использует одну и ту же логику отображения формы в нескольких местах, вы можете уменьшить дублирование, сохранив цикл формы в отдельном шаблоне и используя тег include для повторного использования этого содержимого в других шаблонах:

# In your form template:
{% include "form_snippet.html" %}

# In form_snippet.html:
{% for field in form %}
    <div class="fieldWrapper">
        {{ field.errors }}
        {{ field.label_tag }} {{ field }}
    </div>
{% endfor %}

Если объект формы, переданный в шаблон, имеет другое имя в контексте, вы можете присвоить ему псевдоним с помощью параметра with тега include :

{% include "form_snippet.html" with form=comment_form %}

Если вы обнаружите, что часто воспроизводите один и тот же код, возможно, вам придется подумать о создании настраиваемого тега включения .

Дополнительные темы

На этой странице рассказывается об основах, но формы могут делать гораздо больше:

Смотрите также

Ссылка на форму
Содержит полную справку по API, включая поля формы, компоненты формы, а также проверку полей и форм.

Copyright ©2020 All rights reserved