扩展

Jinja支持可以添加额外过滤器、测试、全局参数甚至扩展解析器的扩展。扩展的主要动机是将经常使用的代码移到可重用的类中，比如添加对国际化的支持。

添加扩展名

扩展在创建时添加到JJJA环境中。若要添加扩展，请将扩展类的列表或导入路径传递到 extensions 属性的参数 Environment 构造函数。以下示例创建加载了i18n扩展名的JJJA环境：

jinja_env = Environment(extensions=['jinja2.ext.i18n'])

若要在创建后添加扩展，请使用 add_extension() 方法：

jinja_env.add_extension('jinja2.ext.debug')

i18n扩展

进口名称： jinja2.ext.i18n

i18n扩展可与 gettext 或 Babel . 当它被启用时，Jinja提供了一个 trans 语句，该语句将块标记为可翻译并调用 gettext .

启用后，应用程序必须提供以下功能 gettext ， ngettext ，以及可选的 pgettext 和 npgettext ，全局或在渲染时。一个 _() 函数作为别名添加到 gettext 功能。

环境方法

启用扩展后，环境提供以下附加方法：

jinja2.Environment.install_gettext_translations(translations, newstyle=False)

为环境全局安装转换。这个 translations 对象必须实现 gettext ， ngettext ，以及可选的 pgettext 和 npgettext 。 gettext.NullTranslations ， gettext.GNUTranslations ，以及 Babel S Translations 是受支持的。

Changelog

在 3.0 版本发生变更: 增列 pgettext 和 npgettext 。

在 2.5 版本发生变更: 添加了新样式的gettext支持。

jinja2.Environment.install_null_translations(newstyle=False)

不安装op gettext函数。如果您想为国际化准备应用程序，但又不想实现完整的系统，那么这很有用。

Changelog

在 2.5 版本发生变更: 添加了新样式的gettext支持。

jinja2.Environment.install_gettext_callables(gettext, ngettext, newstyle=False, pgettext=None, npgettext=None)

安装给定的 gettext ， ngettext ， pgettext ，以及 npgettext 进入到环境中。他们的行为应该完全像 gettext.gettext() ， gettext.ngettext() ， gettext.pgettext() 和 gettext.npgettext() 。

如果 newstyle 被激活时，可调用文件被包装为像newStyle可调用文件一样工作。见 新样式Gettext 更多信息。

Changelog

在 3.0 版本发生变更: 增列 pgettext 和 npgettext 。

在 2.5 版本加入: 添加了新样式的gettext支持。

jinja2.Environment.uninstall_gettext_translations()

卸载环境的全局安装的转换。

jinja2.Environment.extract_translations(source)

从给定的模板节点或源提取可本地化的字符串。

对于找到的每个字符串，此函数生成一个 (lineno, function, message) 元组，其中：

• lineno 找到字符串的行的编号。

• function 是的名称 gettext 函数（如果字符串是从嵌入的Python代码中提取的）。

• message 是字符串本身，或具有多个参数的函数的字符串元组。

如果 Babel 已安装，请参阅 Babel 提取字符串。

对于可以使用多种语言但为所有用户提供相同语言的web应用程序（例如，为法语社区安装的多语言论坛软件），可以在创建环境时安装翻译。

translations = get_gettext_translations()
env = Environment(extensions=["jinja2.ext.i18n"])
env.install_gettext_translations(translations)

这个 get_gettext_translations 函数将返回当前配置的转换器，例如使用 gettext.find .

使用 i18n 中介绍了模板设计器的扩展 the template documentation .

空白剪裁

Changelog

在 2.10 版本加入.

内 {{% trans %}} 块，可以很有用地修剪换行符和空白，使文本块看起来像是翻译文件中带有单个空格的简单字符串。

可以通过启用 ext.i18n.trimmed policy .

新样式Gettext

Changelog

在 2.5 版本加入.

新样式的gettext调用的类型更少，更不容易出错，并且更好地支持自动转义。

您可以通过设置 env.newstyle_gettext = True 或路过 newstyle=True 到 env.install_translations . 它们完全受Babel提取工具的支持，但在使用其他提取工具时可能无法如预期的那样工作。

