我可以从 Django 中的模板访问 settings.py 中的常量吗？

Question

我在 settings.py 中有一些东西，我希望能够从模板访问它们，但我不知道如何做到这一点。 我已经尝试过了

{{CONSTANT_NAME}}

，但这似乎不起作用。 这可能吗？

Answer 1

如果这是您希望每个请求都具有的值 模板，使用上下文处理器 更合适。

操作方法如下：

1. 在应用目录中创建一个 context_processors.py 文件。 假设我想在每个上下文中都有 ADMIN_PREFIX_VALUE 值：

   from django.conf import settings #导入设置文件 
   
     def admin_media（请求）： 
         # 以字典形式返回你想要的值。   您可以在其中添加多个值。 
         返回 {'ADMIN_MEDIA_URL': settings.ADMIN_MEDIA_PREFIX} 
     

2. 将上下文处理器添加到您的 settings.py 文件中：

   模板 = [{ 
         # 前面的内容 
         '选项'： { 
             '上下文处理器'：[ 
                 # 前面的内容 
                 “your_app.context_processors.admin_media”， 
             ], 
         } 
     }] 
     

3. 在视图中使用 RequestContext 在模板中添加上下文处理器。 render 快捷方式 可以执行此操作自动：

   from django.shortcuts import render 
   
     def my_view（请求）： 
         返回渲染（请求，“index.html”） 
     

4. 最后，在您的模板中：

   <前><代码>...
   管理媒体路径
   ...

Answer 2

我发现最简单的方法是单个 自定义模板标签：

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" %}

Answer 3

如果您使用 Django 内置的通用视图或在render_to_response 快捷函数。 以下是每种情况的示例：

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 等。

如果您正在寻找对设置中其他常量的访问，然后只需解压所需的常量并将它们添加到您在视图函数中使用的上下文字典中，如下所示：

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)

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

Answer 4

查看 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>

Answer 5

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

@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" %}

将其打印在任何页面上，而无需跳过上下文处理器。

Answer 6

我喜欢 Berislav 的解决方案，因为在简单的网站上，它干净有效。 我不喜欢的是随意暴露所有设置常量。 所以我最终做的是这样的：

from django import template
from django.conf import settings

register = template.Library()

ALLOWABLE_VALUES = ("CONSTANT_NAME_1", "CONSTANT_NAME_2",)

# settings value
@register.simple_tag
def settings_value(name):
    if name in ALLOWABLE_VALUES:
        return getattr(settings, name, '')
    return ''

用法：

{% settings_value "CONSTANT_NAME_1" %}

这可以保护您未命名的任何常量在模板中使用，如果您想要真正喜欢，您可以在设置中设置一个元组，并创建多个模板为不同的页面、应用程序或区域添加标签，只需根据需要将本地元组与设置元组组合起来，然后进行列表理解以查看该值是否可接受。
我同意，在一个复杂的网站上，这有点简单化，但是有些值在模板中通用会很好，而且这似乎工作得很好。
感谢贝里斯拉夫的原创想法！

Answer 7

使用 Django 2.0+ 添加包含创建自定义模板标记以解决此问题的完整说明的答案

在您的应用文件夹中，创建一个名为 templatetags 的文件夹。 在其中创建 __init__.py 和 custom_tags.py：

在custom_tags.py中创建自定义标签函数提供对 settings 常量中任意键的访问：

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" %}

此解决方案不适用于数组，但如果您需要，您可能会在模板中添加很多逻辑。

注意：更干净、更安全的解决方案可能是创建一个自定义上下文处理器，您可以在其中将所需的设置添加到所有模板可用的上下文中。 这样您就可以降低在模板中错误输出敏感设置的风险。

Answer 8

将此代码添加到名为 context_processors.py 的文件中：

from django.conf import settings as django_settings


def settings(request):
    return {
        'settings': django_settings,
    }

