扩展

Jinja2 支持扩展来添加过滤器、测试、全局变量或者甚至是处理器。 扩展的主要动力是 把诸如添加国际化支持的常用代码迁移到一个可重用的类。

添加扩展

扩展在 Jinja2 环境创建时被添加。 一旦环境被创建，就不能添加额外的扩展。 要添加 一个扩展，传递一个扩展类或导入路径的列表到 Environment 构造函数的 environment 参数。 下面的例子创建了一个加载了 i18n 扩展的 Jinja2 环境: 

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

i18n扩展

Import name: jinja2.ext.i18n

i18n扩展可以与gettext或babel组合使用。 如果启用了 i18n 扩展， Jinja2 提供了 trans 语句来标记被其包裹的 字符串为可翻译的，并调用 gettext 。

在启用虚拟的 _ 函数后，之后的 gettext 调用会被添加到环境的全局变量。 那么 一个国际化的应用应该不仅在全局，以及在每次渲染中在命名空间中提供至少一个 gettext 或可选的 ngettext 函数。

环境方法

在启用这个扩展后，环境提供下面的额外方法:

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

在该环境中全局安装翻译。 提供的翻译对象要至少实现 uggettext 和 ungettext 。 支持gettext.NullTranslations和gettext.GNUTranslations类以及Babel 翻译类。

Changed in version 2.5: 添加了新样式的 gettext

jinja2.Environment.install_null_translations(newstyle=False)

安装虚拟的 gettext 函数。 这在你想使应用为国际化做准备但还不想实现完整的 国际化系统时很有用。

Changed in version 2.5: 添加了新样式的 gettext

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

在环境中把给出的 gettext 和 ngettext 可调用量安装为全局变量。 它们 应该表现得几乎与标准库中的 gettext.ugettext() 和 gettext.ungettext() 函数相同。

如果激活了 新样式 ，可调用量被包装为新样式的可调用量一样工作。 更多 信息见 新样式 Gettext 。

版本2.5中的新功能。

jinja2.Environment.uninstall_gettext_translations()

再次卸载翻译。

jinja2.Environment.extract_translations(source)

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

对于每个字符串，此函数产生一个(lineno, function, message)元组，其中

  • lineno是找到字符串的行的编号，
  • function 是 gettext 函数使用的名称（如果字符串是从内嵌的 Python 代码中抽取的）。
  • message 是字符串本身（一个 unicode 对象，在函数有多个字符串参数 时是一个 unicode 对象的元组）。

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

对于一个对多种语言可用而对所有用户给出同一种的语言的 web 应用（例如一个法国社 区安全了一个多种语言的论坛软件）可能会一次性加载翻译并且在环境生成时把翻译方 法添加到环境上: 

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

get_get_translations 函数会返回当前配置的翻译器。 （比如使用 gettext.find ）

模板设计者的 i18n 扩展使用在 模板文档 中有描述。

新样式 Gettext

版本2.5中的新功能。

从版本 2.5 开始你可以使用新样式的 gettext 调用。 这些的启发源于 trac 的内部 gettext 函数并且完全被 babel 抽取工具支持。 如果你不使用Babel的话，它们可能无法像其他提取工具那样正常工作。

标准 gettext 调用和新样式的 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
)}}

新样式看起来是这样: 

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

新样式 gettext 的优势是你需要输入的更少，并且命名占位符是强制的。 后者看起 来似乎是缺陷，但解决了当翻译者不能切换两个占位符的位置时经常勉励的一大堆 麻烦。 使用新样式的 gettext ，所有的格式化字符串看起来都一样。

除此之外，在新样式 gettext 中，如果没有使用占位符，字符串格式化也会被使用， 这使得所有的字符串表现一致。 最后，不仅是新样式的 gettext 调用可以妥善地为 解决了许多转义相关问题的自动转义标记字符串，许多模板也在使用自动转义时体验 了多次。

表达式语句

Import name: jinja2.ext.do

“do”又叫做表达式语句扩展，向模板引擎添加了一个简单的 do 标签，其工作如同 一个变量表达式，只是忽略返回值。

