扩展

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

添加扩展名

在创建时将扩展添加到jinja2环境中。一旦创建了环境,就无法添加其他扩展。要添加扩展,请将扩展类列表或导入路径传递给 extensions 的参数 Environment 构造函数。以下示例创建了一个加载了i18n扩展的jinja2环境:

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

i18n扩展

导入名称: jinja2.ext.i18n

i18n扩展可与 gettextbabel . 如果I18N扩展被启用,jinja2提供 trans 将包装好的字符串标记为可翻译和调用的语句 gettext .

启用后,虚拟 _ 将调用转发到的函数 gettext 添加到环境全局变量。国际化应用程序必须提供 gettext 函数和可选的 ngettext 在命名空间中执行函数,无论是全局还是每次呈现。

环境方法

启用扩展后,环境提供以下附加方法:

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

为该环境全局安装翻译。提供的翻译对象必须至少实现 ugettext and ungettext. The gettext.NullTranslations and gettext.GNUTranslations classes as well as Babel 的S Translations 支持类。

在 2.5 版更改: 添加了NewStyle GetText

jinja2.Environment.install_null_translations(newstyle=False)

安装虚拟GetText函数。如果您想为国际化准备应用程序,但还不想实现完整的国际化系统,那么这是非常有用的。

在 2.5 版更改: 添加了NewStyle GetText

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

安装给定的 gettextngettext 可作为全局调用到环境中。他们的行为应该和标准类库的完全一样。 gettext.ugettext()gettext.ungettext() 功能。

如果 newstyle 被激活时,可调用文件被包装为像newStyle可调用文件一样工作。见 空白剪裁 更多信息。

2.5 新版功能.

jinja2.Environment.uninstall_gettext_translations()

再次卸载翻译。

jinja2.Environment.extract_translations(source)

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

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

  • lineno 是找到字符串的行的编号,

  • function 是的名称 gettext 使用的函数(如果字符串是从嵌入的python代码中提取的),以及

  • message 是字符串本身(a unicode 对象,或 unicode 具有多个字符串参数的函数的对象)。

如果 Babel 已安装, the babel integration 可用于提取babel的字符串。

对于可以使用多种语言但为所有用户提供相同语言的Web应用程序(例如为法国社区安装的多语言论坛软件),可以加载一次翻译并在环境生成时将翻译方法添加到环境中:

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

