Rufen Sie eine Python-Funktion von jinja2 auf

Ich verwende jinja2 und möchte eine Python-Funktion als Helfer aufrufen, wobei ich eine ähnliche Syntax verwende, als würde ich ein Makro aufrufen. jinja2 scheint darauf bedacht zu sein, mich daran zu hindern, einen Funktionsaufruf zu tätigen, und besteht darauf, dass ich mich wiederhole, indem ich die Funktion als Makro in eine Vorlage kopiere.

Gibt es eine einfache Möglichkeit, dies zu tun? Und gibt es eine Möglichkeit, eine ganze Reihe von Python-Funktionen zu importieren und über jinja2 zugänglich zu machen, ohne viel Rigamarole zu durchlaufen (z. B. eine Erweiterung zu schreiben)?

Wenn Sie Flask verwenden, geben Sie Folgendes ein __init__.py:

def clever_function():
    return u'HELLO'

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

und in Ihrer Vorlage nennen Sie es mit {{ clever_function() }}

Hinweis: Dies ist flaschenspezifisch!

Ich weiß, dass dieser Beitrag ziemlich alt ist, aber es gibt bessere Methoden, dies in den neueren Versionen von Flask unter Verwendung von Kontextprozessoren zu tun.

Variablen können einfach erstellt werden:

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

Das Obige kann in einer Jinja2-Vorlage mit Flask wie folgt verwendet werden:

{{ myexample }}

(Welche Ausgänge This is an example)

Sowie vollwertige Funktionen:

@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)

Das obige, wenn es so verwendet wird:

{{ format_price(0.33) }}

(Welches gibt den Eingabepreis mit dem Währungssymbol aus)

Alternativ können Sie Jinja-Filter verwenden , die in Flask eingebrannt sind. ZB mit Dekorateuren:

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

Oder ohne Dekorateure und manuelles Registrieren der Funktion:

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

Filter, die mit den beiden oben genannten Methoden angewendet werden, können folgendermaßen verwendet werden:

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

Ich denke, Jinja macht es absichtlich schwierig, "beliebige" Python innerhalb einer Vorlage auszuführen. Es wird versucht, die Meinung durchzusetzen, dass weniger Logik in Vorlagen eine gute Sache ist.

Sie können den globalen Namespace innerhalb einer EnvironmentInstanz bearbeiten, um Verweise auf Ihre Funktionen hinzuzufügen. Dies muss erfolgen, bevor Sie Vorlagen laden. Beispielsweise:

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

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

Sie können die Funktion auch in den Feldern gemäß der Antwort von Matroskin angeben

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

Wird ausgegeben:

Hey, my name is Jay Kay

Funktioniert mit Jinja2 Version 2.7.3

Und wenn Sie möchten, dass ein Dekorateur die Definition von Funktionen erleichtert, lesen Sie die Antworttemplate.globals von Bruno Bronosky

Ich mag die Antwort von @ AJP . Ich habe es wörtlich verwendet, bis ich viele Funktionen hatte. Dann wechselte ich zu einem Python-Funktionsdekorateur .

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

Gut, dass Funktionen eine haben __name__!

Ich habe noch nie einen so einfachen Weg bei offiziellen Dokumenten oder beim Stapelüberlauf gesehen, aber ich war erstaunt, als ich Folgendes fand:

# 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})

Verwenden Sie ein Lambda, um die Vorlage mit Ihrem Hauptcode zu verbinden

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

Dann können Sie die Funktion in der Vorlage nahtlos aufrufen

{{clever_function(value)}}

Um eine Python-Funktion von Jinja2 aus aufzurufen, können Sie benutzerdefinierte Filter verwenden, die ähnlich wie die globalen funktionieren: http://jinja.pocoo.org/docs/dev/api/#writing-filters

Es ist ganz einfach und nützlich. In einer Datei myTemplate.txt schrieb ich:

{{ data|pythonFct }}

Und in einem Python-Skript:

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)

Gibt es eine Möglichkeit, eine ganze Reihe von Python-Funktionen zu importieren und über jinja2 darauf zugreifen zu können?

Ja, zusätzlich zu den anderen Antworten oben funktioniert dies für mich.

Erstellen Sie eine Klasse und füllen Sie sie mit den zugehörigen Methoden, z

class Test_jinja_object:

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

    def clever_function (self):
        return 'hello' 

Erstellen Sie dann eine Instanz Ihrer Klasse in Ihrer Ansichtsfunktion und übergeben Sie das resultierende Objekt als Parameter für die Funktion render_template an Ihre Vorlage

my_obj = Test_jinja_object()

Jetzt können Sie in Ihrer Vorlage die Klassenmethoden in jinja so aufrufen

{{ my_obj.clever_function () }}

So importieren Sie alle integrierten Funktionen:

app.jinja_env.globals.update(__builtins__)

Fügen Sie .__dict__nach , __builtins__wenn dies nicht funktioniert.

Basierend auf der Antwort von John32323 .

Wenn Sie es mit Django machen, können Sie die Funktion einfach mit dem Kontext übergeben:

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

Jetzt können Sie die strFunktion in der jinja2-Vorlage verwenden

Es gibt eine viel einfachere Entscheidung.

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

def y(text):
    return text

Dann in test.html :

{{ y('hi') }}