Teanga teimpléad Django: do ríomhchláraitheoirí PythonLink to this heading#

Athróga agus cuardaighLink to this heading#

Ní mór go mbeadh aon litir (A-Z), aon dhigit (0-9), béim (ach níor chóir dóibh tosú le béim) nó ponc ar ainmneacha athróga.

Tá brí speisialta ag poncanna i rindreáil teimpléad. Léiríonn ponc in ainm athraitheach**cuardach**. Go sonrach, nuair a bhíonn an córas teimpléid ag teacht le ponc in ainm athraitheach, déanann sé iarracht na cuardaigh seo a leanas, san ord seo:

• Cuardach foclóra. Sampla: ``foo ["bar"] ``

• Cuardach tréithe. Sampla: foo.bar

• Cuardach liosta-innéacs. Sampla: ``foo [bar] ``

Tabhair faoi deara go léirmhínítear “barra” i abairt teimpléid cosúil le {{foo.bar}} mar shreang litriúil agus gan úsáid luach an athróg “barra”, má tá ceann ann i gcomhthéacs an teimpléid.

Úsáideann an córas teimpléid an chéad chineál cuardaigh a oibríonn. Is loighic ghearrchiorcad é. Seo cúpla sampla:

>>> from django.template import Context, Template
>>> t = Template("My name is {{ person.first_name }}.")
>>> d = {"person": {"first_name": "Joe", "last_name": "Johnson"}}
>>> t.render(Context(d))
"My name is Joe."

>>> class PersonClass:
...     pass
...
>>> p = PersonClass()
>>> p.first_name = "Ron"
>>> p.last_name = "Nasty"
>>> t.render(Context({"person": p}))
"My name is Ron."

>>> t = Template("The first stooge in the list is {{ stooges.0 }}.")
>>> c = Context({"stooges": ["Larry", "Curly", "Moe"]})
>>> t.render(c)
"The first stooge in the list is Larry."

Má tá aon chuid den athróg inghlaoch, déanfaidh an córas teimpléid iarracht glaoch air. Sampla:

>>> class PersonClass2:
...     def name(self):
...         return "Samantha"
...
>>> t = Template("My name is {{ person.name }}.")
>>> t.render(Context({"person": PersonClass2}))
"My name is Samantha."

Tá athróga inghlaonta beagán níos casta ná athróga nach dteastaíonn ach cuardach díreach uathu. Seo roinnt rudaí le coinneáil i gcuimhne:

• Má ardaíonn an t-athróg eisceacht nuair a thugtar air, iomadófar an eisceacht, mura bhfuil tréith silent_variable_failure ag an eisceacht a luach True. Má tá tréith silent_variable_failure ag an eisceacht **, a bhfuil a luach True, tabharfaidh an t-athróg mar luach rogha cumraíochta string_if_invalid an innill (teaghrán folamh, de réir réamhshocraithe). Sampla:

  Python console

  >>> t = Template("My name is {{ person.first_name }}.")
  >>> class PersonClass3:
  ...     def first_name(self):
  ...         raise AssertionError("foo")
  ...
  >>> p = PersonClass3()
  >>> t.render(Context({"person": p}))
  Traceback (most recent call last):
  ...
  AssertionError: foo
  
  >>> class SilentAssertionError(Exception):
  ...     silent_variable_failure = True
  ...
  >>> class PersonClass4:
  ...     def first_name(self):
  ...         raise SilentAssertionError
  ...
  >>> p = PersonClass4()
  >>> t.render(Context({"person": p}))
  "My name is ."
  

  Tabhair faoi deara go bhfuil: exc: Django.Core.Exceptions.ObjectDoesNotExist, arb é an bunaicme do gach eisceacht API bunachar sonraí Django doesNotExist, ag silent_variable_fail = True`. Mar sin má tá teimpléid Django á úsáid agat le rudaí samhail Django, teipeann ar aon eisceacht DoesNotExist go ciúin.

• Ní féidir athróg a ghlaoch ach mura bhfuil aon argóintí riachtanacha aige. Seachas sin, cuirfidh an córas luach rogha string_if_invalid` an innill ar ais.

