Django shortcut functions

render(request, template_name, context=None, content_type=None, status=None, using=None)

Combines a given template with a given context dictionary and returns an HttpResponse object with that rendered text.

Django does not provide a shortcut function which returns a because the constructor of TemplateResponse offers the same level of convenience as .

request

The request object used to generate this response.

template_name

The full name of a template to use or sequence of template names. If a sequence is given, the first template that exists will be used. See the template loading documentation for more information on how templates are found.

Optional arguments

context

A dictionary of values to add to the template context. By default, this is an empty dictionary. If a value in the dictionary is callable, the view will call it just before rendering the template.

content_type

The MIME type to use for the resulting document. Defaults to 'text/html'.

status

The status code for the response. Defaults to 200.

using

The NAME of a template engine to use for loading the template.

This example is equivalent to:

from django.http import HttpResponse
from django.template import loader
def my_view(request):
    # View code here...
    t = loader.get_template('myapp/index.html')
    c = {'foo': 'bar'}
    return HttpResponse(t.render(c, request), content_type='application/xhtml+xml')

redirect(to, \args, permanent=False, **kwargs*)

Returns an to the appropriate URL for the arguments passed.

The arguments could be:

A model: the model’s get_absolute_url() function will be called.
A view name, possibly with arguments: will be used to reverse-resolve the name.

By default issues a temporary redirect; pass permanent=True to issue a permanent redirect.

Examples

You can use the function in a number of ways.

By passing some object; that object’s get_absolute_url() method will be called to figure out the redirect URL:

from django.shortcuts import redirect
    ...
    obj = MyModel.objects.get(...)
    return redirect(obj)

By passing the name of a view and optionally some positional or keyword arguments; the URL will be reverse resolved using the method:
```
def my_view(request):
    ...
    return redirect('some-view-name', foo='bar')
```
By passing a hardcoded URL to redirect to:
```
def my_view(request):
    ...
    return redirect('/some/url/')
```
This also works with full URLs:

By default, redirect() returns a temporary redirect. All of the above forms accept a permanent argument; if set to True a permanent redirect will be returned:

def my_view(request):
    ...
    obj = MyModel.objects.get(...)
    return redirect(obj, permanent=True)

get_object_or_404(klass, \args, **kwargs*)

Calls on a given model manager, but it raises Http404 instead of the model’s exception.

klass

A Model class, a , or a QuerySet instance from which to get the object.

Lookup parameters, which should be in the format accepted by get() and filter().

Example

The following example gets the object with the primary key of 1 from MyModel:

from django.shortcuts import get_object_or_404
def my_view(request):

This example is equivalent to:

from django.http import Http404
    try:
        obj = MyModel.objects.get(pk=1)
    except MyModel.DoesNotExist:
        raise Http404("No MyModel matches the given query.")

The most common use case is to pass a Model, as shown above. However, you can also pass a instance:

queryset = Book.objects.filter(title__startswith='M')
get_object_or_404(queryset, pk=1)

The above example is a bit contrived since it’s equivalent to doing:

but it can be useful if you are passed the queryset variable from somewhere else.

Finally, you can also use a Manager. This is useful for example if you have a :

get_object_or_404(Book.dahl_objects, title='Matilda')

You can also use related managers:

author = Author.objects.get(name='Roald Dahl')
get_object_or_404(author.book_set, title='Matilda')

Note: As with get(), a exception will be raised if more than one object is found.

get_list_or_404(klass, \args, **kwargs*)

Returns the result of filter() on a given model manager cast to a list, raising if the resulting list is empty.

klass

A Model, or QuerySet instance from which to get the list.

**kwargs

Lookup parameters, which should be in the format accepted by get() and filter().

Example

from django.shortcuts import get_list_or_404
def my_view(request):
    my_objects = get_list_or_404(MyModel, published=True)

This example is equivalent to:

from django.http import Http404
def my_view(request):
    my_objects = list(MyModel.objects.filter(published=True))
    if not my_objects:
        raise Http404("No MyModel matches the given query.")