[Solved] Is there a Django template tag that lets me set a context variable?

I want to be able to set variables in a template to string values. I wrote a tag, but it doesn’t seem to change the context. The intended use is:

{% define "a string" as my_var %}

Update (solved):

class DefineNode(Node):
    def __init__(self, var, name):
        self.var = var
        self.name = name

    def __repr__(self):
        return "<DefineNode>"

    def render(self, context):
        context[self.name] = self.var
        return ''

def define(parser, token):
    Adds a name to the context for referencing an arbitrarily defined string.

    For example:

        {% define "my_string" as my_string %}

    Now anywhere in the template:

        {{ my_string }}
    bits = list(token.split_contents())
    if (len(bits) != 4 or bits[2] != "as") or 
        not (bits[1][0] in ('"', "'") and bits[1][-1] == bits[1][0]):
        raise TemplateSyntaxError("%r expected format is '""string"" as name'" % bits[0])
        value = bits[1][1:-1]
    name = bits[3]
    return DefineNode(value, name)

Solution #1:

You don’t need to write your own tag. The built-in {% with %} tag does this.

Respondent: hekevintran

Solution #2:

Django already considered this particular case and provides the assigment tags, an special way of registering tags that set a variable in the context.

In this case, you don’t need to care about retrieving, updating and saving the context. You simply do this:

def define(the_string):
  return the_string

And you can use it the very same way, but it is much cleaner:

{% define "a string" as my_var %}

This all the code you need.

As Dirk Bergstrom pointed out, since version django 1.9 assignment_tag is deprecated. simple_tag is a perfect replacement.

def define(the_string):
  return the_string
Respondent: Daniel Roseman

Solution #3:

The answer is buried inside the more complex current_time example in the documentation.


You want to add a variable to the context. But you don’t want to go back and add that variable to all the views which call all the templates which invoke the tag. You just want a tag which can add some data to the context wherever its wanted. I’m looking for this kind of thing when rendering those random distractions which get dropped into sidebars and aren’t specifically related to the work of the main view, for example.


To inject a variable to the context you need access to the context. To do that your custom tag will inject a node which added the data to the template context.


This example adds a “coming_events” queryset to the context then loops over each result. It does that by declaring a custom tag which renders a node which adds a queryset to the context.

from django import template
from apps.events.models import Event
register = template.Library()

def coming_events(parser, token):
    return EventNode()

class EventNode(template.Node):
    def render(self, context):
        context['coming_events'] = Event.objects.all()
        return ''

You’d use it like this:

{% load events %}
{% coming_events %}
{% for event in coming_events %}
<div class="eventItem">
   <p>{{event.title}} {{event.data}}</p>
{% endfor %}

Extra Credit

If you’re really keen to be able to name the variable arbitrarily eg {% coming_events as events %} then look closely at the example in the documentation and note how they split the token into what’s before the ‘ as ‘ and what’s after and use the latter part to name the context variable. You’d have to implement that.

Note that if I wound up putting the HTML for each event into its own dedicated template then I’d be better off just following the standard inclusion tag example in the documentation. This solution is suggested for when you want the data without any baggage.

Respondent: kiril

Solution #4:

If you want the variable to be available in other template blocks, you should look at http://od-eon.com/blogs/liviu/scope-variables-template-blocks/ . In particular, in the custom tag code, you should replace:

context[some_var_name] = some_val


context.dicts[0][some_var_name] = some_val

That will do the trick (though it is possibly an ugly trick, and you should consider alternatives).

Respondent: John Mee

Solution #5:

First of all, you generally want to set context variables within your view. Putting logic in the template is really a formula for added mess. That said, there does come a time when you want to use this, and the {% with %} tag makes a mess of things since you HAVE to end it with a {% endwith %}, losing the variable. The problem I ran into is that I can’t include a template while passing it a value. I’d like to do:

{% if criteria %}
  {% define 'foo' as some_option %}
{% else %}
  {% define 'bar' as some_option %}
{% endif %}