• D'fhéadfadh fo-iarsmaí a bheith ann agus tú ag glaoch ar roinnt athróga, agus bheadh sé amhnach nó poll slándála chun ligean don chóras teimpléid rochtain a fháil orthu.

  Sampla maith is ea an modh: meth: ~django.db.models.model.delete ar gach réad samhail Django. Níor chóir go mbeadh cead ag an gcóras teimpléid rud éigin mar seo a dhéanamh:

  Django template

  I will now delete this valuable data. {{ data.delete }}
  

  To prevent this, set an alters_data attribute on the callable variable. The template system won't call a variable if it has alters_data=True set, and will instead replace the variable with string_if_invalid, unconditionally. The dynamically-generated delete() and save() methods on Django model objects get alters_data=True automatically. Example:

  Code

  def sensitive_function(self):
      self.database_record.delete()
  
  
  sensitive_function.alters_data = True
  

• Occasionally you may want to turn off this feature for other reasons, and tell the template system to leave a variable uncalled no matter what. To do so, set a do_not_call_in_templates attribute on the callable with the value True. The template system then will act as if your variable is not callable (allowing you to access attributes of the callable, for example).

Conas a láimhseáiltear athrógaLink to this heading#

Go ginearálta, mura bhfuil athróg ann, cuireann an córas teimpléid luach rogha cumraíochta string_if_invalid an innill isteach, atá socraithe go ````(an teaghrán folamh) de réir réamhshocraithe.

Ní chuirfear scagairí a chuirtear i bhfeidhm ar athróg neamhbhailí ach amháin má shocraítear string_if_invalid go ``(an teaghrán folamh). Má tá ``string_if_invalid socraithe ar aon luach eile, déanfar neamhaird ar scagairí athraitheacha.

Tá an t-iompar seo beagán difriúil do na clibeanna teimpléad if ``, `for agus athghrúpa. Má chuirtear athróg neamhbhailí ar fáil do cheann de na clibeanna teimpléad seo, léirmhínítear an t-athróg mar None. Cuirtear scagairí i bhfeidhm i gcónaí ar athróga neamhbhailí laisti

Má tá string_if_invalid %s', cuirfear ainm an athróg neamhbhailí in ionad an marcóra formáide.

Athróga ionsuiteLink to this heading#

I ngach comhthéacs tá True, Fréag` agus None. Mar a bheadh ag súil leat, réitíonn na hathróga seo ar na rudaí comhfhreagracha Python

Teorainneacha le litríochtaí teaghránLink to this heading#

Níl aon bhealach ag teanga teimpléad Django éalú ó na carachtair a úsáidtear dá chomhréir féin. Mar shampla, teastaíonn an clibe:ttag: templatetag más gá duit seicheamh carachtair mar {% agus %} a aschur.

