Iterating Over Model Fields in Django Templates

Django’s template language offers various effective methods to access and exhibit model instance data in templates. Frequently, there is a need to iterate through all fields or particular sets of fields within a model instance to showcase their values. This approach allows for a dynamic and programmatic rendering of model data. Nevertheless, executing this task mandates a grasp of Django template tags and filters, coupled with an understanding of model relations. In this post, I will illustrate several techniques to accomplish this, supported by code examples.

Getting Started – Model Setup

First, we need a sample Django model to illustrate. We’ll use a simple Article model with a few fields like title, content, author, created_at etc. The model would be something like:

class Article(models.Model):
    title = models.CharField(max_length=100) 
    content = models.TextField()
    author = models.ForeignKey(Author, on_delete=models.CASCADE)
    created_at = models.DateTimeField(auto_now_add=True)

Article Object in Context

The first step is to have an Article instance available in the template context. This would typically be handled in the view. For example:

def article_detail(request, slug):
    article = get_object_or_404(Article, slug=slug) 
    context = {
        "article": article
    return render(request, "article_detail.html", context)

Now the article object can be accessed in the article_detail.html template.

Simple Field Display

The simplest way to display model fields is by accessing them directly like {{ article.title }}. However, what if we want to iterate over all or some fields?

All Fields in a Loop

We can use the {% for %} tag to enumerate all fields of an object like:

{% for field in article %}
  <b>{{ }}</b>: {{ field }}<br>
{% endfor %}

This will display each field name and value in a loop. The field name is obtained via and the value with field. We can customize the display as needed.

Specific Fields

Alternatively, we may want to display just a subset of fields, not every one. For example, the non-relational fields:

{% for field in article|slice:"title,content,created_at" %}
{% endfor %}

Here the `slice` filter gives just the mentioned fields. The opposite is slice from beginning to a field.

Including Relational Fields
So far we were iterating over non-relational attributes of the model. However, Django models may also contain relational field like ForeignKeys pointing to other models.

We can easily include these as well in the iteration:

{% for field in article|add:"author" %}
   {% if == "author" %}
      <b>Author</b>: {{ field }} 
   {% else %}
   {% endif %}
{% endfor %}

Here, author being a ForeignKey field is additionally included via the add filter. The check on `` allows custom display for relations vs. regular field.

Formatting Field Values

Field values displayed using `{{ field }}` will include the __str__ representation. We can apply Django filters for formatting and customization.

<b>Created</b>: {{ field.created_at|date:"M d Y" }}

This renders the date properly formatted. Pretty printing andPtional other transformations are thus possible while iterating over field.

Accessing Field Verbose Names

Django model field have a `verbose_name` attribute that contains a nice, human readable version of the field name. We can leverage this for display:

{% for field in article %}
   <b>{{ field.verbose_name|title }}</b>: {{ field }}
{% endfor %}

So instead of `created_at` it would render `Created At`. Useful for readable displays.

Handling Missing Fields

If a model instance might have some optional unassigned fields, we should handle them correctly in templates:

{% for field in article %}
  {% if field %} 
    <b>{{ field.verbose_name }}</b>: {{ field }}
  {% else %}
  {% endif %}
{% endfor %}

This avoids run time errors by dealing with missingFields gracefully.


In this article, we explored different techniques for iterating over Django modelFields within templates to dynamically display object data. Some key takeaways:

  • Use {% for %} tag and access model attributes as field
  • Filter with slice and add to manage field sets
  • Format values using Django filters
  • Use and field.verbose_name for metadata
  • Check for missingFields to avoid errors

Having field names and values available in templates enables building admin screens, model detail pages and handling model data in general more easily. Hope this gives you ideas on enhancing your next Django templates and views!