循环控制

Import name: jinja2.ext.loopcontrols

此扩展添加对break和继续的循环支持。 在启用它之后， Jinja2 提供的这两个关键字如同 Python 中那样工作。

使用语句

Import name: jinja2.ext.with_

版本2.3中的新功能。

这个扩展添加了 with 关键字支持。 使用这个关键字可以在模板中强制一块嵌套的 作用域。 变量可以在 with 语句的块头中直接声明，或直接在里面使用标准的 set 语句。

自动转义扩展

Import name: jinja2.ext.autoescape

版本2.4中的新功能。

Push a token back to the stream. 如果环境的autoescape设置设置为False，则可以激活它，如果True，则可以禁用。 这个设定的覆盖是有作用域的。

编写扩展

你可以编写扩展来向 Jinja2 中添加自定义标签。 这是一个不平凡的任务，而且通常不需 要，因为默认的标签和表达式涵盖了所有常用情况。 如 i18n 扩展是一个扩展有用的好例 子，而另一个会是碎片缓存。 另一个是片段缓存。

当你编写扩展时，你需要记住你在与 Jinja2 模板编译器一同工作，而它并不验证你传递 到它的节点树。 如果 AST 是畸形的，你会得到各种各样的编译器或运行时错误，这调试起 来极其可怕。 始终确保你在使用创建正确的节点。 下面的 API 文档展示了有什么节点和如 何使用它们。

示例扩展

下面的例子用 Werkzeug 的缓存 contrib 模块为 Jinja2 实现了一个 cache 标签: 

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上的环境特定数据。这样做的原因是，通过创建副本并重新分配环境属性，可以将扩展绑定到另一个环境（对于叠加层）。

由于扩展由环境创建，因此它们不能接受任何用于配置的参数。人们可能希望通过使用工厂函数来解决这个问题，但是这是不可能的，因为扩展由它们的导入名称标识。配置扩展的正确方法是将配置值存储在环境中。因为这种方式环境最终作为中央配置存储的属性可能会冲突，这就是为什么扩展必须确保他们选择配置的名称不太通用。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)

调用扩展的方法。 Call a method of the extension. This is a shortcut for attr() + jinja2.nodes.Call.

filter_stream(stream)

它传递了一个TokenStream，可用于过滤返回的令牌。此方法必须返回可迭代的Token s，但不必返回TokenStream。

在Jinja2源分发的ext文件夹中有一个名为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 当前只附带一个扩展，就是 i18n 扩展。 它被传递给扩展，并且可以用于解析表达式或语句。

filename

解析器处理的模板文件名。 这 不是 模板的加载名。 对于装载名称，请参见name。 对于不是从文件系统中加载的模板，这个值为 None 。

name

模板的加载名。

stream

当前的 TokenStream 。

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

使用消息引发exc的方便方法，传递的行号或最后一个行号以及当前名称和文件名。

free_identifier(lineno=None)

Return a new free identifier as InternalName.

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

解析分配目标。由于Jinja2允许赋值到元组，这个函数可以解析所有允许的赋值目标。对于元组的默认分配会被解析，但可以通过将with_tuple设置为False来禁用。如果只需要对名称进行分配，name_only可以设置为True。extra_end_rules参数被转发到元组解析函数。

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节点。此方法也可以返回正则表达式而不是元组，如果没有找到逗号。

默认解析模式是一个完整的元组。如果simplified是True，则仅解析名称和文字。将no_condexpr参数转发到parse_expression()。

因为元组不需要分隔符，并且可以在虚假逗号中结束，需要额外的提示来标记元组的结尾。例如，for循环支持之间的和在中的元组。在这种情况下，extra_end_rules设置为['name:in']。

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

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

令牌流是可产生Token的迭代器。然而，解析器不会迭代它，而是调用next()前进一个令牌。当前活动令牌存储为current。

current

当前的 Token 。

eos

我们在流的尽头吗？

expect(expr)