Tá saincheist den chineál céanna ann más mian leat na seicheamh seo a chur san áireamh i scagaire teimpléid nó i gclibeanna Mar shampla, agus clib bloc á pháirseáil, féachann parser teimpléad Django ar an gcéad tarlú de %} ``tar éis {%``. Cuireann sé seo cosc ar "%} "``a úsáid mar shreang litriúil. Mar shampla, ardófar ``TemplateSyntaxError do na nathanna seo a leanas:

{% include "template.html" tvar="Some string literal with %} in it." %}

{% with tvar="Some string literal with %} in it." %}{% endwith %}

Is féidir an tsaincheist chéanna a spreagadh trí sheicheamh áirithe a úsáid in argóintí scagaire:

{{ some.variable|default:"}}" }}

Más gá duit teaghráin a úsáid leis na seicheamh seo, stóráil iad in athróga teimpléad nó bain úsáid as clib nó scagaire teimpléad saincheaptha chun an teorannú a réiteach.

Ag baint úsáide as requestContextLink to this heading#

class RequestContext(request, dict_=None, processors=None, use_l10n=None, use_tz=None, autoescape=True)Link to this definition#

Tagann Django le rang speisialt:class: ~django.template.context, Django.Template.requestContext, a ghníomhaíonn beagán difriúil ón ngnáth`django.template.context``. Is é an chéad difríocht ná go dtógann sé an:class: ~django.http.httpRequest mar a chéad argóint. Mar shampla:

c = RequestContext(
    request,
    {
        "foo": "bar",
    },
)

Is é an dara difríocht ná go ndéanann sé an comhthéacs a líonadh go huathoibríoch le cúpla athróg, de réir rogha cumraíochta ``context_processors' an innill.

Is é an rogha context_processors` liosta de ghlaonna -- ar a dtugtar próiseálaithe comhthéacsa -- a ghlacann réad iarratais mar argóint agus a thugann foclóir míreanna atá le cumasc sa chomhthéacs. Sa chomhad socruithe réamhshocraithe a ghintear, tá na próiseálaithe comhthéacs seo a leanas san inneall teimpléid réamh

[
    "django.template.context_processors.request",
    "django.contrib.auth.context_processors.auth",
    "django.contrib.messages.context_processors.messages",
]

In addition to these, RequestContext always enables 'django.template.context_processors.csrf'. This is a security related context processor required by the admin and other contrib apps, and, in case of accidental misconfiguration, it is deliberately hardcoded in and cannot be turned off in the context_processors option.

Cuirtear gach próiseálaí i bhfeidhm in ord. Ciallaíonn sé sin, má chuireann próiseálaí amháin athróg leis an gcomhthéacs agus má chuireann an dara próiseálaí athróg leis an ainm céanna, cuirfidh an dara ceann ar an gcéad cheann. Mínítear na próiseálaithe réamhshocraithe thíos

Chomh maith leis sin, is féidir leat liosta de phróiseálaithe breise a thabhar:class: RequestContext, ag baint úsáide as an tríú argóint roghnach suímh, ``próiseálaithe ``. Sa sampla seo, faigheann an sampla:class: requestContext athróg ``ip_address ``:

from django.http import HttpResponse
from django.template import RequestContext, Template


def ip_address_processor(request):
    return {"ip_address": request.META["REMOTE_ADDR"]}


def client_ip_view(request):
    template = Template("{{ title }}: {{ ip_address }}")
    context = RequestContext(
        request,
        {
            "title": "Your IP Address",
        },
        [ip_address_processor],
    )
    return HttpResponse(template.render(context))

Próiseálaithe comhthéacs teimpléLink to this heading#

Seo a dhéanann gach ceann de na próiseálaithe ionsuite:

Scríobh do phróiseálaithe comhthéacsLink to this heading#

Tá comhéadan simplí ag próiseálaí comhthéacs: Is feidhm Python é a thógann argóint amháin, an:class: ~django.http.httpRequest réad, agus a thugann foclóir ar ais a chuirtear le comhthéacs an teimpléid.

Mar shampla, chun an socrú:setting: DEFAULT_FROM_EMAIL a chur le gach comhthéacs:

from django.conf import settings


def from_email(request):
    return {
        "DEFAULT_FROM_EMAIL": settings.DEFAULT_FROM_EMAIL,
    }

Is féidir le próiseálaithe comhthéacs saincheaptha maireachtáil áit ar bith i do Is é an cúram le Django ná go ndéanann an rogha context_processors'` i do shocrú: `TEMPLATES` - nó an argóint ``context_processors de:class: ~django.template.ENGINE má tá tú ag úsáid go díreach é.

<TEMPLATES-DIRS>An rogha: Socrú: DIRSLink to this heading#

Inis do Django cad iad d'eolair <TEMPLATES-DIRS>í teimpléad tríd an rogha: setting: DIRS `a úsáid sa socrú: `TEMPLATES i do chomhad socruithe - nó an argóint dirs` de:class: ~DJANGO.TEMPLATE.ENGINE. Ba chóir é seo a shocrú ar liosta teaghráin ina bhfuil cosáin iomlána chuig d'eolairí teimpléid:

TEMPLATES = [
    {
        "BACKEND": "django.template.backends.django.DjangoTemplates",
        "DIRS": [
            "/home/html/templates/lawrence.com",
            "/home/html/templates/default",
        ],
    },
]

Is féidir le do theimpléid dul áit ar bith is mian leat, fad is atá na heolairí agus na teimpléid inléite ag an bhfreastalaí gréasáin. Is féidir leo aon síneadh a theastaíonn uait a bheith acu, mar shampla .html nó .txt, nó ní féidir leo aon síneadh a bheith acu ar chor ar bith.

Tabhair faoi deara gur chóir go n-úsáidfeadh na cosáin seo slashes ar aghaidh i stíl Unix, fiú ar Windows.

Cineálacha lódóraLink to this heading#

De réir réamhshocraithe, úsáideann Django lódóir teimpléad bunaithe ar chóras comhaid, ach tagann Django le cúpla luchtaire teimpléad eile, a bhfuil a fhios acu conas teimpléid a luchtú ó fhoinsí eile.

Tá cuid de na luchtóirí eile seo díchumasaithe de réir réamhshocraithe, ach is féidir leat iad a ghníomhachtú trí rogha 'loaders'` a chur le do chúlcheann ``DjangoTemplates sa socrú:setting: TEMPLATES nó argóint loaders a chur chuig:class: ~django.template.ENGINE. Ba chóir go mbeadh “loaders” ina liosta de shreangáin nó tupáil, áit a léiríonn gach ceann acu rang lódóra teimpléid. Seo iad na lódálaithe teimpléad a thagann le Django:

Django.Template.Loaders.Filesystem.Loader

class filesystem.LoaderLink to this definition#

<TEMPLATES-DIRS>Luchtaíonn teimpléid ón gcóras comhaid, de réir: socrú: `DIRS `.

Tá an lódóir seo cumasaithe de réir réamhshocraithe. Mar sin féin ní gheobhaidh sé aon teimpléid go dtí go socraíonn tú: socrú: `DIRS <TEMPLATES-DIRS>`ar liosta neamh-folamh:

Code

TEMPLATES = [
    {
        "BACKEND": "django.template.backends.django.DjangoTemplates",
        "DIRS": [BASE_DIR / "templates"],
    }
]

Is féidir leat DIRS' a shárú freisin agus eolairí ar leith a shonrú le haghaidh lódóir córas comhaid áirithe:

Code

TEMPLATES = [
    {
        "BACKEND": "django.template.backends.django.DjangoTemplates",
        "OPTIONS": {
            "loaders": [
                (
                    "django.template.loaders.filesystem.Loader",
                    [BASE_DIR / "templates"],
                ),
            ],
        },
    }
]

Django.Template.Loaders.App_Directories.Loader

class app_directories.LoaderLink to this definition#

Luchtaíonn teimpléid ó aipeanna Django ar an gcóras comhaid. I gcás gach aip in:setting: INSTALLED_APPS, féachann an lódóir fo-eolaire ``teimpléid ``. Má tá an eolaire ann, féachann Django teimpléid ann.

Ciallaíonn sé seo gur féidir leat teimpléid a stóráil le d'aipeanna aonair. Cuidíonn sé seo freisin le apps Django a dháileadh le teimpléid réamhshocraithe.

Mar shampla, don socrú seo:

Code

INSTALLED_APPS = ["myproject.polls", "myproject.music"]

... ansin cuardóidh get_template ('foo.html') ```foo.html sna heolairí seo, san ord seo:

• /cosáin/to/mo thionscad/truailleach/teimpléidí/

• /cosáin/to/mo thionscad/ceol/teimpléidí/

... agus úsáidfidh sé an ceann a aimsíonn sé ar dtús.

Tá an t-ordú de:setting: INSTALLED_APPS suntasach! Mar shampla, más mian leat riarachán Django a shaincheapadh, b'fhéidir go roghnaíonn tú an teimpléad caighdeánach admin/base_site.html` a shárú, ó ``django.contrib.admin ``, le do `admin/base_site.html féin i myproject.polls. Ní mór duit a chinntiú ansin go dtagann do myproject.polls roim django.contrib.admin in:setting: INSTALLED_APPS, ar shlí eile luchtálfar django.contrib.admin ar dtús agus déanfar neamhaird ar do chuid féin.

Tabhair faoi deara go ndéanann an lódóir barrfheabhsú nuair a ritheann sé ar dtús: cuireann sé liosta díobh a bhfuil fo-eolaire ``teimpléid ``ag pacáistí: 'SETTING: INSTALLED_APPS.

<TEMPLATES-APP_DIRS>Is féidir leat an lódóir seo a chumasú trí shocrú: socrú: APP_DIRS `go ``True`:

Code

TEMPLATES = [
    {
        "BACKEND": "django.template.backends.django.DjangoTemplates",
        "APP_DIRS": True,
    }
]

Django.Template.Loaders.Cached.Loader

class cached.LoaderLink to this definition#

Cé go bhfuil córas teimpléid Django tapa go leor, más gá dó do theimpléid a léamh agus a thiomsú gach uair a dhéantar iad a léiriú, is féidir leis an lasbhreas as sin cur suas.

Cumraíonn tú an lódóir teimpléad taisceáilte le liosta de luchtóirí eile ar chóir dó fillteadh. Úsáidtear na lódálaithe fillte chun teimpléid anaithnid a aimsiú nuair a bhíonn siad ar dtús. Ansin stóráilíonn an lódóir taisceáilte an ``Teimpléad` tiomsaithe i gcuimhne. Cuirtear an cás “Teimpléad” a chosc ar ais le haghaidh iarratais ina dhiaidh sin chun an teimpléad céanna a luchtú.

Cumasaítear an lódóir seo go huathoibríoch mura ndéantar: socrú: `OPTIONS ['loader'] <TEMPLATES-OPTIONS>`a shonrú.

Is féidir leat taiscáil teimpléad a shonrú de láimh le roinnt lódóirí teimpléad saincheaptha ag baint úsáide as socruithe

Code

TEMPLATES = [
    {
        "BACKEND": "django.template.backends.django.DjangoTemplates",
        "DIRS": [BASE_DIR / "templates"],
        "OPTIONS": {
            "loaders": [
                (
                    "django.template.loaders.cached.Loader",
                    [
                        "django.template.loaders.filesystem.Loader",
                        "django.template.loaders.app_directories.Loader",
                        "path.to.custom.Loader",
                    ],
                ),
            ],
        },
    }
]

Django.Template.Loaders.Locmem.Loader

class locmem.LoaderLink to this definition#

Luchtaíonn teimpléid ó fhoclóir Python. Tá sé seo úsáideach le haghaidh tástála.

Glacann an lódóir seo foclóir teimpléid mar an chéad argóint:

Code

TEMPLATES = [
    {
        "BACKEND": "django.template.backends.django.DjangoTemplates",
        "OPTIONS": {
            "loaders": [
                (
                    "django.template.loaders.locmem.Loader",
                    {
                        "index.html": "content here",
                    },
                ),
            ],
        },
    }
]

Tá an lódóir seo díchumasaithe de réir réamhshocraithe

Úsáideann Django na lódálaithe teimpléad in ord de réir an rogha ```loaders'. Úsáideann sé gach lódóir go dtí go bhfaigheann lódóir cluiche.

Modhanna lódóraLink to this heading#

class LoaderLink to this definition#

Luchtaíonn teimpléid ó fhoinse ar leith, mar shampla an córas comhaid nó bunachar sonraí.

get_template_sources(template_name)Link to this definition#

Modh a thógann template_name agus a thugann torthaige:class: ~django.template.base.origin cásanna do gach foinse féideartha.

For example, the filesystem loader may receive 'index.html' as a template_name argument. This method would yield origins for the full path of index.html as it appears in each template directory the loader looks at.

Ní gá don modh a fhíorú go bhfuil an teimpléad ann ag cosán ar leith, ach ba cheart dó a chinntiú go bhfuil an cosán bailí. Mar shampla, cinntíonn lódóir an chórais chomhaid go bhfuil an cosán faoi eolaire teimpléad bailí.

get_contents(origin)Link to this definition#

Tugann sé an t-ábhar do theimpléad a thugtar a: class: ~django.template.base.origin sampla.

Seo an áit a léifeadh lódóir córas comhaid ábhar ón gcóras comhaid, nó go léifeadh lódóir bunachar sonraí ón mbunachar sonraí. Mura bhfuil teimpléad meaitseála ann, ba chóir dó seo earráid a:exc: ~django.template.templateDoesNotExist a ardú.

get_template(template_name, skip=None)Link to this definition#

Tugann sé réad Template ar ais do template_name ar leith trí lupáil trí thorthaí ó:meth: get_template_sources agus glaoch: meth: get_contents. Filleann sé seo an chéad teimpléad meaitseála. Mura bhfaightear aon teimpléad, ardaítear :exc: ~django.template.templateDoesNotExist.

Is é an argóint roghnach `skip ``ná liosta de bhunús le neamhaird a dhéanamh agus teimpléid á leathnú. Ligeann sé seo teimpléid teimpléid eile den ainm céanna a leathnú. D'úsáid sé freisin chun earráidí athshlánaithe a sheachaint.

Go ginearálta, is leor sainmhíniú: meth: get_template_sources agus:meth: get_contents le haghaidh lódóirí teimpléad saincheaptha. De ghnáth ní gá `get_template () ``a shárú.