亚洲午夜一区二区三区电影院,亚洲天天做夜夜做天天欢人人

這份文檔描述了模板引擎中的語法和語義結構，對于創(chuàng)建 Jinja 模板是一份相當有用的參考。因為模板引擎非常靈活，應用中的配置會在分隔符和未定義值的行為方面與這里的配置有細微差異。

模板僅僅是文本文件。它可以生成任何基于文本的格式（HTML、XML、CSV、LaTex 等等）。它并沒有特定的擴展名， .html 或 .xml 都是可以的。

模板包含變量或 表達式，這兩者在模板求值的時候會被替換為值。模板中還有標簽，控制模板的邏輯。模板語法的大量靈感來自于 Django 和 Python 。

下面是一個最小的模板，它闡明了一些基礎。我們會在文檔中后面的部分解釋細節(jié):

<!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>

這包含了默認的設定。應用開發(fā)者也會把語法從 {% foo %} 改成 <% foo %> 或類似的東西。

這里有兩種分隔符: {% ... %} 和 {{ ... }} 。前者用于執(zhí)行諸如 for 循環(huán) 或賦值的語句，后者把表達式的結果打印到模板上。

應用把變量傳遞到模板，你可能在模板中弄混。變量上面也可以有你能訪問的屬性或元素。變量看起來是什么，完全取決于應用提供了什么。

你可以使用點（ . ）來訪問變量的屬性，作為替代，也可以使用所謂的“下標”語法（ [] ）。下面的幾行效果是一樣的:

知曉花括號不是變量的一部分，而是打印語句的一部分是重要的。如果你訪問標簽里的不帶括號的變量。

如果變量或屬性不存在，會返回一個未定義值。你可以對這類值做什么取決于應用的配置，默認的行為是它如果被打印，其求值為一個空字符串，并且你可以迭代它，但其它操作會失敗。

實現

為方便起見，Jinja2 中 foo.bar 在 Python 層中做下面的事情:

檢查 foo上是否有一個名為 bar的屬性。
如果沒有，檢查 foo中是否有一個 'bar' 項。
如果沒有，返回一個未定義對象。

foo['bar'] 的方式相反，只在順序上有細小差異:

檢查在 foo中是否有一個 'bar' 項。
如果沒有，檢查 foo上是否有一個名為 bar的屬性。
如果沒有，返回一個未定義對象。

如果一個對象有同名的項和屬性，這很重要。此外，有一個過濾器，它只查找屬性。

變量可以通過 過濾器修改。過濾器與變量用管道符號（ | ）分割，并且也可以用圓括號傳遞可選參數。多個過濾器可以鏈式調用，前一個過濾器的輸出會被作為后一個過濾器的輸入。

例如 {{ name|striptags|title }} 會移除 name中的所有 HTML 標簽并且改寫為標題樣式的大小寫格式。過濾器接受帶圓括號的參數，如同函數調用。這個例子會把一個列表用逗號連接起來: {{ list|join(', ') }} 。

下面的節(jié)介紹了所有的內置過濾器。

除了過濾器，所謂的“測試”也是可用的。測試可以用于對照普通表達式測試一個變量。要測試一個變量或表達式，你要在變量后加上一個 is以及測試的名稱。例如，要得出一個值是否定義過，你可以用 name is defined ，這會根據 name是否定義返回 true 或 false 。

測試也可以接受參數。如果測試只接受一個參數，你可以省去括號來分組它們。例如，下面的兩個表達式做同樣的事情:

{% if loop.index is divisibleby 3 %}{% if loop.index is divisibleby(3) %}

下面的章節(jié)介紹了所有的內置測試。

