django-templates settings.py配置 - 我可以通过Django中的模板访问settings.py中的常量吗?




render (13)

我在settings.py中有一些我希望能够从模板访问的东西,但我无法弄清楚如何去做。 我已经尝试过了

{{CONSTANT_NAME}}

但这似乎并不奏效。 这可能吗?


Answers

用Django 2.0添加一个答案和完整的说明来创建一个可以解决这个问题的自定义模板标签

在您的应用程序文件夹中,创建一个名为templatetags的文件夹。 在它中,创建__init__.pycustom_tags.py

custom_tags.py中创建一个自定义标记函数,该函数提供对设置常量中的任意键的访问:

from django import template
from django.conf import settings

register = template.Library()

@register.simple_tag
def get_setting(name):
    return getattr(settings, name, "")

为了理解这段代码,我推荐阅读Django文档中关于简单标签的章节

然后,您需要通过将此文件加载到您将使用它的任何模板中,让Django知道此(以及任何其他)自定义标记。 就像你需要加载内置的静态标签一样:

{% load custom_tags %}

加载它可以像使用其他标签一样使用,只需提供您需要返回的特定设置即可。 所以,如果你的设置中有一个BUILD_VERSION变量:

{% get_setting "BUILD_VERSION" %}

这个解决方案不适用于数组,但是如果你需要的话,你可能会在你的模板中放置很多逻辑。


另一种方法是创建一个自定义模板标签,它可以让您从设置中获取值。

@register.tag
def value_from_settings(parser, token):
    try:
        # split_contents() knows not to split quoted strings.
        tag_name, var = token.split_contents()
    except ValueError:
        raise template.TemplateSyntaxError, "%r tag requires a single argument" % token.contents.split()[0]
    return ValueFromSettings(var)

class ValueFromSettings(template.Node):
    def __init__(self, var):
        self.arg = template.Variable(var)
    def render(self, context):        
        return settings.__getattr__(str(self.arg))

然后你可以使用:

{% value_from_settings "FQDN" %}

可以在任何页面上打印,而无需跳过上下文处理器环节。


退房django-settings-export (免责声明:我是这个项目的作者)。

例如...

$ pip install django-settings-export

settings.py

TEMPLATES = [
    {
        'OPTIONS': {
            'context_processors': [
                'django_settings_export.settings_export',
            ],
        },
    },
]

MY_CHEESE = 'Camembert';

SETTINGS_EXPORT = [
    'MY_CHEESE',
]

template.html

<script>var MY_CHEESE = '{{ settings.MY_CHEESE }}';</script>

如果您使用django的内置通用视图或在render_to_response快捷方式函数中传递上下文实例关键字参数,Django可以访问模板的某些常用设置常量,例如settings.MEDIA_URL和一些语言设置。 以下是每种情况的示例:

from django.shortcuts import render_to_response
from django.template import RequestContext
from django.views.generic.simple import direct_to_template

def my_generic_view(request, template='my_template.html'):
    return direct_to_template(request, template)

def more_custom_view(request, template='my_template.html'):
    return render_to_response(template, {}, context_instance=RequestContext(request))

这些视图都会有几个经常使用的设置,例如settings.MEDIA_URL可以作为{{ MEDIA_URL }}等模板使用。

如果你正在寻找访问设置中的其他常量,那么简单地解压你想要的常量,并将它们添加到你在视图函数中使用的上下文字典中,如下所示:

from django.conf import settings
from django.shortcuts import render_to_response

def my_view_function(request, template='my_template.html'):
    context = {'favorite_color': settings.FAVORITE_COLOR}
    return render_to_response(template, context)

现在,您可以在模板上以{{ favorite_color }}访问settings.FAVORITE_COLOR


如果这是您想要的每个请求和模板的值,则使用上下文处理器更合适。

就是这样:

  1. 在您的应用程序目录中创建一个context_processors.py文件。 假设我想在每个上下文中具有ADMIN_PREFIX_VALUE值:

    from django.conf import settings # import the settings file
    
    def admin_media(request):
        # return the value you want as a dictionnary. you may add multiple values in there.
        return {'ADMIN_MEDIA_URL': settings.ADMIN_MEDIA_PREFIX}
    
  2. 将你的上下文处理器添加到你的settings.py文件中:

    TEMPLATES = [{
        # whatever comes before
        'OPTIONS': {
            'context_processors': [
                # whatever comes before
                "your_app.context_processors.admin_media",
            ],
        }
    }]
    
  3. 在您的视图中使用RequestContext将您的上下文处理器添加到您的模板中。 render快捷方式自动执行此操作:

    from django.shortcuts import render
    
    def my_view(request):
        return render(request, "index.html")
    
  4. 最后,在你的模板中:

    ...
    <a href="{{ ADMIN_MEDIA_URL }}">path to admin media</a>
    ...
    

如果有人像我这样发现了这个问题,那么我会发布我的解决方案,它在Django 2.0上工作:

这个标签将一些settings.py变量赋值给模板的变量:

用法: {% get_settings_value template_var "SETTINGS_VAR" %}

应用程序/ templatetags / my_custom_tags.py:

from django import template
from django.conf import settings

register = template.Library()

class AssignNode(template.Node):
    def __init__(self, name, value):
        self.name = name
        self.value = value

    def render(self, context):
        context[self.name] = getattr(settings, self.value.resolve(context, True), "")
        return ''

@register.tag('get_settings_value')
def do_assign(parser, token):
    bits = token.split_contents()
    if len(bits) != 3:
        raise template.TemplateSyntaxError("'%s' tag takes two arguments" % bits[0])
    value = parser.compile_filter(bits[2])
    return AssignNode(bits[1], value)

您的模板:

{% load my_custom_tags %}

# Set local template variable:
{% get_settings_value settings_debug "DEBUG" %}

# Output settings_debug variable:
{{ settings_debug }}

# Use variable in if statement:
{% if settings_debug == True %}
... do something ...
{% else %}
... do other stuff ...
{% endif %}

请参阅Django的文档,了解如何在此创建自定义模板标记: https://docs.djangoproject.com/en/2.0/howto/custom-template-tags/https://docs.djangoproject.com/en/2.0/howto/custom-template-tags/


我发现最简单的方法是单个模板标签:

from django import template
from django.conf import settings

register = template.Library()

# settings value
@register.simple_tag
def settings_value(name):
    return getattr(settings, name, "")

用法:

{% settings_value "LANGUAGE_CODE" %}

我改进了一下chrisdew的答案 (创建你自己的标签)。

首先,创建文件yourapp/templatetags/value_from_settings.py ,您可以在其中定义自己的新标记value_from_settings

from django.template import TemplateSyntaxError, Variable, Node, Variable, Library
from yourapp import settings

register = Library()
# I found some tricks in URLNode and url from defaulttags.py:
# https://code.djangoproject.com/browser/django/trunk/django/template/defaulttags.py
@register.tag
def value_from_settings(parser, token):
  bits = token.split_contents()
  if len(bits) < 2:
    raise TemplateSyntaxError("'%s' takes at least one " \
      "argument (settings constant to retrieve)" % bits[0])
  settingsvar = bits[1]
  settingsvar = settingsvar[1:-1] if settingsvar[0] == '"' else settingsvar
  asvar = None
  bits = bits[2:]
  if len(bits) >= 2 and bits[-2] == 'as':
    asvar = bits[-1]
    bits = bits[:-2]
  if len(bits):
    raise TemplateSyntaxError("'value_from_settings' didn't recognise " \
      "the arguments '%s'" % ", ".join(bits))
  return ValueFromSettings(settingsvar, asvar)

class ValueFromSettings(Node):
  def __init__(self, settingsvar, asvar):
    self.arg = Variable(settingsvar)
    self.asvar = asvar
  def render(self, context):
    ret_val = getattr(settings,str(self.arg))
    if self.asvar:
      context[self.asvar] = ret_val
      return ''
    else:
      return ret_val

您可以通过以下方式在模板中使用此标记:

{% load value_from_settings %}
[...]
{% value_from_settings "FQDN" %}

或通过

{% load value_from_settings %}
[...]
{% value_from_settings "FQDN" as my_fqdn %}

as ...符号的优点是,这使得通过简单的{{my_fqdn}}可以轻松地在blocktrans块中使用。


如果使用基于类的视图:

#
# in settings.py
#
YOUR_CUSTOM_SETTING = 'some value'

#
# in views.py
#
from django.conf import settings #for getting settings vars

class YourView(DetailView): #assuming DetailView; whatever though

    # ...

    def get_context_data(self, **kwargs):

        context = super(YourView, self).get_context_data(**kwargs)
        context['YOUR_CUSTOM_SETTING'] = settings.YOUR_CUSTOM_SETTING

        return context

#
# in your_template.html, reference the setting like any other context variable
#
{{ YOUR_CUSTOM_SETTING }}

如果我们要在单个变量上比较上下文和模板标签,那么知道更高效的选项可能是非常有效的。 但是,您最好只能从需要该变量的模板中进入设置。 在这种情况下,将变量传递到所有模板是没有意义的。 但是,如果您要将变量发送到通用模板(如base.html模板),那么无需考虑base.html模板在每个请求上的呈现方式,因此您可以使用任一种方法。

如果您决定使用模板标签选项,那么请使用以下代码,因为它允许您传递默认值,以防变量问题未定义。

例如:get_from_settings my_variable as my_context_value

示例:get_from_settings my_variable my_default as my_context_value

class SettingsAttrNode(Node):
    def __init__(self, variable, default, as_value):
        self.variable = getattr(settings, variable, default)
        self.cxtname = as_value

    def render(self, context):
        context[self.cxtname] = self.variable
        return ''


def get_from_setting(parser, token):
    as_value = variable = default = ''
    bits = token.contents.split()
    if len(bits) == 4 and bits[2] == 'as':
        variable = bits[1]
        as_value = bits[3]
    elif len(bits) == 5 and bits[3] == 'as':
        variable     = bits[1]
        default  = bits[2]
        as_value = bits[4]
    else:
        raise TemplateSyntaxError, "usage: get_from_settings variable default as value " \
                "OR: get_from_settings variable as value"

    return SettingsAttrNode(variable=variable, default=default, as_value=as_value)

get_from_setting = register.tag(get_from_setting)

从bchhun上面的例子很好,除了你需要显式地从settings.py构建你的上下文字典。 下面是一个UNTESTED示例,说明如何从settings.py的所有大写属性自动构建上下文词典(re:“^ [A-Z0-9 _] + $”)。

在settings.py结尾处:

_context = {} 
local_context = locals()
for (k,v) in local_context.items():
    if re.search('^[A-Z0-9_]+$',k):
        _context[k] = str(v)

def settings_context(context):
    return _context

TEMPLATE_CONTEXT_PROCESSORS = (
...
'myproject.settings.settings_context',
...
)

我发现这是Django 1.3最简单的方法:

  1. views.py

    from local_settings import BASE_URL
    
    def root(request):
        return render_to_response('hero.html', {'BASE_URL': BASE_URL})
    
  2. hero.html

    var BASE_URL = '{{ JS_BASE_URL }}';
    

您需要事先准备好数据,在这种情况下,您应该将两元组列表传递给模板:

{% for product, rating in product_list %}
    <h1>{{ product.name }}</h1><p>{{ rating }}</p>
{% endfor %}




django django-templates django-settings