{% include "some_template_partial.html" %}

This is impossible to do using {% with %} tags without having repeated code:

{% if criteria %}
  {% with 'foo' as some_option %}
    {% include "some_template_partial.html" %}
  {% endwith %}
{% else %}
  {% with 'bar' as some_option %}
    {% include "some_template_partial.html" %}
  {% endwith %}
{% endif %}

Fine as it is now, but this will degrade into a horrible mess as cases proliferate. Thus this code was written:

from django import template
from django.conf import settings
import logging
import re
register = template.Library()


class define_node(template.Node):
  def __init__(self, value, key, parse):
    self.value = value
    self.key = key
    self.parse = parse
  def render(self, context):
      if self.key in context:
        raise Exception("EPIC NAMESPACE FAIL, CONTEXT HAZ A %s" % self.key)
    if self.parse:
      context[self.key] = context[self.value]
      context[self.key] = self.value
    return ''

def define(parser, token):
  """Definition template tag. Use to define variables in your context within the template.
  Sorta like the {% with "blah" as blah %} tag, but without the {% endwith %} mess.

  Supports two modes:
  Literal mode: argument is encapsulated with quotes (e.g. "blah" or 'blah')
                variable, is set to the string literal, ex:
                {% define "fish" as foo %}
  Variable mode: argument is prefixed with a $ (e.g. $blah or $monkey)
                 variable is copied from another context variable, ex:
                 {% define $fish as foo %}

  Namespace protection is also provided if django.conf.settings.DEBUG is True.
  You will get an epic namespace fail if that occurs (please fix it before you deploy)

    * define override nomenclature if you REALLY want to overwrite a variable
      - should decide what nomeclature to use first
    * expand on variables so that {% define $array.blah as foo %} will work
      (this currently WILL NOT)
    tag_name, arg = token.contents.split(None, 1)
  except ValueError:
    raise template.TemplateSyntaxError, "%r tag requires arguments" % token.contents.split()[0]
  m = re.search(r'(.*?) as (w+)', arg)
  if not m:
    raise template.TemplateSyntaxError, "%r tag had invalid arguments" % tag_name
  value, key = m.groups()
  if (value[0] == value[-1] and value[0] in ('"', "'")):
    ret = value[1:-1]
    parse = False
  elif (value[0] == '$'):
    ret = value[1:]
    parse = True
    raise template.TemplateSyntaxError, "%r tag's first argument indeciperable" % tag_name
  return define_node(ret, key, parse)
Respondent: Jameson Quinn

Solution #6:

You can use kiril’s answer. It’s quite simple. You can also use the set_context tag of django-libs.


{% set_context foo.bar|filter_foo as foobar %}
Respondent: shu.chen

Solution #7:

You can use custom template tags to set variables like so:

You create a file called set_var.py in your templatetags folder that contains the following code:

from django import template

register = template.Library()

class SetVarNode(template.Node):

    def __init__(self, var_name, var_value):
        self.var_name = var_name
        self.var_value = var_value

    def render(self, context):
            value = template.Variable(self.var_value).resolve(context)
        except template.VariableDoesNotExist:
            value = ""
        context[self.var_name] = value
        return u""

def set_var(parser, token):
        {% set <var_name>  = <var_value> %}
    parts = token.split_contents()
    if len(parts) < 4:
        raise template.TemplateSyntaxError("'set' tag must be of the form:  {% set <var_name>  = <var_value> %}")
    return SetVarNode(parts[1], parts[3])

register.tag('set', set_var)

Then to use this in your template, you just do the following:

{% load set_var %}

{% set a = 3 %}
{% set b = some_context_variable %}
{% set c = "some string" %}

Value of a is {{a}}
Value of b is {{b}}
Value of c is {{c}}
Respondent: Tobias Lorenz

The answers/resolutions are collected from stackoverflow, are licensed under cc by-sa 2.5 , cc by-sa 3.0 and cc by-sa 4.0 .

Leave a Reply

Your email address will not be published.