从 jinja2 调用 python 函数

Question

我正在使用 jinja2，我想调用一个 python 函数作为助手，使用类似于调用宏的语法。 jinja2 似乎有意阻止我进行函数调用，并坚持我通过将函数作为宏复制到模板中来重复自己。

有没有直接的方法来做到这一点？而且，有没有什么方法可以导入一整套 python 函数并让它们从 jinja2 访问，而无需经过大量繁琐的工作（例如编写扩展程序）？

Answer 1

对于使用 Flask 的用户，请将其放入您的 __init__.py：

def clever_function():
    return u'HELLO'

app.jinja_env.globals.update(clever_function=clever_function)

并在您的模板中使用{{ clever_function() }} 调用它

Answer 2

注意：这是 Flask 特有的！

我知道这篇文章已经很老了，但是在新版本的 Flask 中使用上下文处理器有更好的方法。

可以轻松创建变量：

@app.context_processor
def example():
    return dict(myexample='This is an example')

上面可以在带有 Flask 的 Jinja2 模板中使用，如下所示：

{{ myexample }}

（输出This is an example）

以及完整的功能：

@app.context_processor
def utility_processor():
    def format_price(amount, currency=u'€'):
        return u'{0:.2f}{1}'.format(amount, currency)
    return dict(format_price=format_price)

上面这样使用时：

{{ format_price(0.33) }}

（输出带有货币符号的输入价格）

或者，您可以使用jinja filters，烘焙到 Flask 中。例如。使用装饰器：

@app.template_filter('reverse')
def reverse_filter(s):
    return s[::-1]

或者，没有装饰器，手动注册函数：

def reverse_filter(s):
    return s[::-1]
app.jinja_env.filters['reverse'] = reverse_filter

上面两种方法应用的过滤器可以这样使用：

{% for x in mylist | reverse %}
{% endfor %}

Answer 3

我认为 jinja 故意让在模板中运行“任意”python 变得困难。它试图强化这样一种观点，即模板中的逻辑越少越好。

您可以在Environment 实例中操作全局命名空间来添加对您的函数的引用。它必须在您加载任何模板之前完成。例如：

from jinja2 import Environment, FileSystemLoader

def clever_function(a, b):
    return u''.join([b, a])

env = Environment(loader=FileSystemLoader('/path/to/templates'))
env.globals['clever_function'] = clever_function

Answer 4

from jinja2 import Template

def custom_function(a):
    return a.replace('o', 'ay')

template = Template('Hey, my name is {{ custom_function(first_name) }} {{ func2(last_name) }}')
template.globals['custom_function'] = custom_function

你也可以在Matroskin's answer的字段中给出函数

fields = {'first_name': 'Jo', 'last_name': 'Ko', 'func2': custom_function}
print template.render(**fields)

将输出：

Hey, my name is Jay Kay

适用于 Jinja2 2.7.3 版

如果你想要一个装饰器来简化 template.globals 上的定义函数，请查看 Bruno Bronosky's answer

Answer 5

我喜欢@AJP's answer。我逐字逐句地使用它，直到我最终得到了很多功能。然后我切换到Python function decorator。

from jinja2 import Template

template = '''
Hi, my name is {{ custom_function1(first_name) }}
My name is {{ custom_function2(first_name) }}
My name is {{ custom_function3(first_name) }}
'''
jinga_html_template = Template(template)

def template_function(func):
    jinga_html_template.globals[func.__name__] = func
    return func

@template_function
def custom_function1(a):
    return a.replace('o', 'ay')

@template_function
def custom_function2(a):
    return a.replace('o', 'ill')

@template_function
def custom_function3(a):
    return 'Slim Shady'

fields = {'first_name': 'Jo'}
print(jinga_html_template.render(**fields))

好东西函数有一个__name__！

Answer 6

在官方文档或堆栈溢出中从未见过如此简单的方法，但当我发现这个时我很惊讶：

# jinja2.__version__ == 2.8
from jinja2 import Template

def calcName(n, i):
    return ' '.join([n] * i)

template = Template("Hello {{ calcName('Gandalf', 2) }}")

template.render(calcName=calcName)
# or
template.render({'calcName': calcName})

Answer 7

有一个更简单的决定。

@app.route('/x')
def x():
    return render_template('test.html', foo=y)

def y(text):
    return text

然后，在test.html中：

{{ foo('hi') }}

Answer 8

使用 lambda 将模板连接到您的主代码

return render_template("clever_template", clever_function=lambda x: clever_function x)

然后就可以无缝调用模板中的函数了

{{clever_function(value)}}

Answer 9

要从 Jinja2 调用 python 函数，您可以使用 custom filters，其工作方式与 globals 类似。

它非常简单实用。 在 myTemplate.txt 文件中，我写道：

{{ data | pythonFct }}

在 python 脚本中：

import jinja2

def pythonFct(data):
    return "This is my data: {0}".format(data)
    
input="my custom filter works!"
  
loader = jinja2.FileSystemLoader(path or './')
env = jinja2.Environment(loader=loader)
env.filters['pythonFct'] = pythonFct
result = env.get_template("myTemplate.txt").render(data=input)
print(result)

Answer 10

有什么方法可以导入一整套python函数并让它们从jinja2访问？

是的，除了上面的其他答案之外，这对我有用。

创建一个类并使用相关方法填充它，例如

class Test_jinja_object:

    def __init__(self):
        self.myvar = 'sample_var'

    def clever_function (self):
        return 'hello' 

然后在您的视图函数中创建您的类的实例，并将生成的对象作为 render_template 函数的参数传递给您的模板

my_obj = Test_jinja_object()

现在在您的模板中，您可以像这样调用 jinja 中的类方法

{{ my_obj.clever_function () }}

Answer 11

要导入您可以使用的所有内置函数：

app.jinja_env.globals.update(__builtins__)

如果这不起作用，请在 __builtins__ 之后添加 .__dict__。

基于John32323's answer。

Answer 12

如果你是用 Django 做的，你可以通过上下文传递函数：

context = {
    'title':'My title',
    'str': str,
}
...
return render(request, 'index.html', context)

现在您可以在 jinja2 模板中使用str 函数

Answer 13

@John32323 的回答是一个非常干净的解决方案。

这里是同一个，但保存到一个单独的文件中，也许更干净。

创建帮助文件

app\helper.py

from app import app

def clever_function_1():
    return u'HELLO'

def clever_function_2(a, b):
    return a + b



app.jinja_env.globals.update(
    clever_function_1=clever_function_1,
    clever_function_2=clever_function_2,
)

从应用导入

app.py

from app import routes
from app import helper   # add this one

这样使用

app\templates\some.html

{{ clever_function_1() }}
{{ clever_function_2(a, b) }}

Answer 14

对于那些使用 FastApi 的用户，请将其放入您的 __init__.py：

from fastapi.templating import Jinja2Templates
templates = Jinja2Templates(directory="templates")

def clever_function():
    return u'HELLO'

templates.env.globals.update(clever_function=clever_function)

并在您的模板中使用{{ clever_function() }} 调用它