期望给定的令牌类型并返回它。 Expect a given token type and return it. This accepts the same argument as jinja2.lexer.Token.test().

look()

看看下一个令牌。

next_if(expr)

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

push(token)

将令牌推回流。

skip(n=1)

前面有n个令牌。

skip_if(expr)

Like next_if() but only returns True or False.

class jinja2.lexer.Token

令牌类。

lineno

token 的行号。

type

token 的类型。 这个值是被禁锢的，所以你可以用 is 运算符同任意字符 串比较。

value

token 的值。

test(expr)

针对令牌表达式测试令牌。这可以是令牌类型或'token_type:token_value'。这只能测试字符串值和类型。

test_any(*iterable)

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

同样，在词法分析模块中也有一个实用函数可以计算字符串中的换行符数目:

jinja2.lexer.count_newlines(value)

计算字符串中换行符的数量。这对于过滤流的扩展程序很有用。

AST

AST（抽象语法树: Abstract Syntax Tree）用于表示解析后的模板。 它有编译器之后 转换到可执行的 Python 代码对象的节点构建。 提供自定义语句的扩展可以返回执行自 定义 Python 代码的节点。

下面的清单展示了所有当前可用的节点。 AST 在 Jinja2 的各个版本中有差异，但会向 后兼容。

更多信息请见 jinja2.Environment.parse() 。

class jinja2.nodes.Node

Token class. 有多个不同类型的节点可用。有四种主要类型：

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

find(node_type)

找到给定类型的第一个节点。如果不存在此类节点，则返回值为无。

find_all(node_type)

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

iter_child_nodes(exclude=None, only=None)

迭代节点的所有直接子节点。这遍历所有字段，并产生它们的值为节点。如果字段的值是列表，则返回该列表中的所有节点。

iter_fields(exclude=None, only=None)

此方法迭代所有定义的字段，并产生（键， 值）元组。默认情况下，返回所有字段，但可以通过提供参数或使用排除参数排除某些字段来限制某些字段。两者都应该是字段名称的集合或元组。

set_ctx(ctx)

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

set_environment(environment)

设置所有节点的环境。

set_lineno （ lineno，override = False ） ¶ t5 >

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

class jinja2.nodes.Expr

Baseclass for all expressions.

节点类型：Node
as_const(eval_ctx=None)

将表达式的值返回为常量，或者如果这不可能，则提高Impossible。

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

Changed in version 2.4: the eval_ctx parameter was added.

can_assign()

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

class jinja2.nodes.BinExpr(left, right)

Baseclass for all binary expressions.

节点类型： Expr
class jinja2.nodes.Add(left, right)

将左侧添加到右侧节点。

节点类型： BinExpr
class jinja2.nodes.And(left, right)

短路AND。

节点类型： 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)

短路OR。

节点类型： 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_args和dyn_kwargs必须是无或用作动态位置（*args）或关键字（**kwargs）参数。

节点类型： Expr
class jinja2.nodes.Compare(expr, ops)

将表达式与一些其他表达式进行比较。ops t>必须是Operand的列表。

节点类型： Expr
class jinja2.nodes.Concat(nodes)

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

节点类型： Expr
class jinja2.nodes.CondExpr(test, expr1, expr2)

条件表达式（inline if expression）。（{{ foo if bar else / t6> }}）

节点类型： Expr
class jinja2.nodes.ContextReference

返回当前模板上下文。它可以像Name节点和'load' ctx一样使用，并且将返回当前的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相同。

如果过滤器的节点为无，则过滤最后一个缓冲区的内容。缓冲区由宏和过滤器块创建。

节点类型： Expr
class jinja2.nodes.Getattr(node, attr, ctx)

A constant template string.

节点类型： Expr
class jinja2.nodes.Getitem(node, arg, ctx)

从表达式获取属性或项目，并且喜欢该项目。

节点类型： Expr
class jinja2.nodes.ImportedName(importname)

如果使用导入名称创建，则在节点访问上返回导入名称。例如ImportedName('cgi.escape')从评估的cgi模块返回escape函数。导入由编译器优化，因此不需要将它们分配给局部变量。