有标准的 gettext 调用，字符串格式化是用 |format 过滤器。这需要为 ngettext 电话。

{{ gettext("Hello, World!") }}
{{ gettext("Hello, %(name)s!")|format(name=name) }}
{{ ngettext(
       "%(num)d apple", "%(num)d apples", apples|count
   )|format(num=apples|count) }}
{{ pgettext("greeting", "Hello, World!") }}
{{ npgettext(
       "fruit", "%(num)d apple", "%(num)d apples", apples|count
   )|format(num=apples|count) }}

新风格 gettext 使格式化成为调用的一部分，并在幕后强制实现更高的一致性。

{{ gettext("Hello, World!") }}
{{ gettext("Hello, %(name)s!", name=name) }}
{{ ngettext("%(num)d apple", "%(num)d apples", apples|count) }}
{{ pgettext("greeting", "Hello, World!") }}
{{ npgettext("fruit", "%(num)d apple", "%(num)d apples", apples|count) }}

newstyle gettext的优点是：

• 没有单独的格式化步骤，您不必记住使用 |format 过滤器。

• 只允许使用命名占位符。这解决了翻译人员面临的一个常见问题，因为位置占位符不能有意义地切换位置。命名占位符总是携带关于值的语义信息。

• 即使不使用占位符，也会使用字符串格式，这使得所有字符串都使用一致的格式。记住要将任何原始百分比符号 %% ，如 100%% .

• 翻译后的字符串被标记为安全的，格式化根据需要执行转义。将参数标记为 |safe 如果它已经逃走了。

表达式语句

进口名称： jinja2.ext.do

“do”aka表达式语句扩展添加了一个简单的 do 模板引擎的标记，其工作方式类似于变量表达式，但忽略返回值。

循环控制

进口名称： jinja2.ext.loopcontrols

此扩展添加了对 break 和 continue 在循环中。在启用之后，Jinja提供了这两个关键字，它们的工作方式与Python中完全相同。

附有声明

进口名称： jinja2.ext.with_

Changelog

在 2.9 版本发生变更: 这个扩展现在是内置的，不再做任何事情。

自动转义扩展

进口名称： jinja2.ext.autoescape

Changelog

在 2.9 版本发生变更: 此扩展已被删除，现在已内置。启用扩展不再起任何作用。

调试扩展

进口名称： jinja2.ext.debug

添加一个 {{% debug %}} 标记以转储当前上下文以及可用的筛选器和测试。这对于在不设置调试器的情况下查看模板中可使用的内容非常有用。

正在写入扩展名

通过编写扩展，您可以向Jinja添加自定义标记。这是一项非常重要的任务，通常不需要，因为默认标记和表达式涵盖了所有常见的用例。i18n扩展是说明扩展为何有用的一个很好的例子。另一个是碎片缓存。

在编写扩展时，您必须记住，您使用的是Jinja模板编译器，它不会验证传递给它的节点树。如果AST的格式不正确，您将得到各种各样的编译器或运行时错误，这些错误很难调试。始终确保正确使用创建的节点。下面的API文档显示了存在哪些节点以及如何使用它们。

扩展示例

隐藏物

以下示例实现了 cache 使用 cachelib 类库：

from jinja2 import nodes
from jinja2.ext import Extension


class FragmentCacheExtension(Extension):
    # a set of names that trigger the extension.
    tags = {"cache"}

    def __init__(self, environment):
        super().__init__(environment)

        # add the defaults to the environment
        environment.extend(fragment_cache_prefix="", fragment_cache=None)

    def parse(self, parser):
        # the first token is the token that started the tag.  In our case
        # we only listen to ``'cache'`` so this will be a name token with
        # `cache` as value.  We get the line number so that we can give
        # that line number to the nodes we create by hand.
        lineno = next(parser.stream).lineno

        # now we parse a single expression that is used as cache key.
        args = [parser.parse_expression()]

        # if there is a comma, the user provided a timeout.  If not use
        # None as second parameter.
        if parser.stream.skip_if("comma"):
            args.append(parser.parse_expression())
        else:
            args.append(nodes.Const(None))

        # now we parse the body of the cache block up to `endcache` and
        # drop the needle (which would always be `endcache` in that case)
        body = parser.parse_statements(["name:endcache"], drop_needle=True)

        # now return a `CallBlock` node that calls our _cache_support
        # helper method on this extension.
        return nodes.CallBlock(
            self.call_method("_cache_support", args), [], [], body
        ).set_lineno(lineno)

    def _cache_support(self, name, timeout, caller):
        """Helper callback."""
        key = self.environment.fragment_cache_prefix + name

        # try to load the block from the cache
        # if there is no fragment in the cache, render it and store
        # it in the cache.
        rv = self.environment.fragment_cache.get(key)
        if rv is not None:
            return rv
        rv = caller()
        self.environment.fragment_cache.add(key, rv, timeout)
        return rv