要把模板中一行的部分注釋掉，默認使用 {# ... #} 注釋語法。這在調試或添加給你自己或其它模板設計者的信息時是有用的:

{# 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 %} 標簽是這里的關鍵。它告訴模板引擎這個模板“繼承”另一個模板。當模板系統(tǒng)對這個模板求值時，首先定位父模板。 extends 標簽應該是模板中的第一個標簽。它前面的所有東西都會按照普通情況打印出來，而且可能會導致一些困惑。更多該行為的細節(jié)以及如何利用它，見 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 %}

這個例子會輸出空的 <li> 項，因為 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布局模板到環(huán)境，這段代碼會工作:

{% extends layout_template %}

之前 layout_template變量一定是布局模板文件名的字符串才能工作。

當從模板生成 HTML 時，始終有這樣的風險:變量包含影響已生成 HTML 的字符。有兩種解決方法:手動轉義每個字符或默認自動轉義所有的東西。

Jinja 兩者都支持，使用哪個取決于應用的配置。默認的配置未開啟自動轉義有這樣幾個原因:

轉義所有非安全值的東西也意味著 Jijna 轉義已知不包含 HTML 的值，比如數字，對性能有巨大影響。
關于變量安全性的信息是易碎的?？赡軙l(fā)生強制標記一個值為安全或非安全的情況，而返回值會被作為 HTML 轉義兩次。

如果啟用了手動轉義，按需轉義變量就是你的責任。要轉義什么？如果你有一個可能包含 > 、 < 、 & 或 ' 字符的變量，你必須轉義它，除非變量中的 HTML 有可信的良好格式。轉義通過用管道傳遞到過濾器 |e 來實現: {{ user.username|e }} 。

當啟用了自動轉移，默認會轉移一切，除非值被顯式地標記為安全的?？梢栽趹弥?標記，也可以在模板中使用 |safe過濾器標記。這種方法的主要問題是 Python 本身沒有被污染的值的概念，所以一個值是否安全的信息會丟失。如果這個信息丟失，會繼續(xù)轉義，你最后會得到一個轉義了兩次的內容。

但雙重轉義很容易避免，只需要依賴 Jinja2 提供的工具而不使用諸如字符串模運算符這樣的 Python 內置結構。

返回模板數據（宏、 super、 self.BLOCKNAME）的函數，其返回值總是被標記為安全的。

模板中的字符串字面量在自動轉義中被也被視為是不安全的。這是因為安全的字符串是一個對 Python 的擴展，而不是每個庫都能妥善地使用它。

控制結構指的是所有的那些可以控制程序流的東西 —— 條件（比如 if/elif/ekse ）、 for 循環(huán)、以及宏和塊之類的東西。控制結構在默認語法中以 {% .. %} 塊的形式出現。

遍歷序列中的每項。例如，要顯示一個由 users`變量提供的用戶列表:

<h1>Members</h1><ul>{% for user in users %} <li>{{ user.username|e }}</li>{% endfor %}</ul>

因為模板中的變量保留它們的對象屬性，可以迭代像 dict的容器:

<dl>{% for key, value in my_dict.iteritems() %} <dt>{{ key|e }}</dt> <dd>{{ value|e }}</dd>{% endfor %}</dl>

注意無論如何字典通常是無序的，所以你可能需要把它作為一個已排序的列表傳入到模板或使用 dictsort過濾器。

在一個 for 循環(huán)塊中你可以訪問這些特殊的變量:

變量	描述
loop.index	當前循環(huán)迭代的次數（從 1 開始）
loop.index0	當前循環(huán)迭代的次數（從 0 開始）
loop.revindex	到循環(huán)結束需要迭代的次數（從 1 開始）
loop.revindex0	到循環(huán)結束需要迭代的次數（從 0 開始）
loop.first	如果是第一次迭代，為 True 。
loop.last	如果是最后一次迭代，為 True 。
loop.length	序列中的項目數。
loop.cycle	在一串序列間期取值的輔助函數。見下面的解釋。

在 for 循環(huán)中，可以使用特殊的 loop.cycle輔助函數，伴隨循環(huán)在一個字符串/變量列表中周期取值:

{% for row in rows %} <li class='{{ loop.cycle('odd', 'even') }}'>{{ row }}</li>{% endfor %}

從 Jinja 2.1 開始，一個額外的 cycle輔助函數允許循環(huán)限定外的周期取值。更多信息請閱讀。

與 Python 中不同，模板中的循環(huán)內不能 break或 continue。但你可以在迭代中過濾序列來跳過項目。下面的例子中跳過了所有隱藏的用戶:

{% for user in users if not user.hidden %} <li>{{ user.username|e }}</li>{% endfor %}

好處是特殊的 loop可以正確地計數，從而不計入未迭代過的用戶。

如果因序列是空或者過濾移除了序列中的所有項目而沒有執(zhí)行循環(huán)，你可以使用 else渲染一個用于替換的塊:

<ul>{% for user in users %} <li>{{ user.username|e }}</li>{% else %} <li><em>no users found</em></li>{% endfor %}</ul>

也可以遞歸地使用循環(huán)。當你處理諸如站點地圖之類的遞歸數據時很有用。要遞歸地使用循環(huán)，你只需要在循環(huán)定義中加上 recursive修飾，并在你想使用遞歸的地方，對可迭代量調用 loop變量。

下面的例子用遞歸循環(huán)實現了站點地圖:

<ul class='sitemap'>{%- for item in sitemap recursive %} <li><a href='{{ item.href|e }}'>{{ item.title }}</a> {%- if item.children -%} <ul class='submenu'>{{ loop(item.children) }}</ul> {%- endif %}</li>{%- endfor %}</ul>

Jinja 中的 if語句可比 Python 中的 if 語句。在最簡單的形式中，你可以測試一個變量是否未定義，為空或 false:

{% if users %}<ul>{% for user in users %} <li>{{ user.username|e }}</li>{% endfor %}</ul>{% endif %}

像在 Python 中一樣，用 elif和 else來構建多個分支。你也可以用更復雜的:

{% if kenny.sick %} Kenny is sick.{% elif kenny.dead %} You killed Kenny! You bastard!!!{% else %} Kenny looks okay --- so far{% endif %}

If 也可以被用作并作為。

宏類似常規(guī)編程語言中的函數。它們用于把常用行為作為可重用的函數，取代手動重復的工作。

這里是一個宏渲染表單元素的小例子:

{% macro input(name, value='', type='text', size=20) -%} <input type='{{ type }}' name='{{ name }}' value='{{ value|e }}' size='{{ size }}'>{%- endmacro %}

在命名空間中，宏之后可以像函數一樣調用:

<p>{{ input('username') }}</p><p>{{ input('password', type='password') }}</p>

如果宏在不同的模板中定義，你需要首先使用。

在宏內部，你可以訪問三個特殊的變量:

varargs: 如果有多于宏接受的參數個數的位置參數被傳入，它們會作為列表的值保存在 varargs變量上。
kwargs: 同 varargs，但只針對關鍵字參數。所有未使用的關鍵字參數會存儲在這個特殊變量中。
caller: 如果宏通過標簽調用，調用者會作為可調用的宏被存儲在這個變量中。

宏也可以暴露某些內部細節(jié)。下面的宏對象屬性是可用的:

name: 宏的名稱。 {{ input.name }} 會打印 input 。
arguments: 一個宏接受的參數名的元組。
defaults: 默認值的元組。
catch_kwargs: 如果宏接受額外的關鍵字參數（也就是訪問特殊的 kwargs變量），為 true。
catch_varargs: 如果宏接受額外的位置參數（也就是訪問特殊的 varargs變量），為 true。
caller: 如果宏訪問特殊的 caller變量且由標簽調用，為 true。

如果一個宏的名稱以下劃線開始，它不是導出的且不能被導入。

在某些情況下，需要把一個宏傳遞到另一個宏。為此，可以使用特殊的 call塊。下面的例子展示了如何讓宏利用調用功能:

{% macro render_dialog(title, class='dialog') -%} <div class='{{ class }}'> <h2>{{ title }}</h2> <div class='contents'> {{ caller() }} </div> </div>{%- endmacro %}{% call render_dialog('Hello World') %} This is a simple dialog rendered by using a macro and a call block.{% endcall %}

也可以向調用塊傳遞參數。這在為循環(huán)做替換時很有用?？偠灾?，調用塊的工作方式幾乎與宏相同，只是調用塊沒有名稱。

這里是一個帶參數的調用塊的例子:

{% macro dump_users(users) -%} <ul> {%- for user in users %} <li><p>{{ user.username|e }}</p>{{ caller(user) }}</li> {%- endfor %} </ul>{%- endmacro %}{% call(user) dump_users(list_of_user) %} <dl> <dl>Realname</dl> <dd>{{ user.realname|e }}</dd> <dl>Description</dl> <dd>{{ user.description }}</dd> </dl>{% endcall %}

過濾器段允許你在一塊模板數據上應用常規(guī) Jinja2 過濾器。只需要把代碼用 filter節(jié)包裹起來:

{% filter upper %} This text becomes uppercase{% endfilter %}

在代碼塊中，你也可以為變量賦值。在頂層的（塊、宏、循環(huán)之外）賦值是可導出的，即可以從別的模板中導入。

賦值使用 set標簽，并且可以為多個變量賦值:

{% set navigation = [('index.html', 'Index'), ('about.html', 'About')] %}{% set key, value = call_something() %}

extends標簽用于從另一個模板繼承。你可以在一個文件中使用多次繼承，但是只會執(zhí)行其中的一個。見上面的關于的節(jié)。

塊用于繼承，同時作為占位符和用于替換的內容。節(jié)中詳細地介紹了塊。

include語句用于包含一個模板，并在當前命名空間中返回那個文件的內容渲染結果:

{% include 'header.html' %} Body{% include 'footer.html' %}

被包含的模板默認可以訪問活動的上下文中的變量。更多關于導入和包含的上下文行為見。

從 Jinja 2.2 開始，你可以把一句 include 用 ignore missing 標記，這樣如果模板不存在，Jinja 會忽略這條語句。當與 with 或 without context 語句聯(lián)合使用時，它必須被放在上下文可見性語句之前。這里是一些有效的例子:

{% include 'sidebar.html' ignore missing %}{% include 'sidebar.html' ignore missing with context %}{% include 'sidebar.html' ignore missing without context %}

New in version 2.2.

你也可以提供一個模板列表，它會在包含前被檢查是否存在。第一個存在的模板會被包含進來。如果給出了 ignore missing，且所有這些模板都不存在，會退化至不做任何渲染，否則將會拋出一個異常。

例子:

{% include ['page_detailed.html', 'page.html'] %}{% include ['special_sidebar.html', 'sidebar.html'] ignore missing %}

Changed in version 2.4:如果傳遞一個模板對象到模板上下文，你可以用 include包含這個對象。

Jinja2 支持在宏中放置經常使用的代碼。這些宏可以被導入，并不同的模板中使用。這與 Python 中的 import 語句類似。要知道的是，導入量會被緩存，并且默認下導入的模板不能訪問當前模板中的非全局變量。更多關于導入和包含的上下文行為見。

有兩種方式來導入模板。你可以把整個模板導入到一個變量或從其中導入請求特定的宏 /導出量。

比如我們有一個渲染表單（名為 forms.html）的助手模塊:

{% macro input(name, value='', type='text') -%} <input type='{{ type }}' value='{{ value|e }}' name='{{ name }}'>{%- endmacro %}{%- macro textarea(name, value='', rows=10, cols=40) -%} <textarea name='{{ name }}' rows='{{ rows }}' cols='{{ cols }}'>{{ value|e }}</textarea>{%- endmacro %}

最簡單靈活的方式是把整個模塊導入為一個變量。這樣你可以訪問屬性:

{% import 'forms.html' as forms %}<dl> <dt>Username</dt> <dd>{{ forms.input('username') }}</dd> <dt>Password</dt> <dd>{{ forms.input('password', type='password') }}</dd></dl><p>{{ forms.textarea('comment') }}</p>

此外你也可以從模板中導入名稱到當前的命名空間:

{% from 'forms.html' import input as input_field, textarea %}<dl> <dt>Username</dt> <dd>{{ input_field('username') }}</dd> <dt>Password</dt> <dd>{{ input_field('password', type='password') }}</dd></dl><p>{{ textarea('comment') }}</p>

名稱以一個或更多下劃線開始的宏和變量是私有的，不能被導入。

Changed in version 2.4:如果傳遞一個模板對象到模板上下文，從那個對象中導入。

默認下，每個包含的模板會被傳遞到當前上下文，而導入的模板不會。這樣做的原因是導入量不會像包含量被緩存，因為導入量經常只作容納宏的模塊。

無論如何，這當然也可以顯式地更改。通過在 import/include 聲明中直接添加 with context或 without context，當前的上下文可以傳遞到模板，而且不會自動禁用緩存。

這里有兩個例子:

{% from 'forms.html' import input with context %}{% include 'header.html' without context %}

提示

在 Jinja 2.0 中，被傳遞到被包含模板的上下文不包含模板中定義的變量。事實上，這不能工作:

{% for box in boxes %} {% include 'render_box.html' %}{% endfor %}

在 Jinja 2.0 中，被包含的模板 render_box.html 不能訪問 box。從 Jinja 2.1 開始， render_box.html 可以這么做。

Jinja 中到處都允許使用基本表達式。這像常規(guī)的 Python 一樣工作，即使你不用 Python 工作，你也會感受到其帶來的便利。

表達式最簡單的形式就是字面量。字面量表示諸如字符串和數值的 Python 對象。下面的字面量是可用的:

“Hello World”:: 雙引號或單引號中間的一切都是字符串。無論何時你需要在模板中使用一個字符串（比如函數調用、過濾器或只是包含或繼承一個模板的參數），它們都是有用的。
42 / 42.23:: 直接寫下數值就可以創(chuàng)建整數和浮點數。如果有小數點，則為浮點數，否則為整數。記住在 Python 里， 42 和 42.0 是不一樣的。
[‘list’, ‘of’, ‘objects’]:
(‘tuple’, ‘of’, ‘values’):: 元組與列表類似，只是你不能修改元組。如果元組中只有一個項，你需要以逗號結尾它。元組通常用于表示兩個或更多元素的項。更多細節(jié)見上面的例子。
{‘dict’: ‘of’, ‘key’: ‘and’, ‘value’: ‘pairs’}:: Python 中的字典是一種關聯(lián)鍵和值的結構。鍵必須是唯一的，并且鍵必須只有一個值。字典在模板中很少使用，罕用于諸如過濾器之類。
true / false:: true 永遠是 true ，而 false 始終是 false 。

提示

特殊常量 true、 false和 none實際上是小寫的。因為這在過去會導致混淆，過去 True擴展為一個被認為是 false 的未定義的變量。所有的這三個常量也可以被寫成首字母大寫（ True、 False和 None）。盡管如此，為了一致性（所有的 Jinja 標識符是小寫的），你應該使用小寫的版本。

Jinja 允許你用計算值。這在模板中很少用到，但是為了完整性允許其存在。支持下面的運算符:

: 把兩個對象加到一起。通常對象是素質，但是如果兩者是字符串或列表，你可以用這種方式來銜接它們。無論如何這不是首選的連接字符串的方式！連接字符串見 ~ 運算符。 {{ 1 1 }} 等于 2 。
-: 用第一個數減去第二個數。 {{ 3 - 2 }} 等于 1 。

/: 對兩個數做除法。返回值會是一個浮點數。 {{ 1 / 2 }} 等于 {{ 0.5 }} 。

//: 對兩個數做除法，返回整數商。 {{ 20 // 7 }} 等于 2 。

%: 計算整數除法的余數。 {{ 11 % 7 }} 等于 4 。
*: 用右邊的數乘左邊的操作數。 {{ 2 * 2 }} 會返回 4 。也可以用于重復一個字符串多次。 {{ ‘=’ * 80 }} 會打印 80 個等號的橫條。
**: 取左操作數的右操作數次冪。 {{ 2**3 }} 會返回 8 。

==: 比較兩個對象是否相等。
!=: 比較兩個對象是否不等。

>: 如果左邊大于右邊，返回 true。
>=: 如果左邊大于等于右邊，返回 true。

<: 如果左邊小于右邊，返回 true。
<=: 如果左邊小于等于右邊，返回 true。

對于 if語句，在 for過濾或 if表達式中，它可以用于聯(lián)合多個表達式:

and: 如果左操作數和右操作數同為真，返回 true 。
or: 如果左操作數和右操作數有一個為真，返回 true 。
not: 對一個表達式取反（見下）。
(expr): 表達式組。

提示

is 和 in 運算符同樣支持使用中綴記法: foo is not bar 和 foo not in bar 而不是 not foo is bar 和 not foo in bar 。所有的其它表達式需要前綴記法 not (foo and bar) 。

下面的運算符非常有用，但不適用于其它的兩個分類:

in: 運行序列/映射包含檢查。如果左操作數包含于右操作數，返回 true 。比如 {{ 1 in [1,2,3] }} 會返回 true 。
is
|

~: 把所有的操作數轉換為字符串，并且連接它們。 {{ 'Hello ' ~ name ~ '!' }} 會返回（假設 name值為 ''John' ） Hello John! 。
(): 調用一個可調用量: {{ post.render() }} 。在圓括號中，你可以像在 python 中一樣使用位置參數和關鍵字參數: {{ post.render(user, full=true) }} 。
. / []: 獲取一個對象的屬性。（見）

同樣，也可以使用內聯(lián)的 if表達式。這在某些情況很有用。例如你可以用來在一個變量定義的情況下才繼承一個模板，否則繼承默認的布局模板:

{% extends layout_template if layout_template is defined else 'master.html' %}

一般的語法是 <do something> if <something is true> else <do something else> 。

else部分是可選的。如果沒有顯式地提供 else 塊，會求值一個未定義對象:

abs ( number )

attr ( obj, name )

batch ( value, linecount, fill_with=None )

capitalize ( s )

center ( value, width=80 )

default ( value, default_value=u'', boolean=False )

Aliases :	`d`

dictsort ( value, case_sensitive=False, by='key' )

escape ( s )

Aliases :	`e`

filesizeformat ( value, binary=False )

first ( seq )

float ( value, default=0.0 )

forceescape ( value )

format ( value, *args, **kwargs )

groupby ( value, attribute )

indent ( s, width=4, indentfirst=False )

int ( value, default=0 )

join ( value, d=u'', attribute=None )

last ( seq )

length ( object )

Aliases :	`count`

list ( value )

lower ( s )

map ( )

pprint ( value, verbose=False )

random ( seq )

reject ( )

rejectattr ( )

replace ( s, old, new, count=None )

reverse ( value )

round ( value, precision=0, method='common' )

safe ( value )

select ( )

selectattr ( )

slice ( value, slices, fill_with=None )

sort ( value, reverse=False, case_sensitive=False, attribute=None )

string ( object )

striptags ( value )

sum ( iterable, attribute=None, start=0 )

title ( s )

trim ( value )

truncate ( s, length=255, killwords=False, end='...' )

upper ( s )

urlencode ( value )

urlize ( value, trim_url_limit=None, nofollow=False )

wordcount ( s )

wordwrap ( s, width=79, break_long_words=True, wrapstring=None )

xmlattr ( d, autospace=True )

callable ( object )

defined ( value )

divisibleby ( value, num )

escaped ( value )

even ( value )

iterable ( value )

lower ( value )

mapping ( value )

none ( value )

number ( value )

odd ( value )

sameas ( value, other )

sequence ( value )

string ( value )

undefined ( value )

upper ( value )

默認下，下面的函數在全局作用域中可用:

range ( [ start ], stop [, step ] )

lipsum ( n=5, html=True, min=20, max=100 )

dict ( **items )

class cycler ( *items )

reset ( )

next ( )

current

New in version 2.1.

class joiner ( sep=', ' )

New in version 2.1.

下面的幾節(jié)涵蓋了可能被應用啟用的 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的別名

例如你可以容易地這樣打印一個已翻譯的字符串:

你可以使用 format過濾器來使用占位符:

因為其它語言可能不會用同樣的順序使用詞匯，要使用多個占位符，應始終用字符串參數傳給 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參數作為計數作為附加的常規(guī)參數。

如果加載了表達式語句擴展，一個名為 do的擴展即可用。它工作幾乎如同常規(guī)的變量表達式（ {{ ... }} ），只是它不打印任何東西。這可以用于修改列表:

{% do navigation.append('a string') %}

如果應用啟用來 循環(huán)控制 ，則可以在循環(huán)中使用 break和 continue。到達 break時，循環(huán)終止。到達 continue時，當前處理會終止并從下一次迭代繼續(xù)。

這個循環(huán)每兩項跳過一次:

{% for user in users %} {%- if loop.index is even %}{% continue %}{% endif %} ...{% endfor %}

同樣，這個循環(huán) 10 次迭代之后會終止處理:

{% for user in users %} {%- if loop.index >= 10 %}{% break %}{% endif %}{%- endfor %}

New in version 2.3.

如果應用啟用了 With 語句 ，將允許在模板中使用 with關鍵字。這使得創(chuàng)建一個新的內作用域。這個作用域中的變量在外部是不可見的。

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標簽之后，自動轉義的行為將回到與之前相同的狀態(tài)。

本站僅提供存儲服務，所有內容均由用戶發(fā)布，如發(fā)現有害或侵權內容，請點擊舉報。

九色国产,午夜在线视频,新黄色网址,九九色综合,天天做夜夜做久久做狠狠,天天躁夜夜躁狠狠躁2021a,久久不卡一区二区三区

有效的:

無效的: