Wie verwende ich Django-Vorlagen ohne den Rest von Django?

Ich möchte die Django-Vorlagen-Engine in meinem (Python-) Code verwenden, erstelle jedoch keine Django-basierte Website. Wie verwende ich es, ohne eine settings.py-Datei (und andere) zu haben und die Umgebungsvariable DJANGO_SETTINGS_MODULE festlegen zu müssen?

Wenn ich den folgenden Code ausführe:

>>> import django.template
>>> from django.template import Template, Context
>>> t = Template('My name is {{ my_name }}.')

Ich bekomme:

ImportError: Settings cannot be imported, because environment variable DJANGO_SETTINGS_MODULE is undefined.

Die Lösung ist einfach. Es ist eigentlich gut dokumentiert , aber nicht zu leicht zu finden. (Ich musste mich umsehen - es kam nicht auf, als ich ein paar verschiedene Google-Suchanfragen ausprobierte.)

Der folgende Code funktioniert:

>>> from django.template import Template, Context
>>> from django.conf import settings
>>> settings.configure()
>>> t = Template('My name is {{ my_name }}.')
>>> c = Context({'my_name': 'Daryl Spitzer'})
>>> t.render(c)
u'My name is Daryl Spitzer.'

In der Django-Dokumentation (oben verlinkt) finden Sie eine Beschreibung einiger Einstellungen, die Sie möglicherweise definieren möchten (als zu konfigurierende Schlüsselwortargumente).

Die Jinja2- Syntax ist mit sehr wenigen Unterschieden fast identisch mit der von Django, und Sie erhalten eine viel leistungsfähigere Vorlagen-Engine, die Ihre Vorlage auch zu Bytecode kompiliert (SCHNELL!).

Ich benutze es für Vorlagen, auch in Django selbst, und es ist sehr gut. Sie können auch problemlos Erweiterungen schreiben, wenn eine gewünschte Funktion fehlt.

Hier einige Demonstrationen der Codegenerierung:

>>> import jinja2
>>> print jinja2.Environment().compile('{% for row in data %}{{ row.name | upper }}{% endfor %}', raw=True) 
from __future__ import division
from jinja2.runtime import LoopContext, Context, TemplateReference, Macro, Markup, TemplateRuntimeError, missing, concat, escape, markup_join, unicode_join
name = None

def root(context, environment=environment):
    l_data = context.resolve('data')
    t_1 = environment.filters['upper']
    if 0: yield None
    for l_row in l_data:
        if 0: yield None
        yield unicode(t_1(environment.getattr(l_row, 'name')))

blocks = {}
debug_info = '1=9'

Gibt es einen bestimmten Grund, warum Sie Djangos Vorlagen verwenden möchten? Sowohl Jinja als auch Genshi sind meiner Meinung nach überlegen.

Wenn Sie wirklich wollen, lesen Sie die Django-Dokumentation untersettings.py . Insbesondere der Abschnitt "Einstellungen ohne Einstellung verwenden DJANGO_SETTINGS_MODULE". Verwenden Sie so etwas:

from django.conf import settings
settings.configure (FOO='bar') # Your settings go here

Ich würde auch jinja2 empfehlen. Es gibt einen schönen Artikel über djangovs. jinja2, der einige detaillierte Informationen darüber enthält, warum Sie den späteren bevorzugen sollten.

Laut der Jinja-Dokumentation ist die Python 3-Unterstützung noch experimentell . Wenn Sie also mit Python 3 arbeiten und die Leistung kein Problem darstellt, können Sie die integrierte Vorlagen-Engine von django verwenden.

Django 1.8 hat die Unterstützung für mehrere Template-Engines eingeführt, die eine Änderung der Art und Weise erfordern, wie Templates initialisiert werden. Sie müssen explizit konfigurieren, settings.DEBUGwelche von der von django bereitgestellten Standardvorlagen-Engine verwendet wird. Hier ist der Code, um Vorlagen zu verwenden, ohne den Rest von Django zu verwenden.