以下是您在环境中使用它的方法：

from jinja2 import Environment
from cachelib import SimpleCache

env = Environment(extensions=[FragmentCacheExtension])
env.fragment_cache = SimpleCache()

在模板内，可以将块标记为可缓存。以下示例缓存边栏300秒：

{% cache 'sidebar', 300 %}
<div class="sidebar">
    ...
</div>
{% endcache %}

内联 gettext

下面的示例演示如何使用 Extension.filter_stream() 解析对 _() 无需使用gettext函数的Jinja静态块。

<h1>_(Welcome)</h1>
<p>_(This is a paragraph)</p>

它需要加载和配置i18n扩展。

import re

from jinja2.exceptions import TemplateSyntaxError
from jinja2.ext import Extension
from jinja2.lexer import count_newlines
from jinja2.lexer import Token


_outside_re = re.compile(r"\\?(gettext|_)\(")
_inside_re = re.compile(r"\\?[()]")


class InlineGettext(Extension):
    """This extension implements support for inline gettext blocks::

        <h1>_(Welcome)</h1>
        <p>_(This is a paragraph)</p>

    Requires the i18n extension to be loaded and configured.
    """

    def filter_stream(self, stream):
        paren_stack = 0

        for token in stream:
            if token.type != "data":
                yield token
                continue

            pos = 0
            lineno = token.lineno

            while True:
                if not paren_stack:
                    match = _outside_re.search(token.value, pos)
                else:
                    match = _inside_re.search(token.value, pos)
                if match is None:
                    break
                new_pos = match.start()
                if new_pos > pos:
                    preval = token.value[pos:new_pos]
                    yield Token(lineno, "data", preval)
                    lineno += count_newlines(preval)
                gtok = match.group()
                if gtok[0] == "\\":
                    yield Token(lineno, "data", gtok[1:])
                elif not paren_stack:
                    yield Token(lineno, "block_begin", None)
                    yield Token(lineno, "name", "trans")
                    yield Token(lineno, "block_end", None)
                    paren_stack = 1
                else:
                    if gtok == "(" or paren_stack > 1:
                        yield Token(lineno, "data", gtok)
                    paren_stack += -1 if gtok == ")" else 1
                    if not paren_stack:
                        yield Token(lineno, "block_begin", None)
                        yield Token(lineno, "name", "endtrans")
                        yield Token(lineno, "block_end", None)
                pos = match.end()

            if pos < len(token.value):
                yield Token(lineno, "data", token.value[pos:])

        if paren_stack:
            raise TemplateSyntaxError(
                "unclosed gettext expression",
                token.lineno,
                stream.name,
                stream.filename,
            )

扩展API

延伸

扩展始终必须扩展 jinja2.ext.Extension 类：

class jinja2.ext.Extension(environment)

扩展可用于在解析器级别向Jinja模板系统添加额外的功能。自定义扩展已绑定到环境，但不能在上存储特定于环境的数据 self . 原因是，通过创建副本并重新分配 environment 属性。

由于扩展是由环境创建的，因此它们不能接受任何配置参数。人们可能希望通过使用工厂函数来解决这个问题，但这是不可能的，因为扩展是由它们的导入名称标识的。配置扩展的正确方法是在环境中存储配置值。因为这样环境最终会充当中央配置存储，所以属性可能会发生冲突，这就是为什么扩展必须确保它们为配置选择的名称不是太通用的原因。 prefix 例如，一个糟糕的名字， fragment_cache_prefix 另一方面是一个好名字，包括扩展名（片段缓存）。

参数:

environment (Environment) --

