Panggil fungsi python dari jinja2

Saya menggunakan jinja2, dan saya ingin memanggil fungsi python sebagai penolong, menggunakan sintaksis yang sama seperti jika saya memanggil makro. jinja2 tampaknya berniat mencegah saya membuat panggilan fungsi, dan bersikeras saya ulangi diri saya dengan menyalin fungsi ke dalam templat sebagai makro.

Apakah ada cara mudah untuk melakukan ini? Dan, apakah ada cara untuk mengimpor seluruh rangkaian fungsi python dan membuatnya dapat diakses dari jinja2, tanpa melalui banyak omong kosong (seperti menulis ekstensi)?

Bagi mereka yang menggunakan Flask, letakkan ini di __init__.py:

def clever_function():
    return u'HELLO'

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

dan dalam template Anda menyebutnya dengan {{ clever_function() }}

Catatan: Ini khusus untuk Labu!

Saya tahu posting ini cukup lama, tetapi ada metode yang lebih baik untuk melakukan ini di versi Flask yang lebih baru menggunakan pemroses konteks.

Variabel dapat dengan mudah dibuat:

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

Di atas dapat digunakan dalam template Jinja2 dengan Labu seperti:

{{ myexample }}

(Output mana This is an example)

Serta fungsi lengkap penuh:

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

Di atas ketika digunakan seperti:

{{ format_price(0.33) }}

(Yang menampilkan harga input dengan simbol mata uang)

Atau, Anda dapat menggunakan filter jinja , yang dimasukkan ke dalam Flask. Misalnya menggunakan dekorator:

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

Atau, tanpa dekorator, dan mendaftarkan fungsi secara manual:

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

Filter yang diterapkan dengan dua metode di atas dapat digunakan seperti ini:

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

Saya pikir jinja sengaja membuatnya sulit untuk menjalankan python 'sewenang-wenang' dalam sebuah template. Ia mencoba untuk menegakkan pendapat bahwa logika yang kurang dalam template adalah hal yang baik.

Anda dapat memanipulasi namespace global dalam sebuah Environmentinstance untuk menambahkan referensi ke fungsi Anda. Itu harus dilakukan sebelum Anda memuat template apa pun. Sebagai contoh:

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

Anda juga dapat memberikan fungsi di bidang sesuai jawaban Matroskin

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

Akan menghasilkan:

Hey, my name is Jay Kay

Bekerja dengan Jinja2 versi 2.7.3

Dan jika Anda ingin seorang dekorator memudahkan menentukan fungsi pada template.globalsmemeriksa jawaban Bruno Bronosky

Saya suka jawaban @ AJP . Saya menggunakannya kata demi kata sampai akhirnya memiliki banyak fungsi. Kemudian saya beralih ke dekorator fungsi Python .

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

Fungsi hal yang baik miliki __name__!

Tidak pernah melihat cara sederhana di dokumen resmi atau di stack overflow, tetapi saya kagum ketika menemukan ini:

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

Gunakan lambda untuk menghubungkan templat ke kode utama Anda

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

Kemudian Anda dapat memanggil fungsi di dalam templat dengan mulus

{{clever_function(value)}}

Untuk memanggil fungsi python dari Jinja2, Anda dapat menggunakan filter khusus yang berfungsi sama seperti global: http://jinja.pocoo.org/docs/dev/api/#writing-filters

Ini cukup sederhana dan bermanfaat. Dalam file myTemplate.txt, saya menulis:

{{ data|pythonFct }}

Dan dalam skrip 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)

apakah ada cara untuk mengimpor seluruh rangkaian fungsi python dan membuatnya dapat diakses dari jinja2?

Ya ada, Selain jawaban lain di atas, ini berfungsi untuk saya.

Buat kelas dan isi dengan metode terkait mis

class Test_jinja_object:

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

    def clever_function (self):
        return 'hello' 

Kemudian buat instance kelas Anda di fungsi tampilan Anda dan meneruskan objek yang dihasilkan ke template Anda sebagai parameter untuk fungsi render_template

my_obj = Test_jinja_object()

Sekarang di templat Anda, Anda dapat memanggil metode kelas di jinja seperti itu

{{ my_obj.clever_function () }}

Untuk mengimpor semua fungsi bawaan Anda dapat menggunakan:

app.jinja_env.globals.update(__builtins__)

Tambahkan .__dict__setelah __builtins__jika ini tidak berhasil.

Berdasarkan jawaban John32323 .

Jika Anda melakukannya dengan Django, Anda bisa meneruskan fungsi dengan konteks:

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

Sekarang Anda akan dapat menggunakan strfungsi dalam template jinja2

Ada keputusan yang jauh lebih sederhana.

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

def y(text):
    return text

Lalu, di test.html :

{{ y('hi') }}