How can I access a dictionary element in a Django template?

Use:

choices = {'key1':'val1', 'key2':'val2'}

Here's the template:

<ul>
{% for key, value in choices.items %}
  <li>{{key}} - {{value}}</li>
{% endfor %}
</ul>

Basically, .items is a Django keyword that splits a dictionary into a list of (key, value) pairs, much like the Python method .items(). This enables iteration over a dictionary in a Django template.

You can use the dot notation:

Dot lookups can be summarized like this: when the template system encounters a dot in a variable name, it tries the following lookups, in this order:

• Dictionary lookup (e.g., foo["bar"])
• Attribute lookup (e.g., foo.bar)
• Method call (e.g., foo.bar())
• List-index lookup (e.g., foo[2])

The system uses the first lookup type that works. It’s short-circuit logic.

You need to find (or define) a 'get' template tag, for example, here.

The tag definition:

@register.filter
def hash(h, key):
    return h[key]

And it’s used like:

{% for o in objects %}
  <li>{{ dictionary|hash:o.id }}</li>
    {% endfor %}

django_template_filter filter name get_value_from_dict

{{ your_dict|get_value_from_dict:your_key }}

Similar to the answer by russian_spy:

<ul>
{% for choice in choices.items %}
  <li>{{choice.0}} - {{choice.1}}</li>
{% endfor %}
</ul>

This might be suitable for breaking down more complex dictionaries.

I couldn't find anything simpler and better than this solution. Also see the documentation.

@register.filter
def dictitem(dictionary, key):
    return dictionary.get(key)

But there's a problem (also discussed here) that the returned item is an object, and I need to reference a field of this object. Expressions like {{ (schema_dict|dictitem:schema_code).name }} are not supported, so the only solution I found was:

{% with schema=schema_dict|dictitem:schema_code %}
    <p>Selected schema: {{ schema.name }}</p>
{% endwith %}

And:

@register.filter
def member(obj, name):
    return getattr(obj, name, None)

So there isn’t any need for a with tag:

{{ schema_dict|dictitem:schema_code|member:'name' }}

Ideally, you would create a method on the choice object that found itself in votes, or create a relationship between the models. A template tag that performed the dictionary lookup would work, too.

I'd suggest to add some simple preprocessing in the view, then passing the data to the view. I'd say that it keeps the template simple and it grows nicely as your view become more complicated.

You could create a dataclass containing all the data that you're showing:

@dataclasses.dataclass(frozen=True)
class ChoicesInfo:
    choice: Choice
    votes: int

Then, in the view, you populate the list:

choices_info = [ChoiceInfo(choice, votes[choice.id] for choice in choices]

Then, you pass choices_info instead.

Django’s template language does not support Python-style indexing like votes[choice.id]. That is why you are seeing the error saying it cannot parse the expression. The template system is intentionally limited, so direct dictionary lookups with brackets are not allowed.

1. Recommended: do the lookup in the view

A simple approach is to attach the vote count to each choice in the view before rendering the template. This keeps the template clean and keeps the logic in Python, which is usually easier to maintain.

View:

def poll_view(request):
    choices = Choice.objects.all()
    votes = get_votes_dict_somehow()  # example: {1: 10, 2: 7, 3: 4}

    for c in choices:
        c.vote_count = votes.get(c.id, 0)

    return render(request, "poll.html", {"choices": choices})

Template:

{% for choice in choices %}
    {{ choice.choice }} - {{ choice.vote_count }}<br>
{% endfor %}

2. Use a custom template filter

If you really want to access the dictionary directly in the template, you can write a small filter that returns the value for a given key.

yourapp/templatetags/dict_extras.py

from django import template

register = template.Library()

@register.filter
def dict_get(d, key):
    return d.get(key, "")

Template:

{% load dict_extras %}

{% for choice in choices %}
    {{ choice.choice }} - {{ votes|dict_get:choice.id }}<br>
{% endfor %}

This gives you a simple and readable way to access dictionary values without using bracket notation. Both methods work, so choose whichever one fits your workflow better.