identifier

扩展的标识符。这始终是扩展类的真正导入名称，不得更改。

tags

如果扩展实现自定义标记，则这是扩展正在侦听的一组标记名。

attr(name, lineno=None)

返回当前扩展名的属性节点。这对于将扩展上的常量传递给生成的模板代码很有用。

self.attr('_my_attribute', lineno=lineno)

参数:

• name (str) --

• lineno (int | None) --

返回类型:

ExtensionAttribute

call_method(name, args=None, kwargs=None, dyn_args=None, dyn_kwargs=None, lineno=None)

调用扩展的方法。这是一个快捷方式 attr() + jinja2.nodes.Call .

参数:

• name (str) --

• args (List[Expr] | None) --

• kwargs (List[Keyword] | None) --

• dyn_args (Expr | None) --

• dyn_kwargs (Expr | None) --

• lineno (int | None) --

返回类型:

Call

filter_stream(stream)

它通过了 TokenStream 可用于筛选返回的令牌。此方法必须返回 Token S，但它不必返回 TokenStream .

参数:

stream (TokenStream) --

返回类型:

TokenStream | Iterable[Token]

parse(parser)

如果有 tags 匹配的这个方法是以解析器作为第一个参数调用的。解析器流指向的标记是匹配的名称标记。此方法必须返回一个或多个节点的列表。

参数:

parser (Parser) --

返回类型:

Node | List[Node]

preprocess(source, name, filename=None)

此方法在实际词法分析之前调用，并可用于对源进行预处理。这个 filename 是可选的。返回值必须是预处理的源。

参数:

• source (str) --

• name (str | None) --

• filename (str | None) --

返回类型:

str

语法分析器

分析器传递给 Extension.parse() 提供分析不同类型表达式的方法。扩展可以使用以下方法：

class jinja2.parser.Parser(environment, source, name=None, filename=None, state=None)

这是Jinja使用的中心解析类。它被传递给扩展，可以用来解析表达式或语句。

参数:

• environment (Environment) --

• source (str) --

• name (str | None) --

• filename (str | None) --

• state (str | None) --

filename

分析程序处理的模板的文件名。这是 not 模板的加载名称。有关加载名称，请参见 name . 对于未从文件系统加载的模板，这是 None .

name

模板的加载名称。

stream

TokenStream

fail(msg, lineno=None, exc=<class 'jinja2.exceptions.TemplateSyntaxError'>)

提出的便利方法 exc 通过消息，传递的行号或最后一个行号以及当前名称和文件名。

参数:

• msg (str) --

• lineno (int | None) --

• exc (Type[TemplateSyntaxError]) --

返回类型:

te.NoReturn

free_identifier(lineno=None)

返回新的自由标识符为 InternalName .

参数:

lineno (int | None) --

返回类型:

InternalName

parse_assign_target(with_tuple=True, name_only=False, extra_end_rules=None, with_namespace=False)

分析分配目标。由于Jinja允许对元组赋值，所以这个函数可以解析所有允许的赋值目标。解析对元组的默认赋值，但可以通过设置 with_tuple 到 False . 如果只需要指定姓名 name_only 可以设置为 True . 这个 extra_end_rules 参数被转发到元组分析函数。如果 with_namespace 如果启用，则可以分析命名空间分配。

参数:

• with_tuple (bool) --

• name_only (bool) --

• extra_end_rules (Tuple[str, ...] | None) --

• with_namespace (bool) --

返回类型:

NSRef | Name | Tuple

parse_expression(with_condexpr=True)

分析表达式。默认情况下，如果 with_condexpr 参数设置为 False 未分析条件表达式。

参数:

with_condexpr (bool) --

返回类型:

Expr

parse_statements(end_tokens, drop_needle=False)

将多个语句解析到一个列表中，直到到达其中一个结束标记为止。这用于分析语句体，因为它还分析模板数据（如果适用）。解析器首先检查当前标记是否是冒号，如果有冒号，则跳过它。然后它检查块的结尾并分析直到 end_tokens 达到。默认情况下，调用结束时流中的活动令牌是匹配的结束令牌。如果不需要的话 drop_needle 可以设置为 True 并删除结束标记。

参数:

• end_tokens (Tuple[str, ...]) --