这个 get_gettext_translations 函数将返回当前配置的转换器。(例如,通过使用 gettext.find

使用 i18n 模板设计器的扩展作为一部分包括在内 of the template documentation .

空白剪裁

2.10 新版功能.

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

Newstyle Gettext

2.5 新版功能.

从2.5版本开始,您可以使用NewStyle GetText调用。这些都是受trac的内部getText函数的启发,并且完全由babel提取工具支持。如果您不使用Babel,其他提取工具可能无法按预期工作。

标准和NewStyle GetText通话有什么区别?一般来说,它们不太容易打字,也不容易出错。另外,如果在自动转义环境中使用它们,它们更好地支持自动转义。以下是新旧呼叫之间的一些常见差异:

标准GetText:

{{ gettext('Hello World!') }}
{{ gettext('Hello %(name)s!')|format(name='World') }}
{{ ngettext('%(num)d apple', '%(num)d apples', apples|count)|format(
    num=apples|count
)}}

newStyle getText看起来是这样的:

{{ gettext('Hello World!') }}
{{ gettext('Hello %(name)s!', name='World') }}
{{ ngettext('%(num)d apple', '%(num)d apples', apples|count) }}

NewStyleGetText的优点是,您可以少键入一些内容,并且命名的占位符成为必需的。后者听起来像是一个缺点,但解决了翻译人员在无法切换两个占位符位置时经常遇到的许多问题。对于newStyle getText,所有格式字符串看起来都一样。

此外,对于newStyle getText,如果不使用占位符,也会使用字符串格式,这会使所有字符串的行为完全相同。最后,也是最不重要的是NewStyleGetText调用能够正确地标记字符串以进行自动转义,这解决了许多模板在使用自动转义时长期遇到的许多转义相关问题。

表达式语句

导入名称: jinja2.ext.do

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

循环控制

导入名称: jinja2.ext.loopcontrols

此扩展添加了对 breakcontinue 在循环中。启用后,jinja2提供了这两个关键字,它们的工作方式与python完全相同。

附有声明

导入名称: jinja2.ext.with_

在 2.9 版更改.

这个扩展现在是内置的,不再做任何事情。

自动转义扩展

导入名称: jinja2.ext.autoescape

在 2.9 版更改.

此扩展名已被删除,现在已内置。启用扩展不再有任何作用。

正在写入扩展名

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

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

示例扩展

以下示例实现了 cache tag for Jinja2 by using the Werkzeug 缓存控制模块:

from jinja2 import nodes
from jinja2.ext import Extension


class FragmentCacheExtension(Extension):
    # a set of names that trigger the extension.
    tags = set(['cache'])

    def __init__(self, environment):
        super(FragmentCacheExtension, self).__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 werkzeug.contrib.cache import SimpleCache

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

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

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

扩展API

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

class jinja2.ext.Extension(environment)

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

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

identifier

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

tags

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

attr(name, lineno=None)

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

self.attr('_my_attribute', lineno=lineno)
call_method(name, args=None, kwargs=None, dyn_args=None, dyn_kwargs=None, lineno=None)

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

filter_stream(stream)

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

ext jinja2源分发的文件夹中有一个名为 inlinegettext.py 它实现了一个使用此方法的过滤器。

parse(parser)

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

preprocess(source, name, filename=None)

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

语法分析器API

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

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

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

filename

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

name

模板的加载名称。

stream

TokenStream

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

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

free_identifier(lineno=None)

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

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

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

parse_expression(with_condexpr=True)

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

parse_statements(end_tokens, drop_needle=False)

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

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

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

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

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

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

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

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

current

Token .

__next__()

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

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

eos

我们是在小溪的尽头吗?

expect(expr)

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

look()

看看下一个标记。

next_if(expr)

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

push(token)

将令牌推回到流中。

skip(n=1)

前面有N个令牌。

skip_if(expr)

喜欢 next_if() 但只有回报 TrueFalse .

class jinja2.lexer.Token

令牌类。

lineno

令牌的行号

type

令牌的类型。此字符串已保存,因此可以使用 is 运算符。

value

令牌的值。

test(expr)

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

test_any(*iterable)

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

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

jinja2.lexer.count_newlines(value)

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

AST

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

下面的列表描述了当前可用的所有节点。AST可能在jinja2版本之间发生变化,但将保持向后兼容。

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

class jinja2.nodes.Node

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

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

find(node_type)

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

find_all(node_type)

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

iter_child_nodes(exclude=None, only=None)

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

iter_fields(exclude=None, only=None)

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

set_ctx(ctx)

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

set_environment(environment)

为所有节点设置环境。

set_lineno(lineno, override=False)

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

class jinja2.nodes.Expr

所有表达式的基类。

节点类型

Node

as_const(eval_ctx=None)

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

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

在 2.4 版更改: 这个 eval_ctx 已添加参数。

can_assign()

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

class jinja2.nodes.BinExpr(left, right)

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

节点类型

Expr

class jinja2.nodes.Add(left, right)

将左节点添加到右节点。

节点类型

BinExpr

class jinja2.nodes.And(left, right)

短路和。

节点类型

BinExpr

class jinja2.nodes.Div(left, right)

将左侧除以右侧节点。

节点类型

BinExpr

class jinja2.nodes.FloorDiv(left, right)

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

节点类型

BinExpr

class jinja2.nodes.Mod(left, right)

左模右模。

节点类型

BinExpr

class jinja2.nodes.Mul(left, right)

将左节点与右节点相乘。

节点类型

BinExpr

class jinja2.nodes.Or(left, right)

短路或。

节点类型

BinExpr

class jinja2.nodes.Pow(left, right)

左到右的力量。

节点类型

BinExpr

class jinja2.nodes.Sub(left, right)

从左节点中减去右节点。

节点类型

BinExpr

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

调用表达式。 args 是参数列表, kwargs 关键字参数列表(列表 Keyword 节点) dyn_argsdyn_kwargs 必须是 None 或用作动态位置节点的节点 (*args )关键词 (**kwargs )争论。

节点类型

Expr

class jinja2.nodes.Compare(expr, ops)

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

节点类型

Expr

class jinja2.nodes.Concat(nodes)

连接将表达式转换为Unicode后提供的表达式列表。

节点类型

Expr

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

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

节点类型

Expr

class jinja2.nodes.ContextReference

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

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

Assign(Name('foo', ctx='store'),
       Getattr(ContextReference(), 'name'))
节点类型

Expr

class jinja2.nodes.EnvironmentAttribute(name)

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

节点类型

Expr

class jinja2.nodes.ExtensionAttribute(identifier, name)

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

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

节点类型

Expr

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

此节点对表达式应用筛选器。 name 是筛选器的名称,其余字段与的相同 Call .

如果 node 滤波器的 None 过滤最后一个缓冲区的内容。缓冲区由宏和筛选块创建。

节点类型

Expr

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

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

节点类型

Expr

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

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

节点类型

Expr

class jinja2.nodes.ImportedName(importname)

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

节点类型

Expr

class jinja2.nodes.InternalName(name)

编译器中的内部名称。您不能自己创建这些节点,但分析器提供了 free_identifier() 为您创建新标识符的方法。此标识符在模板中不可用,编译器不会专门对其进行线程化。

节点类型

Expr

class jinja2.nodes.Literal

文本的基类。

节点类型

Expr

class jinja2.nodes.Const(value)

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

节点类型

Literal

class jinja2.nodes.Dict(items)

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

节点类型

Literal

class jinja2.nodes.List(items)

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

节点类型

Literal

class jinja2.nodes.TemplateData(data)

常量模板字符串。

节点类型

Literal

class jinja2.nodes.Tuple(items, ctx)

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

节点类型

Literal

class jinja2.nodes.MarkSafe(expr)

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

节点类型

Expr

class jinja2.nodes.MarkSafeIfAutoescape(expr)

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

2.5 新版功能.

节点类型

Expr

class jinja2.nodes.Name(name, ctx)

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

  • store :在名称中存储值

  • load :加载该名称

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

节点类型

Expr

class jinja2.nodes.NSRef(name, attr)

对命名空间值分配的引用

节点类型

Expr

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

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

节点类型

Expr

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

对表达式应用测试。 name 是测试的名称,其余字段与 Call .

节点类型

Expr

class jinja2.nodes.UnaryExpr(node)

所有一元表达式的基类。

节点类型

Expr

class jinja2.nodes.Neg(node)

使表达式为负数。

节点类型

UnaryExpr

class jinja2.nodes.Not(node)

否定表达式。

节点类型

UnaryExpr

class jinja2.nodes.Pos(node)

使表达式为正(大多数表达式为NOOP)

节点类型

UnaryExpr

class jinja2.nodes.Helper

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

节点类型

Node

class jinja2.nodes.Keyword(key, value)

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

节点类型

Helper

class jinja2.nodes.Operand(op, expr)

保留运算符和表达式。以下运算符可用: %, **, *, +, -, //, /, `` 情商, gtgteqinltlteqnenotnotin

节点类型

Helper

class jinja2.nodes.Pair(key, value)

字典的键、值对。

节点类型

Helper

class jinja2.nodes.Stmt

所有语句的基节点。

节点类型

Node

class jinja2.nodes.Assign(target, node)

将表达式赋给目标。

节点类型

Stmt

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

为目标指定块。

节点类型

Stmt

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

表示块的节点。

节点类型

Stmt

class jinja2.nodes.Break

打破一个循环。

节点类型

Stmt

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

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

节点类型

Stmt

class jinja2.nodes.Continue

继续循环。

节点类型

Stmt

class jinja2.nodes.EvalContextModifier(options)

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

示例更改 autoescape 设置:

EvalContextModifier(options=[Keyword('autoescape', Const(True))])
节点类型

Stmt

class jinja2.nodes.ScopedEvalContextModifier(options, body)

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

节点类型

EvalContextModifier

class jinja2.nodes.ExprStmt(node)

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

节点类型

Stmt

class jinja2.nodes.Extends(template)

表示扩展语句。

节点类型

Stmt

class jinja2.nodes.FilterBlock(body, filter)

筛选器节的节点。

节点类型

Stmt

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

for循环。 target 是迭代的目标(通常是 NameTupleiter 可迭代的。 body 是用作循环体的节点列表,以及 else_ 的节点列表 else 块。如果不存在其他节点,则它必须是空列表。

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

节点类型

Stmt

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

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

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

节点类型

Stmt

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

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

节点类型

Stmt

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

表示导入标记的节点。

节点类型

Stmt

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

表示include标记的节点。

节点类型

Stmt

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

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

节点类型

Stmt

class jinja2.nodes.Output(nodes)

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

节点类型

Stmt

class jinja2.nodes.OverlayScope(context, body)

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

示例用法:

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

2.10 新版功能.

节点类型

Stmt

class jinja2.nodes.Scope(body)

人造镜。

节点类型

Stmt

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

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

2.9.3 新版功能.

节点类型

Stmt

class jinja2.nodes.Template(body)

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

节点类型

Node

exception jinja2.nodes.Impossible

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