这篇文档从技术角度解释了 Django 模板系统——它是如何工作的以及如何扩展它。如果你想找语言语法的参考，请看 Django 模板语言。
\n它的前提是对模板、上下文、变量、标签和渲染的理解。如果你不熟悉这些概念，可以从 Django 模板语言介绍 开始。
\n在 Python 中使用模板系统是一个三步走的过程：
\n\nDjango 项目一般依靠 高级、后端不可知的 API 来完成每一个步骤，而不是模板系统的低级 API。
\n对于 TEMPLATES 设置中的每一个 DjangoTemplates 后端，Django 都会实例化一个 Engine。 DjangoTemplates 封装 Engine 并将其适配到通用的模板后端 API 中。
django.template.loader 模块提供了 get_template() 等函数来加载模板。它们返回一个 django.template.backends.django.Template，它封装了实际的 django.template。
上一步得到的 Template 有一个 render() 方法，它将一个上下文和可能的请求汇集到一个 Context 中，并委托底层的 Template 进行渲染。
如果你使用的是 DjangoTemplates 后端，这可能不是你要找的文档。下面描述的 Engine 类的实例可以通过该后端的 engine 属性来访问，下面提到的任何属性默认值都会被 DjangoTemplates 传递的内容所覆盖。
当实例化一个 Engine 时，所有的参数都必须作为关键字参数传递。
dirs 是引擎应该寻找模板源文件的目录列表。它用于配置 filesystem.Loader。
默认为空列表。
\napp_dirs 只影响 loaders 的默认值。见下文。
默认为 False。
autoescape 控制是否启用 HTML 自动转码。
默认为 True。
context_processors 是一个点分隔 Python 路径的列表，当一个模板被请求渲染时，这些可调用对象被用来填充上下文。这些可调用对象以一个请求对象作为参数，并返回一个 dict 的项目，这些项目将被合并到上下文中。
默认为空列表。
\n查看 RequestContext 获取更多信息。
debug 是一个开启／关闭模板调试模式的布尔值。如果它为 True，模板引擎将存储额外的调试信息，这些信息可用于显示模板渲染过程中出现的任何异常的详细报告。
默认为 False。
loaders 是一个模板加载器类的列表，以字符串形式指定。每个 Loader 类都知道如何从特定来源导入模板。可以选择使用元组来代替字符串。元组中的第一项应该是 Loader 类名，随后的项目在初始化时传递给 Loader。
它默认为包含以下内容的列表：
\n'django.template.loaders.filesystem.Loader'
'django.template.loaders.app_directories.Loader' 如果且仅当 app_dirs 为 True 时。
然后，这些加载器会被包装在 django.template.loaders.cached.Loader 中。
查看 加载器类型 获取详细信息。
\nstring_if_invalid 是模板系统对无效变量（如拼写错误）应使用的字符串输出。
默认为空字符串。
\n查看 如何处理无效变量 获取更多信息。
\nfile_charset 是用来读取磁盘上模板文件的字符集。
默认为 'utf-8'。
'libraries'：模板标签模块的标签和点分隔 Python 路径字典，用于向模板引擎注册。它用于添加新库或为现有库提供替代标签。例如：
Engine(\n libraries={\n "myapp_tags": "path.to.myapp.tags",\n "admin.urls": "django.contrib.admin.templatetags.admin_urls",\n },\n)\n可以通过将相应的字典键传递到 {% load %} 标签来加载库。
'builtins'：要添加的 内置模板标签和过滤器 的点分隔 Python 路径列表。例如：
Engine(\n builtins=["myapp.builtins"],\n)\n可以使用内置库中的标签和过滤器，而不需要先调用 {% load %} 标签。
从第一个配置的 DjangoTemplates 引擎中返回底层 Engine。如果没有配置引擎，则引发 ImproperlyConfigured。
这是为保存依赖于全局可用、隐式配置引擎的 API 所必需的。任何其他用途都是不鼓励的。
\n编译给定的模板代码并返回一个 Template 对象。
加载给定名称的模板，编译后返回一个 Template 对象。
就像 get_template() 一样，只不过它接收一个名称列表，并返回找到的第一个模板。
推荐的创建 Template 的方法是调用 Engine 的工厂方法： get_template()、 select_template() 和 from_string()。
在 Django 项目中，如果 TEMPLATES 设置定义了一个 DjangoTemplates 引擎，那么可以直接实例化一个 Template。如果定义了多个 DjangoTemplates 引擎，则使用第一个引擎。
这个类位于 django.template.Template。构造函数需要一个参数——原始模板代码：
from django.template import Template\n\ntemplate = Template("My name is {{ my_name }}.")\n一旦你有一个编译过的 Template 对象，你就可以用它来渲染一个上下文。你可以重复使用同一个模板，在不同的上下文中多次渲染它。
django.template.Context 的构造函数需要一个可选的参数——一个将变量名映射到变量值的字典。
还可以指定三个可选的关键字参数：
\nautoescape 控制是否启用 HTML 自动转码。
默认为 True。
use_l10n 覆盖值是否默认本地化。如果设置为 True，数字和日期将根据区域设置格式化。
它默认为 None。
有关详细信息，请参阅 在模板中控制本地化。
\nuse_tz 覆盖日期在模板中渲染时是否转换为本地时间。如果设置为 True，所有日期将使用本地时区渲染。这优先于 USE_TZ。
它默认为 None。
有关详细信息，请参阅 模板中的有时区输出。
\n例如用法，请参阅下面的 使用 Context 对象。
\n使用一个 Context 调用 Template 对象的 render() 方法来"填充"模板：
>>> from django.template import Context, Template\n>>> template = Template("My name is {{ my_name }}.")\n\n>>> context = Context({"my_name": "Adrian"})\n>>> template.render(context)\n"My name is Adrian."\n\n>>> context = Context({"my_name": "Dolores"})\n>>> template.render(context)\n"My name is Dolores."\n变量名称必须由任何字母（A-Z）、任何数字（0-9）、下划线（但不得以下划线开头）或点组成。
\n点在模板渲染中具有特殊的意义。变量名中的点表示 查找。具体来说，当模板系统遇到变量名中的点时，它将按照以下顺序尝试进行查找：
\n词典查找。例如：foo["bar"]
属性查找。例如：foo.bar
列表索引查找。例如：foo[bar]
请注意，像 {{ foo.bar }} 这样的模板表达式中的“bar”将被解释为一个字面字符串，而不是使用变量“bar”的值，如果模板上下文中存在的话。
模板系统使用第一个有效的查找类型。它是短路逻辑。以下是一些示例：
\n>>> from django.template import Context, Template\n>>> t = Template("My name is {{ person.first_name }}.")\n>>> d = {"person": {"first_name": "Joe", "last_name": "Johnson"}}\n>>> t.render(Context(d))\n"My name is Joe."\n\n>>> class PersonClass:\n... pass\n...\n>>> p = PersonClass()\n>>> p.first_name = "Ron"\n>>> p.last_name = "Nasty"\n>>> t.render(Context({"person": p}))\n"My name is Ron."\n\n>>> t = Template("The first stooge in the list is {{ stooges.0 }}.")\n>>> c = Context({"stooges": ["Larry", "Curly", "Moe"]})\n>>> t.render(c)\n"The first stooge in the list is Larry."\n如果变量的任何部分都是可调用的，模板系统将尝试调用它。例如：
\n>>> class PersonClass2:\n... def name(self):\n... return "Samantha"\n...\n>>> t = Template("My name is {{ person.name }}.")\n>>> t.render(Context({"person": PersonClass2}))\n"My name is Samantha."\n可调用对象的变量比只需要直接查找的变量要复杂一些。下面是一些需要注意的事项：
\n如果在调用变量时引发异常，除非异常具有一个名为 silent_variable_failure 的属性且其值为 True，否则异常将被传播。如果异常确实具有值为 True 的 silent_variable_failure 属性，则变量将呈现为引擎的 string_if_invalid 配置选项的值（默认为空字符串）。例如：
>>> t = Template("My name is {{ person.first_name }}.")\n>>> class PersonClass3:\n... def first_name(self):\n... raise AssertionError("foo")\n...\n>>> p = PersonClass3()\n>>> t.render(Context({"person": p}))\nTraceback (most recent call last):\n...\nAssertionError: foo\n\n>>> class SilentAssertionError(Exception):\n... silent_variable_failure = True\n...\n>>> class PersonClass4:\n... def first_name(self):\n... raise SilentAssertionError\n...\n>>> p = PersonClass4()\n>>> t.render(Context({"person": p}))\n"My name is ."\n请注意 django.core.exceptions.ObjectDoesNotExist 是所有 Django 数据库 API DoesNotExist 异常的基类，有 silent_variable_failure = True。所以如果你使用 Django 模板与 Django 模型对象，任何 DoesNotExist 异常都会静默失败。
一个变量只有在没有所需参数的情况下才可以被调用，否则，系统将返回引擎的 string_if_invalid 选项的值。否则，系统将返回引擎的 string_if_invalid 选项的值。
在调用一些变量的时候可能会有副作用，如果让模板系统访问这些变量，要么是傻瓜，要么是安全漏洞。
\n一个很好的例子是每个 Django 模型对象上的 delete() 方法。模板系统不应该允许执行这样的操作：
I will now delete this valuable data. {{ data.delete }}\nTo prevent this, set an alters_data attribute on the callable\nvariable. The template system won't call a variable if it has\nalters_data=True set, and will instead replace the variable with\nstring_if_invalid, unconditionally. The\ndynamically-generated delete() and\nsave() methods on Django model objects get\nalters_data=True automatically. Example:
def sensitive_function(self):\n self.database_record.delete()\n\n\nsensitive_function.alters_data = True\nOccasionally you may want to turn off this feature for other reasons,\nand tell the template system to leave a variable uncalled no matter\nwhat. To do so, set a do_not_call_in_templates attribute on the\ncallable with the value True. The template system then will act as\nif your variable is not callable (allowing you to access attributes of\nthe callable, for example).
一般来说，如果一个变量不存在，模板系统会插入引擎的 string_if_invalid 配置选项的值，默认设置为 '' （空字符串）。
只有当 string_if_invalid 被设置为 '' （空字符串）时，才会对无效变量应用过滤器。如果 string_if_invalid 被设置为任何其他值，变量过滤器将被忽略。
对于 if、for 和 regroup 模板标签，这种行为略有不同。如果向这些模板标签之一提供了一个无效的变量，该变量将被解释为 None。过滤器总是应用于这些模板标签中的无效变量。
如果 string_if_invalid 包含 '%s'，格式标记将被替换为无效变量的名称。
每个上下文都包含 True、False 和 None。正如你所期望的那样，这些变量解析为相应的 Python 对象。
Django 的模板语言没有办法转义用于自己语法的字符。例如，如果你需要输出像 {% 和 %} 这样的字符序列，就需要使用 templatetag 标签。
如果您想在模板过滤器或标签参数中包含这些序列，也会存在类似的问题。例如，在解析块标签时，Django 的模板解析器会查找在 {% 之后第一次出现的 %}。这会阻止使用 "%}" 作为字符串文字。例如，以下表达式将引发 TemplateSyntaxError：
{% include "template.html" tvar="Some string literal with %} in it." %}\n\n{% with tvar="Some string literal with %} in it." %}{% endwith %}\n在过滤器参数中使用保留序列也可能触发相同的问题：
\n{{ some.variable|default:"}}" }}\n如果你需要使用这些序列的字符串，请将它们存储在模板变量中，或者使用自定义模板标签或过滤器来解决这个限制。
\nContext 对象Link to this heading#大多数情况下，您将通过将完全填充的字典传递给 Context() 来实例化 Context 对象。但是，一旦实例化了 Context 对象，您也可以使用标准字典语法向其中添加和删除项目：
>>> from django.template import Context\n>>> c = Context({"foo": "bar"})\n>>> c["foo"]\n'bar'\n>>> del c["foo"]\n>>> c["foo"]\nTraceback (most recent call last):\n...\nKeyError: 'foo'\n>>> c["newvariable"] = "hello"\n>>> c["newvariable"]\n'hello'\n如果 key 在上下文中，返回 key 的值，否则返回 otherwise。
如果 key 在上下文中，则返回其值。否则用 default 值插入 key 并返回 default。
Context 对象是一个堆栈。也就是说，您可以对其进行 push() 和 pop() 操作。如果您进行了过多的 pop() 操作，它会引发 django.template.ContextPopException 异常：
>>> c = Context()\n>>> c["foo"] = "first level"\n>>> c.push()\n{}\n>>> c["foo"] = "second level"\n>>> c["foo"]\n'second level'\n>>> c.pop()\n{'foo': 'second level'}\n>>> c["foo"]\n'first level'\n>>> c["foo"] = "overwritten"\n>>> c["foo"]\n'overwritten'\n>>> c.pop()\nTraceback (most recent call last):\n...\nContextPopException\n你也可以使用 push() 作为上下文管理器，以确保匹配的 pop() 被调用。
>>> c = Context()\n>>> c["foo"] = "first level"\n>>> with c.push():\n... c["foo"] = "second level"\n... c["foo"]\n...\n'second level'\n>>> c["foo"]\n'first level'\n传递给 push() 的所有参数都将传递给 dict 构造函数，用于建立新的上下文层次。
>>> c = Context()\n>>> c["foo"] = "first level"\n>>> with c.push(foo="second level"):\n... c["foo"]\n...\n'second level'\n>>> c["foo"]\n'first level'\n除了 push() 和 pop() 之外，Context 对象还定义了一个 update() 方法。它的工作原理与 push() 类似，但它接受一个字典作为参数，并将该字典推到栈上，而不是空的。
>>> c = Context()\n>>> c["foo"] = "first level"\n>>> c.update({"foo": "updated"})\n{'foo': 'updated'}\n>>> c["foo"]\n'updated'\n>>> c.pop()\n{'foo': 'updated'}\n>>> c["foo"]\n'first level'\n像 push() 一样，你可以使用 update() 作为上下文管理器，以确保调用匹配的 pop()。
>>> c = Context()\n>>> c["foo"] = "first level"\n>>> with c.update({"foo": "second level"}):\n... c["foo"]\n...\n'second level'\n>>> c["foo"]\n'first level'\n在 一些自定义模板标签 中，使用 Context 作为栈是很方便的。
使用 flatten() 方法，你可以得到整个 Context 堆栈作为一个字典，包括内置的变量。
>>> c = Context()\n>>> c["foo"] = "first level"\n>>> c.update({"bar": "second level"})\n{'bar': 'second level'}\n>>> c.flatten()\n{'True': True, 'None': None, 'foo': 'first level', 'False': False, 'bar': 'second level'}\n内部还使用 flatten() 方法使 Context 对象具有可比性。
>>> c1 = Context()\n>>> c1["foo"] = "first level"\n>>> c1["bar"] = "second level"\n>>> c2 = Context()\n>>> c2.update({"bar": "second level", "foo": "first level"})\n{'foo': 'first level', 'bar': 'second level'}\n>>> c1 == c2\nTrue\nflatten() 的结果在单元测试中可以用来比较 Context 和 dict：
class ContextTest(unittest.TestCase):\n def test_against_dictionary(self):\n c1 = Context()\n c1["update"] = "value"\n self.assertEqual(\n c1.flatten(),\n {\n "True": True,\n "None": None,\n "False": False,\n "update": "value",\n },\n )\nRequestContextLink to this heading#Django 附带了一个特殊的 Context 类，django.template.RequestContext，它的行为与普通的 django.template.Context 略有不同。第一个区别是它接受一个 HttpRequest 作为其第一个参数。例如：
c = RequestContext(\n request,\n {\n "foo": "bar",\n },\n)\n第二个区别是，它根据引擎的 context_processors 配置选项，自动给上下文填充一些变量。
context_processors 选项是一个可调用的列表——称为 上下文处理器——它将一个请求对象作为参数，并返回一个要合并到上下文中的项目字典。在默认生成的配置文件中，默认模板引擎包含以下上下文处理器：
[\n "django.template.context_processors.request",\n "django.contrib.auth.context_processors.auth",\n "django.contrib.messages.context_processors.messages",\n]\nIn addition to these, RequestContext always enables\n'django.template.context_processors.csrf'. This is a security related\ncontext processor required by the admin and other contrib apps, and, in case\nof accidental misconfiguration, it is deliberately hardcoded in and cannot be\nturned off in the context_processors option.
每个处理器都是按顺序应用的。这意味着，如果一个处理器向上下文添加了一个变量，而第二个处理器添加了一个同名的变量，第二个处理器将覆盖第一个处理器。下面解释默认的处理器。
\n\n此外，你还可以使用可选的第三个位置参数 processors，给 RequestContext 一个额外的处理器列表。在这个例子中， RequestContext 实例得到一个 ip_address 变量：
from django.http import HttpResponse\nfrom django.template import RequestContext, Template\n\n\ndef ip_address_processor(request):\n return {"ip_address": request.META["REMOTE_ADDR"]}\n\n\ndef client_ip_view(request):\n template = Template("{{ title }}: {{ ip_address }}")\n context = RequestContext(\n request,\n {\n "title": "Your IP Address",\n },\n [ip_address_processor],\n )\n return HttpResponse(template.render(context))\n下面是每个内置处理器的作用：
\ndjango.contrib.auth.context_processors.authLink to this heading#如果启用了这个处理器，每一个 RequestContext 都会包含这些变量：
user —— 代表当前登录用户的 auth.User 实例（如果客户端没有登录，则为 AnonymousUser 实例）。
perms —— django.contrib.uth.context_processors.PermWrapper 的实例，表示当前登录用户拥有的权限。
django.template.context_processors.debugLink to this heading#如果启用了这个处理器，每一个 RequestContext 都会包含这两个变量——但前提是你的 DEBUG 设置为 True，并且请求的 IP 地址（request.META['REMOTE_ADDR']）在 INTERNAL_IPS 配置中：
debug —— True。你可以在模板中使用它来测试你是否处于 DEBUG 模式。
sql_queries —— {'sql': ..., 'time': ...} 字典的列表，表示在请求过程中迄今为止发生的每一个 SQL 查询，以及花费的时间。这个列表是按照数据库别名，然后按照查询的顺序排列的。它是在访问时惰性生成的。
django.template.context_processors.i18nLink to this heading#如果启用了这个处理器，每一个 RequestContext 都会包含这些变量：
LANGUAGES —— LANGUAGES 配置值。
LANGUAGE_BIDI —— True 如果当前语言是从右到左的语言，如希伯来语、阿拉伯语。False 如果是从左到右的语言，如英语、法语、德语。
LANGUAGE_CODE —— request.LANGUAGE_CODE，如果存在的话。否则，使用 LANGUAGE_CODE 配置的值。
请参阅 i18n 模板标签，了解产生相同值的模板标签。
\ndjango.template.context_processors.mediaLink to this heading#如果启用了这个处理器，每一个 RequestContext 都会包含一个变量 MEDIA_URL，提供 MEDIA_URL 配置的值。
django.template.context_processors.staticLink to this heading#如果启用了这个处理器，每个 RequestContext 都会包含一个变量 STATIC_URL，提供 STATIC_URL 配置的值。
django.template.context_processors.csrfLink to this heading#该处理器添加了 csrf_token 模板标签所需的令牌，以防止 跨站点伪造请求。
This is always enabled by RequestContext and cannot\nbe disabled. You do not need to include it within context_processors.
django.template.context_processors.cspLink to this heading#If this processor is enabled, every RequestContext will contain a variable\ncsp_nonce, providing a securely generated, request-specific nonce suitable\nfor use under a Content Security Policy. See CSP nonce usage\nfor details.
django.template.context_processors.requestLink to this heading#如果启用了这个处理器，每个 RequestContext 都会包含一个变量 request，就是当前的 HttpRequest。
django.template.context_processors.tzLink to this heading#如果启用了这个处理器，每个 RequestContext 将包含一个变量 TIME_ZONE，提供当前活动时区的名称。
django.contrib.messages.context_processors.messagesLink to this heading#如果启用了这个处理器，每一个 RequestContext 都会包含这两个变量：
上下文处理器具有简单的接口：它是一个 Python 函数，接受一个参数，即 HttpRequest 对象，并返回一个添加到模板上下文的字典。
例如，要将 DEFAULT_FROM_EMAIL 设置添加到每个上下文中：
from django.conf import settings\n\n\ndef from_email(request):\n return {\n "DEFAULT_FROM_EMAIL": settings.DEFAULT_FROM_EMAIL,\n }\n自定义上下文处理器可以存在于你的代码库中的任何地方。Django 只关心你的自定义上下文处理器是否被你的 TEMPLATES 配置中的 'context_processors' 选项所指向，如果你直接使用的话，则是 Engine 的 context_processors 参数。
一般来说，你会把模板存储在文件系统的文件中，而不是自己使用低级的 template API。将模板保存在指定的 template 目录 中。
Django 会在很多地方搜索模板目录，这取决于你的模板加载设置（见下面的“加载器类型”），但最基本的指定模板目录的方法是使用 DIRS 选项。
DIRS 选项Link to this heading#通过使用配置文件中的 TEMPLATES 配置中的 DIRS 选项来告诉 Django 你的模板目录是什么，或者使用 Engine 中的 dirs 参数。这应该被设置为一个字符串列表，其中包含你的模板目录的完整路径：
TEMPLATES = [\n {\n "BACKEND": "django.template.backends.django.DjangoTemplates",\n "DIRS": [\n "/home/html/templates/lawrence.com",\n "/home/html/templates/default",\n ],\n },\n]\n您的模板可以放在任何地方，只要目录和模板对于 Web 服务器是可读的。它们可以具有任何您想要的扩展名，例如 .html 或 .txt，或者甚至可以没有扩展名。
请注意，这些路径应该使用 Unix 风格的斜线，即使在 Windows 上也是如此。
\n默认情况下，Django 使用的是基于文件系统的模板加载器，但 Django 自带了一些其他的模板加载器，它们知道如何从其他来源加载模板。
\n其他一些加载器默认是禁用的，但是你可以通过在 TEMPLATES 配置中为你的 DjangoTemplates 后端添加一个 'loaders' 选项来激活它们，或者向 Engine 传递一个 loaders 参数。loaders 应该是一个字符串或元组的列表，每个元组代表一个模板加载器类。下面是 Django 自带的模板加载器。
django.template.loaders.filesystem.Loader
根据 DIRS 从文件系统加载模板。
这个加载器默认是启用的。然而，它不会找到任何模板，直到你将 DIRS 设置为非空列表：
TEMPLATES = [\n {\n "BACKEND": "django.template.backends.django.DjangoTemplates",\n "DIRS": [BASE_DIR / "templates"],\n }\n]\n你也可以覆盖 'DIRS'，为特定的文件系统加载器指定特定的目录：
TEMPLATES = [\n {\n "BACKEND": "django.template.backends.django.DjangoTemplates",\n "OPTIONS": {\n "loaders": [\n (\n "django.template.loaders.filesystem.Loader",\n [BASE_DIR / "templates"],\n ),\n ],\n },\n }\n]\ndjango.template.loaders.app_directories.Loader
从文件系统中加载 Django 应用的模板。对于 INSTALLED_APPS 中的每个应用，加载器会寻找一个 templates 子目录。如果该目录存在，Django 就会在其中寻找模板。
这意味着你可以将模板与你的各个应用一起存储。这也有助于分发带有默认模板的 Django 应用。
\n例如，对于这个配置：
\nINSTALLED_APPS = ["myproject.polls", "myproject.music"]\n...然后 get_template('foo.html') 将在这些目录中按这个顺序查找 foo.html：
/path/to/myproject/polls/templates/
/path/to/myproject/music/templates/
...会用它最先找到的那个：
\nINSTALLED_APPS 的顺序很重要！例如，如果你想自定义 Django 管理，你可能会选择覆盖标准 django.contrib.admin 的 admin/base_site.html 模板，，用你自己 myproject.polls 中的 admin/base_site.html。然后你必须确保你的 myproject.polls 在 INSTALLED_APPS 中在 django.contrib.admin 之前，否则 django.contrib.admin 的会先被加载，你的会被忽略。
请注意，加载器在第一次运行时进行了优化：它缓存了一个列表，显示哪些 INSTALLED_APPS 包有一个 templates 子目录。
你可以通过设置 APP_DIRS 为 True 来启用该加载器：
TEMPLATES = [\n {\n "BACKEND": "django.template.backends.django.DjangoTemplates",\n "APP_DIRS": True,\n }\n]\ndjango.template.loaders.cached.Loader
虽然 Django 的模板系统非常快，但如果它每次渲染模板时都需要读取和编译模板，那么由此产生的开销可能会累积起来。
\n你可以用其他加载器的列表来配置缓存的模板加载器，它应该对这些加载器进行封装。当第一次遇到未知模板时，封装的加载器被用来定位它们。然后，缓存加载器将编译后的 Template 存储在内存中。缓存的 Template 实例会被返回，供后续加载同一模板的请求使用。
如果未指定 OPTIONS['loaders']，则会自动启用此加载程序。
您可以使用以下设置手动指定一些自定义模板加载程序的模板缓存方式：
\nTEMPLATES = [\n {\n "BACKEND": "django.template.backends.django.DjangoTemplates",\n "DIRS": [BASE_DIR / "templates"],\n "OPTIONS": {\n "loaders": [\n (\n "django.template.loaders.cached.Loader",\n [\n "django.template.loaders.filesystem.Loader",\n "django.template.loaders.app_directories.Loader",\n "path.to.custom.Loader",\n ],\n ),\n ],\n },\n }\n]\ndjango.template.loaders.locmem.Loader
从 Python 字典中加载模板。这对测试很有用。
\n该加载器将模板字典作为其第一个参数：
\nTEMPLATES = [\n {\n "BACKEND": "django.template.backends.django.DjangoTemplates",\n "OPTIONS": {\n "loaders": [\n (\n "django.template.loaders.locmem.Loader",\n {\n "index.html": "content here",\n },\n ),\n ],\n },\n }\n]\n该加载器默认为禁用。
\nDjango 根据 'loaders' 选项的顺序使用模板加载器。它使用每个加载器，直到一个加载器找到匹配的模板。
可以使用自定义模板加载器从其他来源加载模板。自定义 Loader 类应该继承 django.template.loaders.base.Loader 并定义 get_contents() 和 get_template_sources() 方法。
从给定的源，如文件系统或数据库中加载模板。
\n一个接受 template_name 的方法，并为每个可能的来源产生 Origin 实例。
For example, the filesystem loader may receive 'index.html' as a\ntemplate_name argument. This method would yield origins for the\nfull path of index.html as it appears in each template directory\nthe loader looks at.
该方法不需要验证模板是否存在于给定的路径中，但它应该确保路径是有效的。例如，文件系统加载器会确保路径位于一个有效的模板目录下。
\n返回给定 Origin 实例的模板的内容。
这是一个文件系统加载器从文件系统读取内容的地方，或者一个数据库加载器从数据库读取内容的地方。如果一个匹配的模板不存在，这应该会引发一个 TemplateDoesNotExist 错误。
通过循环浏览 get_template_sources() 和调用 get_contents() 的结果，为给定的 template_name 返回一个 Template 对象。这将返回第一个匹配的模板。如果没有找到模板，则会引发 TemplateDoesNotExist。
可选的 skip 参数是扩展模板时要忽略的起源列表。这允许模板扩展同名的其他模板。它也用于避免递归错误。
一般来说，定义 get_template_sources() 和 get_contents() 为自定义模板加载器就可以了。get_template() 通常不需要重写。
模板有一个 origin，包含的属性取决于它们的来源。
模板加载器返回的模板路径。对于从文件系统读取的加载器，这是模板的完整路径。
\n如果模板是直接实例化的，而不是通过模板加载器，这是一个字符串值 <unknown_source>。
传入模板加载器的模板的相对路径。
\n如果模板是直接实例化的，而不是通过模板加载器，这就是 None。
构建这个 Origin 的模板加载器实例。
如果模板是直接实例化的，而不是通过模板加载器，这就是 None。
django.template.loaders.cached.Loader 要求所有封装的加载器都要设置这个属性，通常是通过实例化 loader=self 的 Origin。