• drop_needle (bool) --

返回类型:

List[Node]

parse_tuple(simplified=False, with_condexpr=True, extra_end_rules=None, explicit_parentheses=False)

工作原理类似 parse_expression 但如果多个表达式用逗号分隔 Tuple 节点已创建。如果找不到逗号，此方法还可以返回正则表达式而不是元组。

默认的分析模式是一个完整的元组。如果 simplified 是 True 只分析名称和文本。这个 no_condexpr 参数被转发到 parse_expression() .

因为元组不需要分隔符，可能以伪逗号结尾，所以需要额外的提示来标记元组的结尾。例如，循环支持介于 for 和 in . 在这种情况下， extra_end_rules 设置为 ['name:in'] .

explicit_parentheses 如果分析是由括号中的表达式触发的，则为true。这用于确定空元组是否为有效表达式。

参数:

• simplified (bool) --

• with_condexpr (bool) --

• extra_end_rules (Tuple[str, ...] | None) --

• explicit_parentheses (bool) --

返回类型:

Tuple | Expr

class jinja2.lexer.TokenStream(generator, name, filename)

令牌流是生成 Token 但是，解析器不会对它进行迭代，而是调用 next() 先转到一个令牌。当前活动令牌存储为 current .

参数:

• generator (Iterable[Token]) --

• name (str | None) --

• filename (str | None) --

current

Token .

__next__()

取一个新的令牌，把旧的返回去

使用内置 next() 而不是直接呼叫。

返回类型:

Token

property eos: bool

我们是在小溪的尽头吗？

expect(expr)

期望给定的令牌类型并返回它。这接受了与 jinja2.lexer.Token.test() .

参数:

expr (str) --

返回类型:

Token

look()

看看下一个标记。

返回类型:

Token

next_if(expr)

执行令牌测试，如果匹配，则返回令牌。否则返回值为 None .

参数:

expr (str) --

返回类型:

Token | None

push(token)

将令牌推回到流中。

参数:

token (Token) --

返回类型:

None

skip(n=1)

前面有N个令牌。

参数:

n (int) --

返回类型:

None

skip_if(expr)

喜欢 next_if() 但只有回报 True 或 False .

参数:

expr (str) --

返回类型:

bool

class jinja2.lexer.Token(lineno, type, value)

参数:

• lineno (int) --

• type (str) --

• value (str) --

lineno

令牌的行号

type

令牌的类型。此字符串已实习，因此可以使用 is 操作员。

value

令牌的值。

test(expr)

根据令牌表达式测试令牌。这可以是令牌类型，也可以是 'token_type:token_value' . 这只能对字符串值和类型进行测试。

参数:

expr (str) --

返回类型:

bool

test_any(*iterable)

对多个令牌表达式进行测试。

参数:

iterable (str) --

返回类型:

bool

lexer模块中还有一个实用程序函数，可以计算字符串中的换行符：

jinja2.lexer.count_newlines(value)

计算字符串中换行符的数目。这对于筛选流的扩展非常有用。

参数:

value (str) --

返回类型:

int

AST

AST（抽象语法树）用于表示解析后的模板。它是由节点组成的，然后编译器将这些节点转换为可执行的python代码对象。提供定制语句的扩展可以返回节点来执行定制的python代码。

下面的列表描述了当前可用的所有节点。AST可能会在Jinja版本之间改变，但会保持向后兼容。

有关更多信息，请查看 jinja2.Environment.parse() .

class jinja2.nodes.Node

所有Jinja节点的基类。有许多不同类型的节点可用。主要有四种类型：

• Stmt 声明

• Expr 表达式

• Helper 辅助节点

• Template ：最外层包装节点

所有节点都有字段和属性。字段可以是其他节点、列表或任意值。字段作为常规位置参数传递给构造函数，属性作为关键字参数传递给构造函数。每个节点有两个属性： lineno （节点的行号）和 environment . 这个 environment 属性在所有节点的分析过程结束时自动设置。

参数:

• fields (Any) --

• attributes (Any) --

find(node_type)

查找给定类型的第一个节点。如果不存在这样的节点，返回值为 None .

参数:

node_type (Type[_NodeBound]) --

返回类型:

