Appeler une fonction python de jinja2

Je suis en utilisant jinja2, et je veux appeler une fonction python comme une aide, à l'aide d'une syntaxe similaire comme si je l'appel d'une macro. jinja2 semble décidée à m'empêcher de faire un appel de fonction, et insiste sur le fait de me répéter par la copie de la fonction dans un modèle comme une macro.

Est-il un moyen simple de faire cela? Et, est-il un moyen d'importer un ensemble de fonctions python et ont accessibles à partir de jinja2, sans passer par tout un tas de rigamarole (comme l'écriture d'une extension)?

InformationsquelleAutor Lee | 2011-05-17

jinja2 python

204

Pour ceux qui utilisent le Flacon, mettez ceci dans votre __init__.py:
```
def clever_function():
    return u'HELLO'

app.jinja_env.globals.update(clever_function=clever_function)
```
et dans votre modèle d'appeler avec des {{ clever_function() }}
- vous pouvez passer plusieurs fonctions comme celle-ci?
- Dans les versions plus récentes (je suis en utilisant Jinja2 2.9.6) il semble que le travail beaucoup plus facile. Utilisation de la fonction que vous utilisez une variable (fonctionne aussi dans des situations plus complexes): from jinja2 import Template ##newline## def clever_function(): ##newline## return "Hello" ##newline## template = Template("{{ clever_function() }}") ##newline## print(template.render(clever_function=clever_function))
- Même 8 ans plus tard, si vous utilisez la Fiole, cela semble être une solution plus propre que tout de la plus récente des réponses. Et pour répondre à la vieille question de @ffghfgh , oui—vous pouvez passer plusieurs fonctions.
InformationsquelleAutor John32323
118

Note: Ceci est un Flacon spécifique!

Je sais que ce post est assez vieux, mais il existe de meilleures façons de faire dans les versions plus récentes de la Fiole à l'aide de contexte processeurs.

Variables peuvent facilement être créés:
```
@app.context_processor
def example():
    return dict(myexample='This is an example')
```
Ci-dessus peut être utilisé dans un Jinja2 modèle avec Flacon comme suit:
```
{{ myexample }}
```
(Les sorties qui This is an example)

Ainsi que de véritables fonctions:
```
@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)
```
Ci-dessus lorsqu'il est utilisé comme ainsi:
```
{{ format_price(0.33) }}
```
(Qui sort le prix des entrées avec le symbole de la devise)

Alternativement, vous pouvez utiliser jinja filtres, cuit dans la Fiole. E. g. à l'aide de décorateurs:
```
@app.template_filter('reverse')
def reverse_filter(s):
    return s[::-1]
```
Ou, sans décorateurs, et enregistrer manuellement la fonction:
```
def reverse_filter(s):
    return s[::-1]
app.jinja_env.filters['reverse'] = reverse_filter
```
Les filtres appliqués, avec les deux méthodes peuvent être utilisées comme ceci:
```
{% for x in mylist | reverse %}
{% endfor %}
```
- où si ces fonctions existent, init, points de vue ou tout simplement de n'importe où?
- __init__.py en supposant que vous avez déclaré flask.Flask(__name__) là.
- Bas voté comme question posée sur l'Jinja2 et la réponse est Fiole spécifiques.
- En théorie toujours des réponses à la question. C'est UNE manière de résoudre le problème, vous a accordé le sont également à l'aide de Flacon. Un peu comme tous les JavaScript à des questions à réponse donnant des solutions de rechange, avec ou sans jQuery ou des questions à propos de Python souvent répondre à la fois pour Python2 et 3. La question n'était pas à l'exclusion de Flacon. (contrairement à une question sur Py2 exclure un Py3 réponse). Cette réponse m'a aidé.
- Avec Flacon, vous avez une façon très simple d'ajouter des filtres à Jinja! Je pense que vous devriez être en utilisant. flask.pocoo.org/docs/0.10/templating/#registering-filters à mon humble avis context_processor sont plus au sujet de l'injection de données.
- J'ai ajouté un Jinja exemple de filtre de ma réponse ainsi, @JeromeJ. Je ne dirais pas que "l'injection" est le terme correct. Vous n'êtes pas pré-production de données et l'injecter dans le modèle. L'ajout d'un contexte processeur se fait de la même chose que Jinja filtres.
- Très utile, et tout ce que je cherchais. Jinja2 fait partie d'un framework web, et en tant que tel n'est pas totalement indépendant du back-end. Je travaille dans les deux Django et Flacon avec Python et ce post, ainsi que les autres ici sont importants pour moi. En essayant de plus de spécifier une question est tout aussi nuisible à mon avis comme étant inutilement vague.
InformationsquelleAutor Liam Stanley
73

Je pense que jinja délibérément rend difficile l'exécuter "arbitraire" python à l'intérieur d'un modèle. Il tente de faire respecter l'opinion que moins de la logique dans les modèles est une bonne chose.

Vous pouvez manipuler l'espace de noms global au sein d'une Environment exemple pour ajouter des références à vos fonctions. Il doit être fait avant vous chargez l'un des modèles. Par exemple:
```
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
```
- J'ai découvert ce aussi-vous pouvez ajouter un module en utilisant quelque chose comme ceci: import utils.helpers env.globals['helpers'] = utils.helpers
- Oui, vous pouvez 'injecter' espaces de noms (modules), des fonctions, des instances de classe etc. Il est utile, mais pas aussi flexibles que d'autres moteurs de template comme mako. Encore, jinja a d'autres bons points. Je serais reconnaissant si vous acceptez la réponse si elle a aidé 🙂
- a fait le tour pour moi, en faisant mon app engine projet ( webapp2 et jinja2 ) . merci
- après l'ajout de la clever_function de dictionnaire env.globals, comment peut-on appeler la fonction à partir du modèle.
- Ainsi, {{ clever_function('a', 'b') }}
InformationsquelleAutor Rob Cowie
40
```
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
```
Vous pouvez également donner à la fonction dans les champs à l' Matroskin réponse
```
fields = {'first_name': 'Jo', 'last_name': 'Ko', 'func2': custom_function}
print template.render(**fields)
```
Sera de sortie:
```
Hey, my name is Jay Kay
```
Fonctionne avec Jinja2 version 2.7.3

