ホームページ >ウェブフロントエンド >htmlチュートリアル >Jinja2 中国語 document_html/css_WEB-ITnose
Jinja2 中国語 document_html/css_WEB-ITnose
- WBOYオリジナル
- 2016-06-21 08:49:003985ブラウズ
このドキュメントでは、テンプレート エンジンの構文と意味構造について説明しており、Jinja テンプレートを作成する際の非常に役立つリファレンスです。テンプレート エンジンは非常に柔軟であるため、アプリケーションの構成は、区切り文字と未定義の値の動作の点で、ここでの構成とは若干異なります。
テンプレートは単なるテキスト ファイルです。あらゆるテキストベースの形式 (HTML、XML、CSV、LaTex など) を生成できます。 特定の拡張子はなく、.html または .xml の両方を使用できます。
テンプレートには 変数 または 式 が含まれており、どちらもテンプレートが評価されるときに値に置き換えられます。テンプレートには、テンプレートのロジックを制御するためのタグもあります。テンプレートの構文は、Django と Python から大きく影響を受けています。
以下は、基本のいくつかを示す最小限のテンプレートです。詳細については、ドキュメントの後半で説明します。
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"><html lang="en"><head> <title>My Webpage</title></head><body> <ul id="navigation"> {% for item in navigation %} <li><a href="{{ item.href }}">{{ item.caption }}</a></li> {% endfor %} </ul> <h1>My Webpage</h1> {{ a_variable }}</body></html> これにはデフォルト設定が含まれています。アプリ開発者は、構文を {% foo %} から b581f2cd1116351231646c8f2d13e28e などに変更することもできます。
ここには、{% ... %} と {{ ... }} の 2 つの区切り文字があります。前者は for ループや代入などのステートメントを実行するために使用され、後者は式の結果をテンプレートに出力します。
アプリケーションは変数をテンプレートに渡しますが、テンプレート内で混乱する可能性があります。変数には、アクセスできるプロパティや要素を含めることもできます。変数がどのように見えるかは、アプリケーションが提供するものに完全に依存します。
ドット (.) を使用して変数のプロパティにアクセスすることも、いわゆる「添え字」構文 ([]) を使用することもできます。次の行も同じ効果があります:
{{ foo.bar }}{{ foo['bar'] }} 中括弧は変数の一部ではなく、print ステートメントの一部であることを理解しておくことが重要です。ラベルに括弧を付けずに変数にアクセスした場合。
変数またはプロパティが存在しない場合は、未定義の値が返されます。このタイプの値で何ができるかはアプリケーションの構成によって異なります。デフォルトの動作では、値が出力されると空の文字列に評価され、それを反復処理できますが、他の操作は失敗します。
実装
便宜上、Jinja2 の foo.bar は Python 層で次の処理を実行します。
- foo に名前があるかどうかを確認します。バーの属性。
- foo に 'bar' 項目があるかどうかを確認します (ない場合)。
- そうでない場合は、未定義のオブジェクトを返します。
foo['bar'] は、順序がわずかに異なるだけで逆の処理を行います。
- foo に 'bar' 項目があるかどうかを確認します。
- そうでない場合は、foo に bar という名前のプロパティがあるかどうかを確認します。
- そうでない場合は、未定義のオブジェクトを返します。
これは、オブジェクトに同じ名前の項目とプロパティがある場合に重要です。さらに、属性のみを検索するフィルターもあります。
変数は フィルター を介して変更できます。フィルターと変数はパイプ記号 (|) で区切られ、括弧を使用してオプションのパラメーターを渡すこともできます。複数のフィルターをチェーンで呼び出すことができ、前のフィルターの出力が次のフィルターの入力として使用されます。
たとえば、{{ name|striptags|title }} は、name 内のすべての HTML タグを削除し、タイトル スタイルの大文字と小文字の形式に書き換えます。フィルターは、関数呼び出しと同様に、かっこ内のパラメーターを受け入れます。この例では、リストをコンマで結合します: {{ list|join(', ') }}。
次のセクションでは、すべての組み込みフィルターについて説明します。
フィルターに加えて、いわゆる「テスト」も利用できます。テストを使用すると、変数を通常の式に対してテストできます。 変数または式をテストするには、変数とテスト名の後に is を追加します。たとえば、値が定義されているかどうかを確認するには、name is Definition を使用します。これは、name が定義されているかどうかに応じて true または false を返します。
テストではパラメータを受け入れることもできます。テストがパラメーターを 1 つだけ受け入れる場合は、括弧を省略してパラメーターをグループ化できます。たとえば、次の 2 つの式は同じことを行います。
{% if loop.index is divisibleby 3 %}{% if loop.index is divisibleby(3) %} 以下のセクションでは、すべての組み込みテストについて説明します。
テンプレート内の行の一部をコメントアウトするには、デフォルトで {# ... #} コメント構文が使用されます。これは、自分自身や他のテンプレート設計者に情報をデバッグしたり追加したりするときに役立ちます。
{# note: disabled template because we no longer use this {% for user in users %} ... {% endfor %}#}
デフォルト設定では、テンプレート エンジンは空白文字をさらに変更しません。したがって、すべての空白類 (スペース、タブ、改行など) は変更されずに返されます。アプリケーションが Jinja の Trim_blocks で構成されている場合、テンプレート タグの後の最初の改行は (PHP と同様に) 自動的に削除されます。
また、テンプレートから空白を手動で削除することもできます。ブロック (for タグ、コメント、変数式など) の先頭または末尾にマイナス記号 (-) を置くと、ブロックの前後の空白が削除されます:
{% for item in seq -%} {{ item }}{%- endfor %} これにより、間に空白を含まないすべての要素が生成されます。 seq が 1 から 9 までの数値のリストの場合、出力は 123456789 になります。
如果开启了，它们会自动去除行首的空白。
提示
标签和减号之间不能有空白。
有效的:
{%- if foo -%}...{% endif %} 无效的:
{% - if foo - %}...{% endif %}
有时想要或甚至必要让 Jinja 忽略部分，不会把它作为变量或块来处理。例如，如果 使用默认语法，你想在在使用把 {{作为原始字符串使用，并且不会开始一个变量 的语法结构，你需要使用一个技巧。
最简单的方法是在变量分隔符中（ {{）使用变量表达式输出:
{{ '{{' }} 对于较大的段落，标记一个块为 raw是有意义的。例如展示 Jinja 语法的实例， 你可以在模板中用这个片段:
{% raw %} <ul> {% for item in seq %} <li>{{ item }}</li> {% endfor %} </ul>{% endraw %}
如果应用启用了行语句，就可以把一个行标记为一个语句。例如如果行语句前缀配置为 #，下面的两个例子是等价的:
<ul># for item in seq <li>{{ item }}</li># endfor</ul><ul>{% for item in seq %} <li>{{ item }}</li>{% endfor %}</ul> 行语句前缀可以出现在一行的任意位置，只要它前面没有文本。为了语句有更好的可读 性，在块的开始（比如 for、 if、 elif等等）以冒号结尾:
# for item in seq: ...# endfor
提示
若有未闭合的圆括号、花括号或方括号，行语句可以跨越多行:
<ul># for href, caption in [('index.html', 'Index'), ('about.html', 'About')]: <li><a href="{{ href }}">{{ caption }}</a></li># endfor</ul> 从 Jinja 2.2 开始，行注释也可以使用了。例如如果配置 ##为行注释前缀， 行中所有 ##之后的内容（不包括换行符）会被忽略:
# for item in seq: <li>{{ item }}</li> ## this comment is ignored# endfor
Jinja 中最强大的部分就是模板继承。模板继承允许你构建一个包含你站点共同元素的基 本模板“骨架”，并定义子模板可以覆盖的 块。
听起来复杂，实际上很简单。从例子上手是最易于理解的。
这个模板，我们会把它叫做 base.html，定义了一个简单的 HTML 骨架文档，你可 能使用一个简单的两栏页面。用内容填充空的块是子模板的工作:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"><html lang="en"><html xmlns="http://www.w3.org/1999/xhtml"><head> {% block head %} <link rel="stylesheet" href="style.css" /> <title>{% block title %}{% endblock %} - My Webpage</title> {% endblock %}</head><body> <div id="content">{% block content %}{% endblock %}</div> <div id="footer"> {% block footer %} © Copyright 2008 by <a href="http://domain.invalid/">you</a>. {% endblock %} </div></body> 在本例中， {% block %}标签定义了四个字幕版可以填充的块。所有的 block标签 告诉模板引擎子模板可以覆盖模板中的这些部分。
一个子模板看起来是这样:
{% extends "base.html" %}{% block title %}Index{% endblock %}{% block head %} {{ super() }} <style type="text/css"> .important { color: #336699; } </style>{% endblock %}{% block content %} <h1>Index</h1> <p class="important"> Welcome on my awesome homepage. </p>{% endblock %} {% extend %}标签是这里的关键。它告诉模板引擎这个模板“继承”另一个模板。 当模板系统对这个模板求值时，首先定位父模板。 extends 标签应该是模板中的第一个 标签。它前面的所有东西都会按照普通情况打印出来，而且可能会导致一些困惑。更多 该行为的细节以及如何利用它，见 Null-Master 退回 。
模板的文件名依赖于模板加载器。例如 FileSystemLoader允许你用文件名访 问其它模板。你可以使用斜线访问子目录中的模板:
{% extends "layout/default.html" %} 这种行为也可能依赖于应用内嵌的 Jinja 。注意子模板没有定义 footer块，会 使用父模板中的值。
你不能在同一个模板中定义多个同名的 {% block %}标签。因为块标签以两种 方向工作，所以存在这种限制。即一个块标签不仅提供一个可以填充的部分，也在父级 定义填充的内容。如果同一个模板中有两个同名的 {% blok %}标签，父模板 无法获知要使用哪一个块的内容。
如果你想要多次打印一个块，无论如何你可以使用特殊的 self变量并调用与块同名 的函数:
<title>{% block title %}{% endblock %}</title><h1>{{ self.title() }}</h1>{% block body %}{% endblock %}
可以调用 super来渲染父级块的内容。这会返回父级块的结果:
{% block sidebar %} <h3>Table Of Contents</h3> ... {{ super() }}{% endblock %}
Jinja2 允许你在块的结束标签中加入的名称来改善可读性:
{% block sidebar %} {% block inner_sidebar %} ... {% endblock inner_sidebar %}{% endblock sidebar %} 无论如何， endblock后面的名称一定与块名匹配。
嵌套块可以胜任更复杂的布局。而默认的块不允许访问块外作用域中的变量:
{% for item in seq %} <li>{% block loop_item %}{{ item }}{% endblock %}</li>{% endfor %} 这个例子会输出空的 25edfb22a4f469ecb59f1190150159c6项，因为 item在块中是不可用的。其原因是，如果 块被子模板替换，变量在其块中可能是未定义的或未被传递到上下文。
从 Jinja 2.2 开始，你可以显式地指定在块中可用的变量，只需在块声明中添加 scoped修饰，就把块设定到作用域中:
{% for item in seq %} <li>{% block loop_item scoped %}{{ item }}{% endblock %}</li>{% endfor %} 当覆盖一个块时，不需要提供 scoped修饰。
Changed in version 2.4.
当一个模板对象被传递到模板上下文，你也可以从那个对象继承。假设调用 代码传递 layout_template布局模板到环境，这段代码会工作:
{% extends layout_template %} 之前 layout_template变量一定是布局模板文件名的字符串才能工作。
当从模板生成 HTML 时，始终有这样的风险:变量包含影响已生成 HTML 的字符。有两种 解决方法:手动转义每个字符或默认自动转义所有的东西。
Jinja 两者都支持，使用哪个取决于应用的配置。默认的配置未开启自动转义有这样几个 原因:
- 转义所有非安全值的东西也意味着 Jijna 转义已知不包含 HTML 的值，比如数字，对 性能有巨大影响。
- 关于变量安全性的信息是易碎的。可能会发生强制标记一个值为安全或非安全的情况， 而返回值会被作为 HTML 转义两次。
如果启用了手动转义，按需转义变量就是 你的责任。要转义什么？如果你有 一个 可能包含 >、 5bb7f261199b602b62d38db32b933ad7如果左边大于右边，返回 true。 >=如果左边大于等于右边，返回 true。 686201278019344f4090b3be47bda6a6 if 3a6499ea9b9c00d329007a2414eccaf8 else 38968bac8afe253e17a6756ab3230541。
else部分是可选的。如果没有显式地提供 else 块，会求值一个未定义对象:
{{ '[%s]' % page.title if page.title }} abs ( number )
Return the absolute value of the argument.
attr ( obj, name )
Get an attribute of an object. foo|attr("bar")works like foo["bar"]just that always an attribute is returned and items are not looked up.
See Notes on subscriptions for more details.
batch ( value, linecount, fill_with=None )
A filter that batches items. It works pretty much like slicejust the other way round. It returns a list of lists with the given number of items. If you provide a second parameter this is used to fill up missing items. See this example:
<table>{%- for row in items|batch(3, ' ') %} <tr> {%- for column in row %} <td>{{ column }}</td> {%- endfor %} </tr>{%- endfor %}</table> capitalize ( s )
Capitalize a value. The first character will be uppercase, all others lowercase.
center ( value, width=80 )
Centers the value in a field of a given width.
default ( value, default_value=u'', boolean=False )
If the value is undefined it will return the passed default value, otherwise the value of the variable:
{{ my_variable|default('my_variable is not defined') }} This will output the value of my_variableif the variable was defined, otherwise 'my_variable is not defined'. If you want to use default with variables that evaluate to false you have to set the second parameter to true:
{{ ''|default('the string was empty', true) }} | Aliases : | d |
|---|
Sort a dict and yield (key, value) pairs. Because python dicts are unsorted you may want to use this function to order them by either key or value:
{% for item in mydict|dictsort %} sort the dict by key, case insensitive{% for item in mydict|dictsort(true) %} sort the dict by key, case sensitive{% for item in mydict|dictsort(false, 'value') %} sort the dict by key, case insensitive, sorted normally and ordered by value. escape ( s )
Convert the characters &, 95ec6993dc754240360e28e0de8de30a, ‘, and ” in string s to HTML-safe sequences. Use this if you need to display text that might contain such characters in HTML. Marks return value as markup string.
| Aliases : | e |
|---|
Format the value like a ‘human-readable’ file size (i.e. 13 kB, 4.1 MB, 102 Bytes, etc). Per default decimal prefixes are used (Mega, Giga, etc.), if the second parameter is set to Truethe binary prefixes are used (Mebi, Gibi).
first ( seq )
Return the first item of a sequence.
float ( value, default=0.0 )
Convert the value into a floating point number. If the conversion doesn’t work it will return 0.0. You can override this default using the first parameter.
forceescape ( value )
Enforce HTML escaping. This will probably double escape variables.
format ( value, *args, **kwargs )
Apply python string formatting on an object:
{{ "%s - %s"|format("Hello?", "Foo!") }} -> Hello? - Foo! groupby ( value, attribute )
Group a sequence of objects by a common attribute.
If you for example have a list of dicts or objects that represent persons with gender, first_nameand last_nameattributes and you want to group all users by genders you can do something like the following snippet:
<ul>{% for group in persons|groupby('gender') %} <li>{{ group.grouper }}<ul> {% for person in group.list %} <li>{{ person.first_name }} {{ person.last_name }}</li> {% endfor %}</ul></li>{% endfor %}</ul> Additionally it’s possible to use tuple unpacking for the grouper and list:
<ul>{% for grouper, list in persons|groupby('gender') %} ...{% endfor %}</ul> As you can see the item we’re grouping by is stored in the grouperattribute and the listcontains all the objects that have this grouper in common.
Changed in version 2.6:It’s now possible to use dotted notation to group by the child attribute of another attribute.
indent ( s, width=4, indentfirst=False )
Return a copy of the passed string, each line indented by 4 spaces. The first line is not indented. If you want to change the number of spaces or indent the first line too you can pass additional parameters to the filter:
{{ mytext|indent(2, true) }} indent by two spaces and indent the first line too. int ( value, default=0 )
Convert the value into an integer. If the conversion doesn’t work it will return 0. You can override this default using the first parameter.
join ( value, d=u'', attribute=None )
Return a string which is the concatenation of the strings in the sequence. The separator between elements is an empty string per default, you can define it with the optional parameter:
{{ [1, 2, 3]|join('|') }} -> 1|2|3{{ [1, 2, 3]|join }} -> 123 It is also possible to join certain attributes of an object:
{{ users|join(', ', attribute='username') }} New in version 2.6:The attributeparameter was added.
last ( seq )
Return the last item of a sequence.
length ( object )
Return the number of items of a sequence or mapping.
| Aliases : | count |
|---|
Convert the value into a list. If it was a string the returned list will be a list of characters.
lower ( s )
Convert a value to lowercase.
map ( )
Applies a filter on a sequence of objects or looks up an attribute. This is useful when dealing with lists of objects but you are really only interested in a certain value of it.
The basic usage is mapping on an attribute. Imagine you have a list of users but you are only interested in a list of usernames:
Users on this page: {{ users|map(attribute='username')|join(', ') }} Alternatively you can let it invoke a filter by passing the name of the filter and the arguments afterwards. A good example would be applying a text conversion filter on a sequence:
Users on this page: {{ titles|map('lower')|join(', ') }} New in version 2.7.
pprint ( value, verbose=False )
Pretty print a variable. Useful for debugging.
With Jinja 1.2 onwards you can pass it a parameter. If this parameter is truthy the output will be more verbose (this requires pretty)
random ( seq )
Return a random item from the sequence.
reject ( )
Filters a sequence of objects by appying a test to either the object or the attribute and rejecting the ones with the test succeeding.
Example usage:
{{ numbers|reject("odd") }} New in version 2.7.
rejectattr ( )
Filters a sequence of objects by appying a test to either the object or the attribute and rejecting the ones with the test succeeding.
{{ users|rejectattr("is_active") }}{{ users|rejectattr("email", "none") }} New in version 2.7.
replace ( s, old, new, count=None )
Return a copy of the value with all occurrences of a substring replaced with a new one. The first argument is the substring that should be replaced, the second is the replacement string. If the optional third argument countis given, only the first countoccurrences are replaced:
{{ "Hello World"|replace("Hello", "Goodbye") }} -> Goodbye World{{ "aaaaargh"|replace("a", "d'oh, ", 2) }} -> d'oh, d'oh, aaargh reverse ( value )
Reverse the object or return an iterator the iterates over it the other way round.
round ( value, precision=0, method='common' )
Round the number to a given precision. The first parameter specifies the precision (default is 0), the second the rounding method:
- 'common'rounds either up or down
- 'ceil'always rounds up
- 'floor'always rounds down
If you don’t specify a method 'common'is used.
{{ 42.55|round }} -> 43.0{{ 42.55|round(1, 'floor') }} -> 42.5 Note that even if rounded to 0 precision, a float is returned. If you need a real integer, pipe it through int:
{{ 42.55|round|int }} -> 43 safe ( value )
Mark the value as safe which means that in an environment with automatic escaping enabled this variable will not be escaped.
select ( )
Filters a sequence of objects by appying a test to either the object or the attribute and only selecting the ones with the test succeeding.
Example usage:
{{ numbers|select("odd") }} New in version 2.7.
selectattr ( )
Filters a sequence of objects by appying a test to either the object or the attribute and only selecting the ones with the test succeeding.
Example usage:
{{ users|selectattr("is_active") }}{{ users|selectattr("email", "none") }} New in version 2.7.
slice ( value, slices, fill_with=None )
Slice an iterator and return a list of lists containing those items. Useful if you want to create a div containing three ul tags that represent columns:
<div class="columwrapper"> {%- for column in items|slice(3) %} <ul class="column-{{ loop.index }}"> {%- for item in column %} <li>{{ item }}</li> {%- endfor %} </ul> {%- endfor %}</div> If you pass it a second argument it’s used to fill missing values on the last iteration.
sort ( value, reverse=False, case_sensitive=False, attribute=None )
Sort an iterable. Per default it sorts ascending, if you pass it true as first argument it will reverse the sorting.
If the iterable is made of strings the third parameter can be used to control the case sensitiveness of the comparison which is disabled by default.
{% for item in iterable|sort %} ...{% endfor %} It is also possible to sort by an attribute (for example to sort by the date of an object) by specifying the attributeparameter:
{% for item in iterable|sort(attribute='date') %} ...{% endfor %} Changed in version 2.6:The attributeparameter was added.
string ( object )
Make a string unicode if it isn’t already. That way a markup string is not converted back to unicode.
striptags ( value )
Strip SGML/XML tags and replace adjacent whitespace by one space.
sum ( iterable, attribute=None, start=0 )
Returns the sum of a sequence of numbers plus the value of parameter ‘start’ (which defaults to 0). When the sequence is empty it returns start.
It is also possible to sum up only certain attributes:
Total: {{ items|sum(attribute='price') }} Changed in version 2.6:The attributeparameter was added to allow suming up over attributes. Also the startparameter was moved on to the right.
title ( s )
Return a titlecased version of the value. I.e. words will start with uppercase letters, all remaining characters are lowercase.
trim ( value )
Strip leading and trailing whitespace.
truncate ( s, length=255, killwords=False, end='...' )
Return a truncated copy of the string. The length is specified with the first parameter which defaults to 255. If the second parameter is truethe filter will cut the text at length. Otherwise it will discard the last word. If the text was in fact truncated it will append an ellipsis sign ( "..."). If you want a different ellipsis sign than "..."you can specify it using the third parameter.
{{ "foo bar"|truncate(5) }} -> "foo ..."{{ "foo bar"|truncate(5, True) }} -> "foo b..." upper ( s )
Convert a value to uppercase.
urlencode ( value )
Escape strings for use in URLs (uses UTF-8 encoding). It accepts both dictionaries and regular strings as well as pairwise iterables.
New in version 2.7.
urlize ( value, trim_url_limit=None, nofollow=False )
Converts URLs in plain text into clickable links.
If you pass the filter an additional integer it will shorten the urls to that number. Also a third argument exists that makes the urls “nofollow”:
{{ mytext|urlize(40, true) }} links are shortened to 40 chars and defined with rel="nofollow" wordcount ( s )
Count the words in that string.
wordwrap ( s, width=79, break_long_words=True, wrapstring=None )
Return a copy of the string passed to the filter wrapped after 79characters. You can override this default using the first parameter. If you set the second parameter to falseJinja will not split words apart if they are longer than width. By default, the newlines will be the default newlines for the environment, but this can be changed using the wrapstring keyword argument.
New in version 2.7:Added support for the wrapstringparameter.
xmlattr ( d, autospace=True )
Create an SGML/XML attribute string based on the items in a dict. All values that are neither nonenor undefinedare automatically escaped:
<ul{{ {'class': 'my_list', 'missing': none, 'id': 'list-%d'|format(variable)}|xmlattr }}>...</ul> Results in something like this:
<ul class="my_list" id="list-42">...</ul>
As you can see it automatically prepends a space in front of the item if the filter returned something unless the second parameter is false.
callable ( object )
Return whether the object is callable (i.e., some kind of function). Note that classes are callable, as are instances with a __call__() method.
defined ( value )
Return true if the variable is defined:
{% if variable is defined %} value of variable: {{ variable }}{% else %} variable is not defined{% endif %} See thefilter for a simple way to set undefined variables.
divisibleby ( value, num )
Check if a variable is divisible by a number.
escaped ( value )
Check if the value is escaped.
even ( value )
Return true if the variable is even.
iterable ( value )
Check if it’s possible to iterate over an object.
lower ( value )
Return true if the variable is lowercased.
mapping ( value )
Return true if the object is a mapping (dict etc.).
New in version 2.6.
none ( value )
Return true if the variable is none.
number ( value )
Return true if the variable is a number.
odd ( value )
Return true if the variable is odd.
sameas ( value, other )
Check if an object points to the same memory address than another object:
{% if foo.attribute is sameas false %} the foo attribute really is the `False` singleton{% endif %} sequence ( value )
Return true if the variable is a sequence. Sequences are variables that are iterable.
string ( value )
Return true if the object is a string.
undefined ( value )
Likebut the other way round.
upper ( value )
Return true if the variable is uppercased.
默认下，下面的函数在全局作用域中可用:
range ( [ start ], stop [, step ] )
返回一个包含整等差级数的列表。 range(i, j) 返回 [i, i+1, i+2, ...., j-1] ；起始值（！）默认为 0 。当给定了公差，它决定了增长（或减小）。 例如 range(4) 返回 [0, 1, 2, 3] 。末端的值被丢弃了。这些是一个 4 元素 数组的有效索引值。
例如重复一个模板块多次来填充一个列表是有用的。想向你有一个 7 个用户的 列表，但你想要渲染三个空项目来用 CSS 强制指定高度:
<ul>{% for user in users %} <li>{{ user.username }}</li>{% endfor %}{% for number in range(10 - users|count) %} <li class="empty"><span>...</span></li>{% endfor %}</ul> lipsum ( n=5, html=True, min=20, max=100 )
在模板中生成 lorem ipsum 乱数假文。默认会生成 5 段 HTML ，每段在 20 到 100 词之间。如果 HTML 被禁用，会返回常规文本。这在测试布局时生成简单内容时很有 用。
dict ( **items )
方便的字典字面量替代品。 {'foo' : 'bar'}与 dict(foo=bar)等价。
class cycler ( *items )
周期计允许你在若干个值中循环，类似 loop.cycle的工作方式。不同于 loop.cycle的是，无论如何你都可以在循环外或在多重循环中使用它。
比如如果你想要显示一个文件夹和文件列表，且文件夹在上，它们在同一个列表中且 行颜色是交替的。
下面的例子展示了如何使用周期计:
{% set row_class = cycler('odd', 'even') %}<ul class="browser">{% for folder in folders %} <li class="folder {{ row_class.next() }}">{{ folder|e }}</li>{% endfor %}{% for filename in files %} <li class="file {{ row_class.next() }}">{{ filename|e }}</li>{% endfor %}</ul>周期计有下面的属性和方法: reset ( )
重置周期计到第一个项。
next ( )
返回当前项并跳转到下一个。
current
返回当前项。.
New in version 2.1.
class joiner ( sep=', ' )
一个小巧的辅助函数用于“连接”多个节。连接器接受一个字符串，每次被调用时返回 那个字符串，除了第一次调用时返回一个空字符串。你可以使用它来连接:
{% set pipe = joiner("|") %}{% if categories %} {{ pipe() }} Categories: {{ categories|join(", ") }}{% endif %}{% if author %} {{ pipe() }} Author: {{ author() }}{% endif %}{% if can_edit %} {{ pipe() }} <a href="?action=edit">Edit</a>{% endif %} New in version 2.1.
下面的几节涵盖了可能被应用启用的 Jinja2 内置的扩展。应用也可以提供进一步 的扩展，但这不会在此描述。会有独立的文档来解释那种情况下的扩展。
如果启用来 i18n 扩展，可以把模板中的部分标记为可译的。标记一个段为可译的，可 以使用 trans:
<p>{% trans %}Hello {{ user }}!{% endtrans %}</p> 要翻译一个模板表达式——比如使用模板过滤器或访问对象的属性——你需要绑定表达式到 一个名称来在翻译块中使用:
<p>{% trans user=user.username %}Hello {{ user }}!{% endtrans %}</p> 如果你需要在 trans标签中绑定一个以上的表达式，用逗号来分割（ ,）:
{% trans book_title=book.title, author=author.name %}This is {{ book_title }} by {{ author }}{% endtrans %} 在翻译块中不允许使用语句，只能使用变量标签。
为表示复数，在 trans和 endtrans之间用 pluralize标签同时指定单数和复 数形式:
{% trans count=list|length %}There is {{ count }} {{ name }} object.{% pluralize %}There are {{ count }} {{ name }} objects.{% endtrans %} 默认情况下块中的第一个变量用于决定使用单数还是复数。如果这不奏效，你可以指定 用于复数的名称作为 pluralize的参数:
{% trans ..., user_count=users|length %}...{% pluralize user_count %}...{% endtrans %} 也可以翻译表达式中的字符串。为此，有三个函数:
_ gettext: 翻译一个单数字符串 - ngettext: 翻译一个复数字符串 - _: gettext的别名
例如你可以容易地这样打印一个已翻译的字符串:
{{ _('Hello World!') }} 你可以使用 format过滤器来使用占位符:
{{ _('Hello %(user)s!')|format(user=user.username) }} 因为其它语言可能不会用同样的顺序使用词汇，要使用多个占位符，应始终用字符 串参数传给 format。
Changed in version 2.5.
如果激活了新样式的 gettext 调用（ 新样式 Gettext ），使用占位符 会更加简单:
{{ gettext('Hello World!') }}{{ gettext('Hello %(name)s!', name='World') }}{{ ngettext('%(num)d apple', '%(num)d apples', apples|count) }} 注意 ngettext函数的格式化字符串自动接受 num参数作为计数作为附加的 常规参数。
如果加载了表达式语句扩展，一个名为 do的扩展即可用。它工作几乎如同常规的变量 表达式（ {{ ... }}），只是它不打印任何东西。这可以用于修改列表:
{% do navigation.append('a string') %}
如果应用启用来 循环控制 ，则可以在循环中使用 break和 continue。到达 break时，循环终止。到达 continue时，当前处理会终止并 从下一次迭代继续。
这个循环每两项跳过一次:
{% for user in users %} {%- if loop.index is even %}{% continue %}{% endif %} ...{% endfor %} 同样，这个循环 10 次迭代之后会终止处理:
{% for user in users %} {%- if loop.index >= 10 %}{% break %}{% endif %}{%- endfor %}
New in version 2.3.
如果应用启用了 With 语句 ，将允许在模板中使用 with关键 字。这使得创建一个新的内作用域。这个作用域中的变量在外部是不可见的。
With 用法简介:
{% with %} {% set foo = 42 %} {{ foo }} foo is 42 here{% endwith %}foo is not visible here any longer 因为在作用域的开始设置变量很常见，你可以在 with 语句里这么做。下面的两 个例子是等价的:
{% with foo = 42 %} {{ foo }}{% endwith %}{% with %} {% set foo = 42 %} {{ foo }}{% endwith %}
New in version 2.4.
如果你的应用程序设置了 自动转义扩展 ，你就可以在模版中开启或者关闭自动转义。
例子:
{% autoescape true %}自动转义在这块文本中是开启的。{% endautoescape %}{% autoescape false %}自动转义在这块文本中是关闭的。{% endautoescape %} 在 endautoescape标签之后，自动转义的行为将回到与之前相同的状态。