_NodeBound | None

find_all(node_type)

查找给定类型的所有节点。如果类型是元组，则对任何元组项执行检查。

参数:

node_type (Type[_NodeBound] | Tuple[Type[_NodeBound], ...]) --

返回类型:

Iterator[_NodeBound]

iter_child_nodes(exclude=None, only=None)

循环访问节点的所有直接子节点。这将遍历所有字段，并生成它们的值作为节点。如果字段值是列表，则返回该列表中的所有节点。

参数:

• exclude (Container[str] | None) --

• only (Container[str] | None) --

返回类型:

Iterator[Node]

iter_fields(exclude=None, only=None)

此方法迭代所有定义的字段并生成 (key, value) 元组。默认情况下，会返回所有字段，但可以通过提供 only 参数或排除一些使用 exclude 参数。两者都应该是字段名的集合或元组。

参数:

• exclude (Container[str] | None) --

• only (Container[str] | None) --

返回类型:

Iterator[Tuple[str, Any]]

set_ctx(ctx)

重置节点和所有子节点的上下文。默认情况下，解析器将生成所有具有“加载”上下文的节点，因为它是最常见的节点。此方法在解析器中用于将分配目标和其他节点设置为存储上下文。

参数:

ctx (str) --

返回类型:

Node

set_environment(environment)

为所有节点设置环境。

参数:

environment (Environment) --

返回类型:

Node

set_lineno(lineno, override=False)

设置节点和子节点的行号。

参数:

• lineno (int) --

• override (bool) --

返回类型:

Node

class jinja2.nodes.Expr

所有表达式的基类。

节点类型:

Node

参数:

• fields (Any) --

• attributes (Any) --

as_const(eval_ctx=None)

以常量或升序返回表达式的值 Impossible 如果不可能的话。

安 EvalContext 如果没有给定任何上下文，则可以提供。创建的默认上下文要求节点具有附加的环境。

Changelog

在 2.4 版本发生变更: 这个 eval_ctx 已添加参数。

参数:

eval_ctx (EvalContext | None) --

返回类型:

Any

can_assign()

检查是否可以为此节点分配某些内容。

返回类型:

bool

class jinja2.nodes._FilterTestCommon(node, name, args, kwargs, dyn_args, dyn_kwargs)

节点类型:

Expr

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.Filter(node, name, args, kwargs, dyn_args, dyn_kwargs)

将过滤应用于表达式。 name 是过滤的名称，其他字段与 Call 。

如果 node 是 None ，过滤正在过滤挡路中使用，并应用于挡路的内容。

节点类型:

_FilterTestCommon

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.Test(node, name, args, kwargs, dyn_args, dyn_kwargs)

将测试应用于表达式。 name 是测试的名称，其他字段与 Call 。

Changelog

在 3.0 版本发生变更: as_const 共享相同的筛选器和测试逻辑。测试检查易失性、异步和 @pass_context 等等。装修工。

节点类型:

_FilterTestCommon

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.BinExpr(left, right)

所有二进制表达式的基类。

节点类型:

Expr

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.Add(left, right)

将左节点添加到右节点。

节点类型:

BinExpr

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.And(left, right)

短路和。

节点类型:

BinExpr

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.Div(left, right)

将左侧除以右侧节点。

节点类型:

BinExpr

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.FloorDiv(left, right)

将左侧除以右侧节点，并通过截断将结果转换为整数。

节点类型:

BinExpr

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.Mod(left, right)

左模右模。

节点类型:

BinExpr

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.Mul(left, right)

将左节点与右节点相乘。

节点类型:

BinExpr

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.Or(left, right)

短路或。

节点类型:

BinExpr

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.Pow(left, right)

左到右的力量。

节点类型:

BinExpr

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.Sub(left, right)

从左节点中减去右节点。

节点类型:

BinExpr

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.Call(node, args, kwargs, dyn_args, dyn_kwargs)