from django.template import Template, Context
from django.template.engine import Engine

from django.conf import settings
settings.configure(DEBUG=False)

template_string = "Hello {{ name }}"
template = Template(template_string, engine=Engine())
context = Context({"name": "world"})
output = template.render(context) #"hello world"

Wenn Sie Django Template für Django> 1.7 verwenden möchten, müssen Sie zusätzlich zu dem, was andere geschrieben haben, Ihre settings.configure (...) angeben, die Variable TEMPLATES aufrufen und django.setup () wie folgt aufrufen:

from django.conf import settings

settings.configure(TEMPLATES=[
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': ['.'], # if you want the templates from a file
        'APP_DIRS': False, # we have no apps
    },
])

import django
django.setup()

Dann können Sie Ihre Vorlage wie gewohnt aus einer Zeichenfolge laden:

from django import template   
t = template.Template('My name is {{ name }}.')   
c = template.Context({'name': 'Rob'})   
t.render(c)

Und wenn Sie die DIRS-Variable in der .configure von der Festplatte geschrieben haben:

from django.template.loader import get_template
t = get_template('a.html')
t.render({'name': 5})

Django-Fehler: Es ist kein DjangoTemplates-Backend konfiguriert

http://django.readthedocs.io/en/latest/releases/1.7.html#standalone-scripts

Ich würde auch Jinja sagen . Es ist definitiv leistungsstärker als die Django Templating Engine und es ist eigenständig .

Wenn dies ein externer Plug für eine vorhandene Django-Anwendung war, können Sie einen benutzerdefinierten Befehl erstellen und die Vorlagen-Engine in Ihrer Projektumgebung verwenden. So was;

manage.py generatereports --format=html

Aber ich denke nicht, dass es sich lohnt, nur die Django Templating Engine anstelle von Jinja zu verwenden.

Vielen Dank für die Hilfe Leute. Hier ist noch eine Ergänzung. Der Fall, in dem Sie benutzerdefinierte Vorlagen-Tags verwenden müssen.

Angenommen, Sie haben dieses wichtige Vorlagen-Tag im Modul read.py

from django import template

register = template.Library()

@register.filter(name='bracewrap')
def bracewrap(value):
    return "{" + value + "}"

Dies ist die HTML-Vorlagendatei "temp.html":

{{var|bracewrap}}

Schließlich ist hier ein Python-Skript, das alle miteinander verbindet

import django
from django.conf import settings
from django.template import Template, Context
import os

#load your tags
from django.template.loader import get_template
django.template.base.add_to_builtins("read")

# You need to configure Django a bit
settings.configure(
    TEMPLATE_DIRS=(os.path.dirname(os.path.realpath(__file__)), ),
)

#or it could be in python
#t = Template('My name is {{ my_name }}.')
c = Context({'var': 'stackoverflow.com rox'})

template = get_template("temp.html")
# Prepare context ....
print template.render(c)

Die Ausgabe wäre

{stackoverflow.com rox}

Ich habe es gefunden:

http://snippets.dzone.com/posts/show/3339

Tu es nicht. Verwenden Sie stattdessen StringTemplate - es gibt keinen Grund, eine andere Template-Engine in Betracht zu ziehen, sobald Sie davon erfahren.

Ich stimme den obigen Aussagen zu. Jinja 2 ist eine ziemlich gute Obermenge von Django-Vorlagen für den allgemeinen Gebrauch. Ich denke, sie arbeiten daran, die Django-Vorlagen etwas weniger an die settings.py zu koppeln, aber Jinja sollte gut für Sie tun.

Während Sie die manage.pyShell ausführen:

>>> from django import template   
>>> t = template.Template('My name is {{ me }}.')   
>>> c = template.Context({'me': 'ShuJi'})   
>>> t.render(c)

Google AppEngineverwendet die Django-Vorlagen-Engine. Haben Sie sich angesehen, wie sie dies tun? Sie könnten das möglicherweise einfach verwenden.