节点类型： Expr
class jinja2.nodes.InternalName(name)

编译器中的内部名称。您不能自己创建这些节点，但解析器提供了一个free_identifier()方法，为您创建一个新的标识符。此标识符不能从模板中获得，并且不是由编译器专门设置的。

节点类型： Expr
class jinja2.nodes.Literal

Baseclass for literals.

节点类型： Expr
class jinja2.nodes.Const(value)

所有常量值。解析器将为简单常量（例如42或"foo"）返回此节点，但它也可用于存储更复杂的值，例如列表。只有具有安全表示的常量（eval（repr（x）） == x 。

节点类型：Literal
class jinja2.nodes.Dict(items)

任何字典，如{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)

将包装的表达式标记为安全（将其换为标记）。

节点类型： Expr
class jinja2.nodes.MarkSafeIfAutoescape(expr)

将包装的表达式标记为安全（包装为标记），但仅当自动转义处于活动状态时。

版本2.5中的新功能。

节点类型： Expr
class jinja2.nodes.Name(name, ctx)

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

  • store：在名称中存储一个值
  • 加载：加载该名称
  • param：like store但是如果名称被定义为函数参数。
节点类型： 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)

Baseclass for all unary expressions.

节点类型： 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)

保存运算符和表达式。The following operators are available: %, **, *, +, -, //, /, eq, gt, gteq, in, lt, lteq, ne, not, notin

节点类型：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, body)

将块分配给目标。

节点类型： Stmt
class jinja2.nodes.Block(name, body, scoped)

表示块的节点。

节点类型： Stmt
class jinja2.nodes.Break

打破循环。

节点类型： Stmt
class jinja2.nodes.CallBlock(call, args, defaults, body)

像一个没有名称但是调用的宏。调用使用未命名宏作为此节点持有的调用者参数调用。

节点类型： Stmt
class jinja2.nodes.Continue

继续循环。

节点类型： Stmt
class jinja2.nodes.EvalContextModifier(options)

Break a loop. 对于应修改的每个选项，必须将Keyword添加到options列表中。

Example to change the autoescape setting: 

EvalContextModifier(options=[Keyword('autoescape', Const(True))])
节点类型： Stmt
class jinja2.nodes.ScopedEvalContextModifier(options, body)

修改eval上下文并稍后恢复。 Modifies the eval context and reverts it later. Works exactly like EvalContextModifier but will only modify the EvalContext for nodes in the body.

节点类型： EvalContextModifier
class jinja2.nodes.ExprStmt(node)

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

节点类型： Stmt
class jinja2.nodes.Extends(template)

表示extends语句。

节点类型： Stmt
class jinja2.nodes.FilterBlock(body, filter)

过滤器节点。

节点类型： Stmt
class jinja2.nodes.For(target, iter, body, else_, test, recursive)

for循环。target是迭代的目标（通常是Name或Tuple），iterbody是用作循环体的节点列表，else _是else块的节点列表。如果没有其他节点存在，它必须是一个空列表。

对于过滤的节点，表达式可以存储为test，否则为无。

节点类型： Stmt
class jinja2.nodes.FromImport(template, names, with_context)

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

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

节点类型： Stmt
class jinja2.nodes.If(test, body, else_)

如果test为真，则呈现主体，否则else _。

节点类型： Stmt
class jinja2.nodes.Import(template, target, with_context)

表示导入标记的节点。

节点类型： Stmt
class jinja2.nodes.Include(template, with_context, ignore_missing)

表示包含标记的节点。

节点类型： Stmt
class jinja2.nodes.Macro(name, args, defaults, body)

宏定义。name是宏的名称，args是参数列表，是默认值body是宏主体的节点列表。

节点类型： Stmt
class jinja2.nodes.Output(nodes)

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

节点类型： Stmt
class jinja2.nodes.Scope(body)

人工范围。

节点类型： Stmt
class jinja2.nodes.Template(body)

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

节点类型：Node
exception jinja2.nodes.Impossible

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