调用表达式。 args 是参数列表， kwargs 关键字参数列表（列表 Keyword 节点） dyn_args 和 dyn_kwargs 必须是 None 或用作动态位置节点的节点 (*args ）关键词 (**kwargs ）参数。

节点类型:

Expr

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.Compare(expr, ops)

将表达式与其他一些表达式进行比较。 ops 必须是 Operand S

节点类型:

Expr

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.Concat(nodes)

连接在将表达式转换为字符串后提供的表达式列表。

节点类型:

Expr

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.CondExpr(test, expr1, expr2)

条件表达式（内联if表达式）。 ({{{{ foo if bar else baz }}}} ）

节点类型:

Expr

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.ContextReference

返回当前模板上下文。它可以像 Name 节点，用 'load' 并将返回电流 Context 对象。

这里有一个将当前模板名称赋给名为 foo ：：

Assign(Name('foo', ctx='store'),
       Getattr(ContextReference(), 'name'))

这基本上等同于使用 pass_context() 在使用高级API时使用装饰符，这会导致对上下文的引用作为第一个参数传递给函数。

节点类型:

Expr

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.DerivedContextReference

返回当前模板上下文，包括局部变量。行为完全像 ContextReference ，但包含局部变量，例如 for 循环。

Changelog

在 2.11 版本加入.

节点类型:

Expr

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.EnvironmentAttribute(name)

从环境对象加载属性。这对于希望调用存储在环境中的回调的扩展非常有用。

节点类型:

Expr

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.ExtensionAttribute(identifier, name)

返回绑定到环境的扩展的属性。标识符是 Extension .

通常通过调用 attr() 方法。

节点类型:

Expr

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.Getattr(node, attr, ctx)

从仅为ASCII字节串的表达式中获取属性或项，并首选该属性。

节点类型:

Expr

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.Getitem(node, arg, ctx)

从表达式中获取属性或项，并首选该项。

节点类型:

Expr

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.ImportedName(importname)

如果使用导入名称创建，则在节点访问时返回导入名称。例如 ImportedName('cgi.escape') 返回 escape 来自CGI模块的函数。导入由编译器优化，因此无需将其分配给局部变量。

节点类型:

Expr

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.InternalName(name)

编译器中的内部名称。您不能自己创建这些节点，但是解析器提供了一个 free_identifier() 方法，该方法为您创建新的标识符。该标识符不能从模板中获得，编译器也不会对其进行特殊处理。

节点类型:

Expr

class jinja2.nodes.Literal

文本的基类。

节点类型:

Expr

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.Const(value)

所有常量值。解析器将返回简单常量（如 42 或 "foo" 但它也可以用于存储更复杂的值，如列表。只有具有安全表示形式的常量（对象 eval(repr(x)) == x 是真的）。

节点类型:

Literal

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.Dict(items)

任何dict文字，如 {{1: 2, 3: 4}} . 项目必须是 Pair 节点。

节点类型:

Literal

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.List(items)

任何列表文本，如 [1, 2, 3]

节点类型:

Literal

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.TemplateData(data)

常量模板字符串。

节点类型:

Literal

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.Tuple(items, ctx)

用于循环解包和一些其他事情，比如下标的多个参数。喜欢 Name ctx 指定元组是用于加载名称还是用于存储。

节点类型:

Literal

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.MarkSafe(expr)

将被包装的表达式标记为安全的（将其包装为 Markup ）

节点类型:

Expr

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.MarkSafeIfAutoescape(expr)

将被包装的表达式标记为安全的（将其包装为 Markup ）但只有当自动转义处于活动状态时。

Changelog

在 2.5 版本加入.

节点类型:

Expr

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.Name(name, ctx)

查找名称或在名称中存储值。这个 ctx 节点的值可以是以下值之一：

• store ：在名称中存储值

• load ：加载该名称

• param 喜欢 store 但如果名称被定义为函数参数。

节点类型:

Expr

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.NSRef(name, attr)

对命名空间值分配的引用

节点类型:

Expr

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.Slice(start, stop, step)

表示切片对象。此参数只能用作 Subscript .

节点类型:

Expr

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.UnaryExpr(node)

所有一元表达式的基类。

节点类型:

Expr

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.Neg(node)

使表达式为负数。

节点类型:

UnaryExpr

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.Not(node)

否定表达式。

节点类型:

UnaryExpr

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.Pos(node)

使表达式为正（大多数表达式为NOOP）

节点类型:

UnaryExpr

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.Helper

仅存在于特定上下文中的节点。

节点类型:

Node

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.Keyword(key, value)

关键字参数的键、值对，其中键是字符串。

节点类型:

Helper

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.Operand(op, expr)

包含运算符和表达式。

节点类型:

Helper

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.Pair(key, value)

字典的键、值对。

节点类型:

Helper

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.Stmt

所有语句的基节点。

节点类型:

Node

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.Assign(target, node)

将表达式赋给目标。

节点类型:

Stmt

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.AssignBlock(target, filter, body)

为目标指定块。

节点类型:

Stmt

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.Block(name, body, scoped, required)

表示块的节点。

Changelog

在 3.0.0 版本发生变更: 这个 required 已添加字段。

节点类型:

Stmt

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.Break

打破一个循环。

节点类型:

Stmt

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.CallBlock(call, args, defaults, body)

就像一个没有名字的宏，而是一个调用。 call 用未命名的宏调用为 caller

节点类型:

Stmt

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.Continue

继续循环。

节点类型:

Stmt

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.EvalContextModifier(options)

修改eval上下文。对于应修改的每个选项，a Keyword 必须添加到 options 名单。

示例更改 autoescape 设置：

EvalContextModifier(options=[Keyword('autoescape', Const(True))])

节点类型:

Stmt

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.ScopedEvalContextModifier(options, body)

修改eval上下文，稍后将其还原。工作原理和 EvalContextModifier 但只会修改 EvalContext 对于中的节点 body .

节点类型:

EvalContextModifier

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.ExprStmt(node)

计算表达式并丢弃结果的语句。

节点类型:

Stmt

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.Extends(template)

表示扩展语句。

节点类型:

Stmt

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.FilterBlock(body, filter)

筛选器节的节点。

节点类型:

Stmt

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.For(target, iter, body, else_, test, recursive)

for循环。 target 是迭代的目标（通常是 Name 或 Tuple ） iter 可迭代的。 body 是用作循环体的节点列表，以及 else_ 的节点列表 else 块。如果不存在其他节点，则它必须是空列表。

对于筛选的节点，表达式可以存储为 test ，否则 None .

节点类型:

Stmt

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.FromImport(template, names, with_context)

表示“从导入”标记的节点。重要的是不要将不安全的名称传递给name属性。编译器将属性查找直接转换为getattr调用，并执行 not 使用接口的下标回调。由于导出的变量不能以双下划线（解析器断言）开头，这对于常规的jinja代码来说不是问题，但是如果在扩展中使用此节点，则必须格外小心。

如果需要别名，名称列表可能包含元组。

节点类型:

Stmt

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.If(test, body, elif_, else_)

如果 test 是真的， body 是渲染的，否则 else_ .

节点类型:

Stmt

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.Import(template, target, with_context)

表示导入标记的节点。

节点类型:

Stmt

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.Include(template, with_context, ignore_missing)

表示include标记的节点。

节点类型:

Stmt

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.Macro(name, args, defaults, body)

宏定义。 name 是宏的名称， args 参数列表和 defaults 默认值列表（如果有）。 body 是宏体的节点列表。

节点类型:

Stmt

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.Output(nodes)

保存多个表达式的节点，然后打印出来。这两个都用于 print 语句和常规模板数据。

节点类型:

Stmt

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.OverlayScope(context, body)

扩展的覆盖范围。这是一个很大程度上未经优化的范围，但是可以用来从字典或类似字典的对象将完全任意的变量引入子范围。这个 context 字段必须计算为字典对象。

示例用法：

OverlayScope(context=self.call_method('get_context'),
             body=[...])

Changelog

在 2.10 版本加入.

节点类型:

Stmt

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.Scope(body)

人造镜。

节点类型:

Stmt

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.With(targets, values, body)

WITH语句的特定节点。在旧版本的Jinja中，WITH语句是在 Scope 节点代替。

Changelog

在 2.9.3 版本加入.

节点类型:

Stmt

参数:

• fields (Any) --

• attributes (Any) --

class jinja2.nodes.Template(body)

表示模板的节点。这必须是传递给编译器的最外部节点。

节点类型:

Node

参数:

• fields (Any) --

• attributes (Any) --

exception jinja2.nodes.Impossible

在节点无法执行请求的操作时引发。