Django 的默认模板表单渲染 ( {{ form }} ) 是如何工作的？

Question

The most basic way to render a form in a template in Django is to add an instance of the form to the context:

context['form'] = MyForm()

And then, in your template, render the form by calling it as a template variable:

<form method="POST">
    {% csrf_token %}
    {{ form }}
</form>

When this template is rendered, {{ form }} gets rendered as:

<label for="my_field">my_field:</label>
<input type="default_widget_for_field_type" name="my_field" />

with one pair for each field in your form.

My question is: what code path on the form and/or in the templating language actually does this rendering? Based on other conventions in the Django templating language, I had expected the Python underlying {{ form }} to be form() , much like {{ object.get_absolute_url }} ends up being object.get_absolute_url() , but when I instantiate an instance of my form in the shell and try to call it, I get a TypeError telling me it's not callable. I had a look at the Django source code trying to figure out where this gets done, but I didn't have much luck.

---

Here's my use case. I want to create a ModelForm for a model representing a comment on a piece of content. It has a foreign key to that content model. There are multiple pieces of content on each page, so I need to instantiate multiple, unbound copies of the ModelForm to create comments on each piece of content. Each form will be attached to its content object on the page, so I don't want the foreign key to be a user-editable field.

This means that I need to take care of populating the foreign key field, and it makes sense to me to do that from the template as a hidden form field, because the template will have access to the object that it needs to set the foreign key to. However, if I leave the foreign key field off of the ModelForm, then the model won't save correctly on form validation. I could override the form validation to add in the hidden field, but I feel like a more elegant way to do it would be to add the field to the ModelForm, then override the ModelForm's rendering method so it doesn't try to render that field. Then I'll add the field manually in my template.

{% for piece_of_content in page_contents %}
    {# the content #}
    <p>Add your comment!</p>
    <form method="POST" action="{% url 'comment-create' %}">
        {% csrf_token %}
        {# the overridden rendering method won't render the foreign key field... #}
        {{ form }}
        {# then I add it manually #}
        <input type="hidden" name="commented_on" value="{{ piece_of_content.id }}" />
    </form>

Then I wire the url for 'comment-create' to a CreateView , set its form_class to the ModelForm, and it will do its thing without any additional input from my end.

If the form were just callable, like I thought, then I could override __call__ on the ModelForm, and tell it to render everything but the foreign key field. But the ModelForm doesn't have a __call__ , and I can't figure out where it is done! The form has methods for rendering various other configurations ( as_p , as_ul , and as_table ), but none that I see for just the default rendering.

Answer 1

Including {{ form }} is the same as {{ form.as_table }} . This is because the form's __str__ method calls its as_table() method. See the docs on outputting forms as HTML for more info.

The docs on template variables and lookups explain how variables are included in the template. If attributes are callable, the method is called. However in your case, form instances are not callable, so the unicode representation of the form is displayed.

If you don't want users to edit a field, I suggest you exclude it from the form and set it in the view. Users can tamper with the values of hidden fields.

Answer 2

The answer to your question is that this is just the string representation of the form: __unicode__() calls as_p() which renders the form.

However, this really isn't the way to do it. Rather than trying to hack both output and validation, and then try to insert the value, you should just exclude the foreign key from the form altogether. Then simply add it when you save: you can get the relevant value from the URL that the form posts to, and add it there:

if form.is_valid():
    obj = form.save(commit=False)
    obj.content_id = value_from_url
    obj.save()