django: почему RequestContext установлен как context_instance?

Question

Кажется, большая часть документации рекомендует:

template_values = {}
template_values["foo"] = "bar"
return render_to_response(path, template_values, context_instance=RequestContext(request)

Почему бы мне не использовать:

template_values = RequestContext(request)
template_values["foo"] = "bar"
return render_to_response(path, template_values)

Answer 1

Что касается «кода котельной плиты», он уже встроен в Django. Просто используйте общий вид:

from django.views.generic.simple import direct_to_template

def my_view(request):
    # Do stuff here...
    return direct_to_template(request, 'my_template.html', {'var1': 'value', etc..})

Answer 2

RequestContext не наследуется от dict, и поэтому не гарантируется реализация всех методов dict (и это не так), и любые функции, которые работают с dicts, могут не работать или. Наконец, нет никаких причин для; лучше считать это непрозрачным объектом, реализация которого может измениться. Использование dict для предоставления контекста шаблона имеет все преимущества и ни одного из недостатков RequestContext.

Обновление

Чтобы получить меньше стандартного кода, я использую две служебные функции. Я поместил их в файл shortcuts.py в основе моего проекта.

from django.template import RequestContext
def render_template(request, template, data=None):
    "Wrapper around render_to_response that fills in context_instance for you."
    response = render_to_response(template, data,
                              context_instance=RequestContext(request))
    return response

def boilerplate_render(template):
    "Factory function for creating simple views that only forward to a template"
    def view(request, **kwargs):
        response = render_template(request, template, kwargs)
        return response
    return view

Использование:

def my_view(request):
    # Do stuff here...
    return render_template(request, 'my_template.html', {'var1': 'value', etc..})

my_view2 = boilerplate_render('my_template2.html') # Takes no context parameters

Answer 3

Я только что нашел это решение здесь , и я изменил его просто немного:

def render_to(template_name):
    def renderer(func):
        def wrapper(request, *args, **kw):
            output = func(request, *args, **kw)
            if not isinstance(output, dict):
                return output
            return render_to_response(template_name, output,
                    context_instance=RequestContext(request))
        return wrapper
    return renderer

@render_to('my_template.html')
def my_view(request):
    # View code here...
    return some_dict

Answer 4

Некоторое время я бился головой о шаблон Джанго. Django имеет (как минимум) три очень похожие функции для рендеринга шаблонов, каждая с различной степенью краткости:

django.shortcuts.render_to_response
django.template.loader.render_to_string
django.views.generic.simple.direct_to_template

Похоже, что по крайней мере два из них (вероятно, render_to_response и direct_to_template) можно было бы реорганизовать в один, менее привычный ярлык.

django.views.generic.simple.direct_to_template почти достаточно хорош сам по себе, но, к сожалению, помещает аргументы ключевых слов в диктовку params, что делает его несовместимым с большинством случаев использования render_to_response (рефакторинг шаблона часто необходим при переключении с render_to_response на direct_to_template). render_to_response, который по иронии судьбы живет в django.shortcuts, вряд ли является хорошо продуманным ярлыком. Он должен преобразовывать аргументы ключевых слов в параметры шаблона, и этот неуклюжий context_instance аргумент слишком длинен для ввода ... часто.

Я попробовал более полезный ярлык. Обратите внимание на использование *request_and_template_and_params для предотвращения конфликтов между именами параметров шаблона и именами позиционных аргументов.

def render(*request_and_template_and_params, **kwargs):
    """Shortcut for rendering a template with RequestContext

    Takes two or three positional arguments: request, template_name, and
    optionally a mapping of template parameters. All keyword arguments,
    with the excepiton of 'mimetype' are added to the request context.

    Returns a HttpResponse object.
    """
    if len(request_and_template_and_params) == 2:
        request, template_name = request_and_template_and_params
        params = kwargs
    else:
        request, template_name, params = request_and_template_and_params
        params = dict(params) # copy because we mutate it
        params.update(kwargs)
    httpresponse_kwargs = {'mimetype': params.pop('mimetype', None)}
    context = RequestContext(request, params)
    return HttpResponse(loader.render_to_string(
        template_name, context_instance=context), **httpresponse_kwargs)

Answer 5

В дополнение к коду "Котельная плита", вы можете отобразить шаблон в вашем urls.py

Например:

url(r'^about/$', direct_to_template, {'template': 'about.html',}),