Et si vous voulez un décorateur pour faciliter la définition des fonctions sur template.globals découvrez Bruno Bronosky réponse
- Probablement parce que vous downvoted tous les autres réponses 🙁
- ce n'est pas une bonne raison. - Je le seul a voté 2 réponses, des réponses qui étaient sur le Flacon plutôt que Jinja2. Si ils veulent modifier leurs réponses à un sujet et à propos de Jinja2, je vais jusqu'au prochain scrutin.
- Tx @BorkoKovacev 🙂
- fonctionne parfaitement une fois, j'ai remarqué que j'avais plus regardé la jinga_html_template.globals['custom_function'] = custom_function ligne. Fait une grande différence.
- J'ai fait une fonction décorateur version de cette réponse. Il est actuellement au fond, avec 0 votes :,-( stackoverflow.com/a/47291097/117471
- nice. Jusqu'voté 🙂 ... lui donner une autre décennie et il pourrait être plus élevé que le mien 😛 ... ne sera jamais attraper les flacons de bien ;P
InformationsquelleAutor AJP

J'aime @AJP réponse. Je l'ai utilisé verbatim jusqu'à ce que j'ai retrouvé avec beaucoup de fonctions. Puis je suis passé à un Fonction Python décorateur.

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

Bonne chose fonctions ont une __name__!

C'est super cool. Lorsque vous annotez une fonction en python le fait automatiquement passer le nom de la fonction à l'annotation de la fonction?
yep. Lire que la fonction Python décorateur lien. De grandes choses!
Excellente démonstration du sage et de nettoyage utiliser pour python décorateurs ainsi. Après la grande!
Quelle bonne mise en œuvre!

InformationsquelleAutor Bruno Bronosky

N'a jamais vu une telle façon simple à l'officiel de docs ou à débordement de pile, mais j'ai été étonné quand trouvé ceci:

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

InformationsquelleAutor Matroskin

8

Utiliser une lambda pour connecter le modèle de votre code principal
```
return render_template("clever_template", clever_function=lambda x: clever_function x)
```
Ensuite, vous pouvez appeler la fonction dans le modèle
```
{{clever_function(value)}}
```
- Habile utilisation de lambda fonctions.
- Non, il n'est pas. C'est complètement inutile. Il suffit de passer la fonction de gérer lui-même: clever_function=clever_function
- Je vois. Comment ai-je pu rater ça? Merci pour éclaircir cela!
InformationsquelleAutor Robert Onslow

Pour appeler une fonction python de Jinja2, vous pouvez utiliser des filtres personnalisés qui fonctionnent de la même façon que les variables globales:
http://jinja.pocoo.org/docs/dev/api/#writing-filters

C'est très simple et utile.
Dans un fichier myTemplate.txt j'ai écrit:

{{ data|pythonFct }}

Et dans un script 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)

InformationsquelleAutor Ben9000RPM

5

est-il possible d'importer tout un ensemble de fonctions python et ont accessibles à partir de jinja2 ?

Oui, il est, En plus d'autres réponses ci-dessus, cela fonctionne pour moi.

Créer une classe et le remplir avec les méthodes associées.e.g
```
class Test_jinja_object:

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

    def clever_function (self):
        return 'hello' 
```
Ensuite créer une instance de votre classe, de votre point de vue de la fonction et de passer la résultante de l'objet de votre modèle en tant que paramètre de la render_template fonction
```
my_obj = Test_jinja_object()
```
Maintenant dans votre modèle, vous pouvez appeler les méthodes de la classe à jinja, comme
```
{{ my_obj.clever_function () }}
```
- L'équivalent, et légèrement plus simple: mettez toutes les fonctions pour les modèles dans un module d'importation de ce module et de l'ajouter en tant que modèle global. Un module est un objet qui contient des fonctions 🙂 (mais pas les méthodes — pas besoin d'auto param et aucune classe reqiured!)
- Que faire si je n'ai besoin que l'ensemble des fonctions que dans un ou deux modèles et pas tous d'entre eux. Aussi, si j'ai besoin de différents ensembles de fonctions python dans différents jinjas modèles? Voulez-vous encore efficace à l'importation de modèle globals plutôt que de le mettre comme des méthodes dans une classe et transmettre uniquement les classses avec les méthodes que vous avez besoin.
- À utiliser uniquement dans des modèles spécifiques, je voudrais ajouter les fonctions (ou d'un module contenant des fonctions) uniquement pour le modèle de contexte dict c'est returrned par le point de vue que l'utilisation de ces modèles.
InformationsquelleAutor Kudehinbu Oluwaponle
2

Si vous le faites avec Django, vous pouvez juste passer à la fonction du contexte:
```
context = {
    'title':'My title',
    'str': str,
}
...
return render(request, 'index.html', context)
```
De maintenant, vous serez en mesure d'utiliser le str fonction dans jinja2 modèle

InformationsquelleAutor Jahid
2

Pour importer toutes les fonctions internes, vous pouvez utiliser:
```
app.jinja_env.globals.update(__builtins__)
```
Ajouter .__dict__ après __builtins__ si cela ne fonctionne pas.

Basé sur John32323 réponse.

InformationsquelleAutor Solomon Ucko

Vous devez vous connecter pour publier un commentaire.