Django passing variables to templates from class based views

Question

If I have a class based view, like this,

class SomeView (View):
    response_template=\'some_template.html\'
    var1 = 0
    var2 = 1

    def get(self, re         


        

Answer 1

For passing your class label variable inside a function, you need to refer with self which refer as a newly created object. As we know for accessing any variable in class we need to refer to its object. Otherwise, it will be caught global name 'your variable' is not defined

as an example in your case you can do it like

class YourView(genericView):
    template_name='your_template.html'
    var1 = 12
    var2 =1

    def get(self, **kwargs):
        context = locals()
        context['var1'] = self.var1
       context['var2'] = self.var2
       return context

Answer 2

There are two approaches as you can see here. The first one, you can declare a function named get_context_data like this:

def get_context_data(self, **kwargs):          
    context = super().get_context_data(**kwargs)                     
    new_context_entry = "here it goes"
    context["new_context_entry"] = new_context_entry
    return context

If you are using Django 2.x you must pass *args in get_context_data too.

The second approach is modifying extra_context variable in some function in the view:

self.extra_context["another_one"] = "here goes more"

Answer 3

A cleaner way of doing this could be to replicate Django's Template view:

class TemplateView(TemplateResponseMixin, ContextMixin, View):
    """
    A view that renders a template.  This view will also pass into the context
    any keyword arguments passed by the url conf.
    """
    def get(self, request, *args, **kwargs):
        context = self.get_context_data(**kwargs)
        return self.render_to_response(context)

and then adding it to the get_context_data function. Or you could simply use the TemplateView which will allow you to specify a template name and then you could override the get_context_data function:

class SomeView(generic.TemplateView):
    var1 = 0
    var2 = 1 
    template_name = 'some_template.html'

    def get_context_data(self, **kwargs):
        context = super(SomeView, self).get_context_data(**kwargs)
        context.update({'var1': self.var1, 'var2': self.var2})
        return context

EDIT

Django has generic views which you can use for a variety of things, I would strongly advise you to go look at the docs for a full list of them, These generic views have functions you can override to do custom things which aren't supported by default. In your case you just wanted a template with context variables on them which means you subclass the TemplateView and supply the template_name and then finally you can override the get_context_data function to add your context data and that would be all there is to it, the second piece of code would be all you need in your case.

Answer 4

Add self.var1 and self.var2 to the context in get method:

class SomeView (View):
    response_template='some_template.html'
    var1 = 0
    var2 = 1

    def get(self, request, *args, **kwargs):
        context = locals()
        context['var1'] = self.var1
        context['var2'] = self.var2
        return render_to_response(self.response_template, context, context_instance=RequestContext(request))

Note: render_to_response() is removed in Django 3.0 and above (use render() instead).

Also, I'm not sure that passing locals() as a context to the template is a good practice. I prefer to construct the data passed into the template explicitly = pass only what you really need in the template.