Heim >Backend-Entwicklung >Python-Tutorial >Tutorial zur Verwendung von Jinja2, der Standard-Template-Engine des Flask-Frameworks von Python
Tutorial zur Verwendung von Jinja2, der Standard-Template-Engine des Flask-Frameworks von Python
- WBOYOriginal
- 2016-08-04 08:55:461610Durchsuche
Jinja2 erfordert Python 2.4 oder höher.
Installation
Es gibt viele Möglichkeiten, Jinja zu folgen. Sie können je nach Bedarf verschiedene Methoden wählen.
Verwenden Sie easy_install oder pip:
#sudo easy_install Jinja2 #sudo pip install Jinja2
Von Tarball installieren:
# 下载Jinja的安装包 # 解压缩 # sudo python setup.py install
Grundlegende API-Nutzung
Der einfachste Weg, eine Vorlage mit Jinja zu erstellen, ist über Template. Diese Verwendung wird jedoch in tatsächlichen Anwendungen nicht empfohlen:
<pre class="brush:php;toolbar:false">
>>> from Jinja2 import Template
>>> template = Template('Hello {{ name }}!')
>>> template.render(name='World')
u'Hello World!'
In diesem Beispiel wird eine Vorlageninstanz mit einer Zeichenfolge als Vorlageninhalt erstellt, dann die „Render-Methode“ mit „name='World'“ als Parameter aufgerufen, der „Name“ im Inhalt durch „World“ ersetzt und gibt schließlich den gerenderten String zurück – „u'Hello World!‘“
.
Es gibt zwei Arten von Trennzeichen. {% raw %}{% ... %}{% endraw %} und {% raw %}{{ ... }}{% endraw %}. Ersteres wird verwendet, um Anweisungen wie for-Schleifen oder Zuweisungen auszuführen, und letzteres wird verwendet, um das Ergebnis des Ausdrucks an die Vorlage auszugeben.
So organisieren Sie Vorlagen
Wie passen Vorlagen in unsere Anwendungen? Wenn Sie sich mit Flask beschäftigt haben, ist Ihnen vielleicht aufgefallen, dass Flask sehr flexibel ist und keine besonderen Einschränkungen hinsichtlich seines Inhalts auferlegt. Vorlagen sind keine Ausnahme. Möglicherweise stellen Sie auch fest, dass es normalerweise einen empfohlenen Ort zum Ablegen von Dingen (z. B. Vorlagen) gibt. Bei Vorlagen befindet sich dieser Ort im Paketverzeichnis.
myapp/
__init__.py
models.py
views/
templates/
static/
run.py
requirements.txt
templates/
layout.html
index.html
about.html
profile/
layout.html
index.html
photos.html
admin/
layout.html
index.html
analytics.html
Die Struktur des Vorlagenverzeichnisses ist parallel zu unserer Routing-Struktur. Für die Route myapp.com/admin/analytics lautet die Vorlage templates/admin/analytics.html. Es gibt einige zusätzliche Vorlagen im Verzeichnis, die nicht direkt gerendert werden. Die Datei „layout.html“ dient zur Übernahme durch andere Vorlagen.
Erben
Ähnlich wie Batmans Hintergrundgeschichte ist ein gut organisiertes Vorlagenverzeichnis stark auf Vererbung angewiesen. Übergeordnete Vorlagen definieren normalerweise eine gemeinsame Struktur, von der alle untergeordneten Vorlagen erben können. In unserem Beispiel ist „layout.html“ eine übergeordnete Vorlage und die anderen .html-Dateien sind untergeordnete Vorlagen.
Normalerweise verfügen Sie über eine „layout.html“ auf oberster Ebene, die das allgemeine Layout Ihrer Anwendung und aller Teile Ihrer Website definiert. Wenn Sie sich das Verzeichnis oben ansehen, sehen Sie eine myapp/templates/layout.html der obersten Ebene sowie myapp/templates/profile/layout.html und myapp/templates/admin/layout.html. Die letzten beiden Dateien erben und ändern die erste Datei.
{# _myapp/templates/layout.html_ #}
<!DOCTYPE html>
<html lang="en">
<head>
<title>{% raw %}{% block title %}{% endblock %}{% endraw %}</title>
</head>
<body>
{% block body %}
<h1>This heading is defined in the parent.</h1>
{% endblock %}
</body>
</html>
In untergeordneten Vorlagen können wir die übergeordnete Vorlage erweitern und den Inhalt dieser Blöcke definieren.
{# _myapp/templates/index.html_ #}
{% extends "layout.html" %}
{% block title %}Hello world!{% endblock %}
{% block body %}
{{ super() }}
<h2>This heading is defined in the child.</h2>
{% endblock %}
Mit der super()-Funktion können wir den Inhalt des übergeordneten Blocks rendern.
Makro erstellen
Wir können uns in unseren Vorlagen an das DRY-Prinzip (Don’t Repeat Yourself) halten, indem wir wiederkehrende Codeschnipsel in Makros abstrahieren. Wenn wir am HTML für die Navigation in unserer Anwendung arbeiten, müssen wir einem „aktiven“ Link eine Klasse zuweisen (class="active"). Ohne Makros müssten wir eine Reihe von if ... else-Anweisungen schreiben, die jeden Link überprüfen, um den aktiven zu finden.
Makros bieten eine Möglichkeit, Code zu modularisieren; sie funktionieren wie Funktionen. Sehen wir uns an, wie man einen aktiven Link mithilfe von Makros markiert.
{# myapp/templates/layout.html #}
{% from "macros.html" import nav_link with context %}
<!DOCTYPE html>
<html lang="en">
<head>
{% block head %}
<title>My application</title>
{% endblock %}
</head>
<body>
<ul class="nav-list">
{{ nav_link('home', 'Home') }}
{{ nav_link('about', 'About') }}
{{ nav_link('contact', 'Get in touch') }}
</ul>
{% block body %}
{% endblock %}
</body>
</html>
Alles, was wir jetzt in dieser Vorlage tun müssen, ist, ein undefiniertes Makro – nav_link – aufzurufen und ihm zwei Parameter zu übergeben: den Zielendpunkt (z. B. den Funktionsnamen der Zielansicht) und den Text, den wir anzeigen möchten.
Möglicherweise stellen Sie fest, dass wir in der Importanweisung den Kontext angegeben haben. Der Kontext von Jinja besteht aus den an die Funktion render_template() übergebenen Parametern und dem Jinja-Umgebungskontext aus unserem Python-Code. Bei Vorlagen sind diese Variablen verfügbar, wenn die Vorlage gerendert wird.
Einige Variablen werden natürlich von uns übergeben, zum Beispiel render_template("index.html", color="red"), aber es gibt auch Variablen und Funktionen, die von Flask automatisch in den Kontext eingebunden werden, zum Beispiel request, g und Sitzung. Wenn wir {% raw %}{% from ... import ... with context %}{% endraw %} sagen, teilen wir Jinja mit, dass diese Variablen auch für Makros verfügbar sind.
Jetzt ist es an der Zeit, das in unserer Vorlage verwendete Makro „nav_link“ zu definieren.
{# myapp/templates/macros.html #}
{% macro nav_link(endpoint, text) %}
{% if request.endpoint.endswith(endpoint) %}
<li class="active"><a href="{{ url_for(endpoint) }}">{{text}}</a></li>
{% else %}
<li><a href="{{ url_for(endpoint) }}">{{text}}</a></li>
{% endif %}
{% endmacro %}
Jetzt haben wir das Makro in myapp/templates/macros.html definiert. In diesem Makro verwenden wir das Anforderungsobjekt von Flask – standardmäßig verfügbar im Jinja-Kontext – um zu prüfen, ob der Endpunkt der in nav_link übergebenen Route die aktuelle Anforderung ist. Wenn ja, befinden wir uns auf der aktuellen Seite und markieren sie als aktiv.
Die Anweisung „y aus x importieren“ verwendet einen relativen Pfad zu x. Wenn unsere Vorlage myapp/templates/user/blog.html ist, können wir „../macros.html“ verwenden, um nav_link zu importieren.
自定义过滤器
Jinja 过滤器是一个函数，它能够在 {% raw %}{{ ... }}{% endraw %} 中用于处理一个表达式的结果。在表达式结果输出到模板之前它就被调用。
<h2>{{ article.title|title }}</h2>
在这段代码中，title 过滤器接收 article.title 作为参数并且返回一个过滤后的标题，接着过滤后的标题将会输出到模板中。这就像 UNIX 的“管道化”一个程序到另一个程序的输出。
有很多像 title 一样的内置过滤器。请参阅 Jinja 文档中的 完整列表。
我们可以在我们的 Jinja 模板中定义自己的过滤器供使用。举例来说，我们将会实现一个简单 caps 过滤器用来大写一个字符串中所有的字母。
Jinja 已经有一个 upper 过滤器来做这样的事情，并且还有一个 capitalize 过滤器，它能用来大写第一个字母，小写其余的字母。这些也能处理 unicode 转换，但是我们会继续我们的示例，让大家目前能够知道如何自定义过滤器。
我们要在 myapp/util/filters.py 中定义我们的过滤器。这里给出一个 util 包，它里面有各种各样的模块。
# myapp/util/filters.py from .. import app @app.template_filter() def caps(text): """Convert a string to all caps.""" return text.uppercase()
在这段代码中我们使用 @app.template_filter() 装饰器注册我们的函数成一个 Jinja 过滤器。默认的过滤器名称就是函数的名称，但是你可以传入一个参数到装饰器中来改变它。
@app.template_filter('make_caps')
def caps(text):
"""Convert a string to all caps."""
return text.uppercase()
现在我们可以在模板中调用 make_caps 而不是 {% raw %}caps：{{ "hello world!"|make_caps }}{% endraw %}。
为了要让我们的过滤器在模板中可用的话，我们只需要在我们的顶层 \\_init.py\\_ 的中导入它。
# myapp/__init__.py # Make sure app has been initialized first to prevent circular imports. from .util import filters