然后，在您的设置文件中包含一个路径，例如 'speedy.core.base.context_processors.settings' (与您的应用名称和路径）位于 TEMPLATES 的 'context_processors' 设置中。

（您可以查看例如 settings/base .py 和 context_processors。 py）。

然后您可以在任何模板代码中使用特定设置。 例如：

{% if settings.SITE_ID == settings.SPEEDY_MATCH_SITE_ID %}

更新：上面的代码将所有设置公开给模板，包括敏感信息，例如您的 SECRET_KEY。 黑客可能会滥用此功能在模板中显示此类信息。 如果您只想向模板公开特定设置，请改用以下代码：

def settings(request):
    settings_in_templates = {}
    for attr in ["SITE_ID", ...]: # Write here the settings you want to expose to the templates.
        if (hasattr(django_settings, attr)):
            settings_in_templates[attr] = getattr(django_settings, attr)
    return {
        'settings': settings_in_templates,
    }

Answer 9

我改进了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 块中使用变得很容易。

Answer 10

如果使用基于类的视图：

#
# 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 }}

Answer 11

上面来自 bchhun 的示例很好，只是您需要从 settings.py 显式构建上下文字典。 下面是一个未经测试的示例，说明如何从 settings.py 的所有大写属性自动构建上下文字典（回复：“^[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',
...
)

Answer 12

如果有人像我一样发现这个问题，那么我将发布适用于 Django 2.0 的解决方案：

此标记将一些 settings.py 变量值分配给模板的变量：

用法： {% get_settings_value template_var "SETTINGS_VAR" %}< /code>

app/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 %}
... do something ...
{% else %}
... do other stuff ...
{% endif %}

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

Answer 13

对于那些想要使用 @Berislav 的方法（自定义模板标签）和 if 标签的人：

/app/templatetags/my_settings.py：

from django import template
from django.conf import settings

register = template.Library()

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

模板文件：

<!-- Load your tags -->
{% load my_settings %}
{% settings_value 'ENABLE_FEATURE_A' as ENABLE_FEATURE_A %}

{% if ENABLE_FEATURE_A %}
<!-- Feature A stuffs -->
{% endif %}

Answer 14

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

1. views.py

   从 local_settings 导入 BASE_URL 
   
     def 根（请求）： 
         返回 render_to_response('hero.html', {'BASE_URL': BASE_URL}) 
     

2. hero.html

   var BASE_URL = '{{ JS_BASE_URL }}'; 
     

Answer 15

IanSR 和 bchhun 都建议覆盖设置中的 TEMPLATE_CONTEXT_PROCESSORS。 请注意，此设置有一个默认值，如果您在不重新设置默认值的情况下覆盖它，可能会导致一些奇怪的事情。 在 Django 的最新版本中，默认值也发生了变化。

https://docs.djangoproject.com/en/1.3/ ref/settings/#template-context-processors

默认的 TEMPLATE_CONTEXT_PROCESSORS ：

TEMPLATE_CONTEXT_PROCESSORS = ("django.contrib.auth.context_processors.auth",
"django.core.context_processors.debug",
"django.core.context_processors.i18n",
"django.core.context_processors.media",
"django.core.context_processors.static",
"django.contrib.messages.context_processors.messages")

Answer 16

如果我们要在单个变量上比较上下文与模板标签，那么了解更有效的选项可能是有益的。 但是，您可能最好仅从需要该变量的模板中深入了解设置。 在这种情况下，将变量传递到所有模板中是没有意义的。 但是，如果您将变量发送到通用模板（例如 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)

Answer 17

更完整的实施。

/project/settings.py

APP_NAME = 'APP'

/app/templatetags/settings_value.py

from django import template
from django.conf import settings
 
register = template.Library()
 
@register.simple_tag
def settings_value(name):
    return getattr(settings, name, "")

/app/templates/index.html

<!DOCTYPE html>
{% load static %}
{% load settings_value %}
<head>
    <title>{% settings_value "APP_NAME" %}</title>
...