---
title: "Teanga teimpléad Django: do ríomhchláraitheoirí Python"
version: 5.2
locale: ga
source: https://docs.djangoproject.com/ga/5.2/ref/templates/api/
canonical: https://djangodocs.dev/ga/5.2/ref/templates/api/
---
# Teanga teimpléad Django: do ríomhchláraitheoirí Python

Míníonn an doiciméad seo córas teimpléid Django ó pheirspictíocht theicniúil - conas a oibríonn sé agus conas é a leathnú. Má tá tagairt á lorg agat maidir le comhréiteach na teanga, féach:doc: /ref/templates/language.

Glacann sé le tuiscint ar theimpléid, comhthéacsanna, athróga, clibeanna agus rindreáil. Tosaigh leis an: ref: réamhrá don teanga teimpléid Django \<template-language-intro\>\`mura bhfuil tú eolach ar na coincheapa seo.

## Forbhreathnú

Is próiseas trí chéim é an córas teimpléid a úsáid i Python:

1. Cumraíonn tú an:class: Inneall.
2. Tiomsaíonn tú cód teimpléad isteach i a:class: Teimpléad.
3. Déanann tú an teimpléad a: class: Context.

De ghnáth braitheann tionscadail Django ar:ref: ardleibhéal, APIs agnóstacha cúltaca \<template-engines\>\`do gach ceann de na céimeanna seo in ionad APIs leibhéal níos ísle an chórais teimpléid:

1. Maidir le gach ceann: aicme: ~django.template.backends.django.djangoTemplates sa socrú: TEMPLATES, déanann Django ain:class: Engine. :class: ~django.template.backends.django.djangoTemplates fillteann:class: Engine agus cuireann sé in oiriúint don API cúltaca teimpléad coitianta.
2. Soláthraíonn an modúl: mod: django.template.loader feidhmeanna mar: func: ~django.template.loader.get\_template chun teimpléid a luchtú. Filleann siad `django.template.backends.django.template` a fhilleann an fhíor:class: django.template.template.
3. Tá a: meth: ~django.template.backends.base.template.base.template.render modh a fuarthas sa chéim roimhe seo a mharsaíonn comhthéacs agus b'fhéidir iarratas isteach i a:class: Context agus a thosclaíonn an rindreáil chuig an bun:class: Template.

## Inneall a chumrú

Má tá tú ag úsáid an backend: :class: ~django.template.backends.django.djangoTemplates, is dócha nach é seo an doiciméadú atá á lorg agat. Tá sampla den aicme `Engine` a thuairiscítear thíos inrochtana ag baint úsáide as tréith `inneal` den chúltaca sin agus cuirtear aon réamhshocraithe tréithe a luaitear thíos ag an méid a chuirtear trí:class: ~django.template.backends.django.djangoTemplates.

#### `class Engine(dirs=None, app_dirs=False, context_processors=None, debug=False, loaders=None, string_if_invalid='', file_charset='utf-8', libraries=None, builtins=None, autoescape=True)`

Agus “Inneall” á dtionscnamh, caithfear gach argóint a rith mar argóintí eochairfhocal:

- Is liosta eolairí é `dirs` inar chóir don inneall comhaid foinse teimpléad a lorg. \<django.template.loaders.filesystem.Loader\>Úsáidtear é chun: class: FileSystem.loader a chumrú.

  Tá sé réamhshocraithe go liosta folamh.
- Ní théann app\_dirs\` i bhfeidhm ach ar luach réamhshocraithe `loaders`. Féach thíos.

  Tá sé réamhshocraithe go `False`.
- Rialaíonn `autoescape` an bhfuil autoescaping HTML cumasaithe.

  Tá sé réamhshocraithe go `True`.

  > **Warning**
  >
  > Socraigh é go `False` ach má tá teimpléid neamh-HTML á rindreáil agat!
- Is é context\_processors\` liosta de chosáin poncaireacha Python chuig glaonna a úsáidtear chun an comhthéacs a líonadh nuair a dhéantar teimpléad a léiriú le hiarratas. Glacann na glaonna seo réad iarratais mar argóint agus filleann siad a: class: dict d'earraí atá le cumasc sa chomhthéacs.

  Tá sé réamhshocraithe go liosta folamh.

  Féach: Class: ~django.template.requestContext le haghaidh tuilleadh faisnéise.
- Is boolean é `debug` a chasann air/as modh dífhabhtaithe teimpléad. Más “True” é, stóráilfidh an t-inneall teimpléid faisnéis bhreise dífhabhtaithe is féidir a úsáid chun tuarascáil mhionsonraithe a thaispeáint d'aon eisceacht a ardaítear le linn rindreáil teimpléad.

  Tá sé réamhshocraithe go `False`.
- Is liosta d'aicmí lódóirí teimpléad é ```loaders`, a shonraítear mar teaghráin. Tá a fhios ag gach rang ``Loader` conas teimpléid a iompórtáil ó fhoinse áirithe. Go roghnach, is féidir tuple a úsáid in ionad sreang. Ba chóir gurb é an chéad mhír sa tuple ainm aicme ``Loader ``, cuirtear míreanna ina dhiaidh sin chuig an ``Loader``` le linn an tionscnaimh.

  Tá sé réamhshocraithe ar liosta ina bhfuil:

  - `'Django.Template.Loaders.FileSystem.Loader'`
  - `'Django.Template.Loaders.App_Directories.Loader'` más rud é agus amháin má tá `app_dirs` `True`.

  Ansin filtear na luchtóirí seo in:class: django.template.loaders.cached.loader.

  Féach:ref: template-loaders le haghaidh sonraí.
- Is é `string_if_invalid` an t-aschur, mar shreang, ar chóir don chóras teimpléid a úsáid le haghaidh athróga neamhbhailí (m.sh. mí-litrithe).

  Déanann sé réamhshocraithe don teaghrán folamh.

  Féach:ref: invalid-template-athraitheoir le haghaidh sonraí.
- Is é file\_charset\` an charset a úsáidtear chun comhaid teimpléad a léamh ar dhiosca.

  Tá sé réamhshocraithe go `'utf-8'`.
- `` `leabharlanna ``: Foclóir lipéid agus cosáin poncanna Python de mhodúil clibeanna teimpléad le clárú leis an inneall teimpléad. Úsáidtear é seo chun leabharlanna nua a chur leis nó lipéid mhalartacha a sholáthar do na cinn atá ann Mar shampla:

  ```
  Engine(
      libraries={
          "myapp_tags": "path.to.myapp.tags",
          "admin.urls": "django.contrib.admin.templatetags.admin_urls",
      },
  )
  ```

  \<load\>Is féidir leabharlanna a luchtú tríd an eochair chomhfhreagrach foclóra a rith chuig an gclibe:ttag: {% load%}.
- `` `builtins' ``: Liosta de na cosáin poncaí Python de mhodúil clibeanna teimpléad le cur la:doc: builtin\</ref/templates/builtins\> s'. Mar shampla:

  ```
  Engine(
      builtins=["myapp.builtins"],
  )
  ```

  \<load\>Is féidir clibeanna agus scagairí ó leabharlanna ionsuite a úsáid gan glaoch ar dtús ar an gclibe:ttag: {% load%}.

#### `static Engine.get_default()`

Filleann sé an bunlin:class: Engine ón gcéad inneall cumraithe:class: ~django.template.backends.django.djangoTemplates. Ardaithe:exc: ~Django.Core.Exceptions.ImProperlyConfigured mura bhfuil aon innill chumraithe.

Tá sé ag teastáil chun APIs a chaomhnú atá ag brath ar inneall cumraithe go domhanda atá cumraithe go hinmheánach. Déantar aon úsáid eile a dhíspreagadh go láidir.

#### `Engine.from_string(template_code)`

Tiomsaíonn sé an cód teimpléad a thugtar agus cuireann sé ar ais a:class: Teimpléad réad.

#### `Engine.get_template(template_name)`

Luchtaíonn teimpléad leis an ainm tugtha, tiomsaíonn sé é agus filleann sé a: class: Teimpléad réad.

#### `Engine.select_template(template_name_list)`

Cos:Meth: ~Engine.get\_Template, ach amháin go dtógann sé liosta ainmneacha agus tugann sé an chéad teimpléad a fuarthas ar ais.

## Teimpléad á luchtú

Is é an bealach a mholtar chun a:class: Template a chruthú ná modhanna monarchan an: class: Engine: :meth: ~Engine.get\_Template, :meth: ~Engine.select\_Template agus:meth: ~Engine.from\_string.

I dtionscadal Django ina sainmhíníonn an socrú:setting: TEMPLATES a:class: ~django.template.backends.django.djangoTemplates, is féidir a:class: Template a chur isteach go díreach. Má shainmhínítear níos mó ná inneall amháin: class: ~django.template.backends.django.djangoTemplates, úsáidfear an chéad cheann.

#### `class Template`

Tá an rang seo ina chónaí ag `Django.Template.Template`. Glacann an tógálaí argóint amháin - an cód teimpléad amh:

```
from django.template import Template

template = Template("My name is {{ my_name }}.")
```

> **Taobh thiar de na radhairc**
>
> Ní dhéanann an córas do chód teimpléad amh a pháirseáil ach uair amháin - nuair a chruthaíonn tú an réad Teimpléad\`. Ón sin ar aghaidh, stóráiltear é go hinmheánach mar struchtúr crann le haghaidh feidhmíochta.
>
> Tá fiú an parsáil féin tapa go leor. Tarlaíonn an chuid is mó den pháirseáil trí ghlao amháin ar léiriú amháin, gearr, rialta.

## Comhthéacs a rindreáil

Nuair a bheidh réad tiomsaithe:class: Template agat, is féidir leat comhthéacs a rinneadh leis. Is féidir leat an teimpléad céanna a athúsáid chun é a dhéanamh arís agus arís eile le comhthéacsanna éagsúla

#### `class Context(dict_=None, autoescape=True, use_l10n=None, use_tz=None)`

Tógann tógálaí `Django.Template.Context` argóint roghnach - foclóir a mhapáil ainmneacha athraitheacha chuig luachanna athraitheacha.

Is féidir trí argóint eochairfhocal roghnach a shonrú freisin:

- Rialaíonn `autoescape` an bhfuil autoescaping HTML cumasaithe.

  Tá sé réamhshocraithe go `True`.

  > **Warning**
  >
  > Socraigh é go `False` ach má tá teimpléid neamh-HTML á rindreáil agat!
- Sáraíonn `use_l10n` cibé an mbeidh luachanna logánaithe de réir réamhshocraithe. Má tá sé socraithe go `True` déanfar uimhreacha agus dátaí a fhormáidiú bunaithe ar an áitiúil.

  Tá sé réamhshocraithe go `None`.

  Féach:ref: topic-l10n-templates le haghaidh sonraí.
- Athraíonn `use_tz` cibé an ndéantar dátaí a thiontú go dtí an am áitiúil nuair a dhéantar iad a rinneadh i dteimpléad. Má tá sé socraithe ar `True` déanfar gach dáta a léiriú ag baint úsáide as an crios ama áitiúil. Tá tosaíocht air seo thar: setting: USE\_TZ.

  Tá sé réamhshocraithe go `None`.

  Féach:ref: criosanna ama-in-theimpléid le haghaidh sonraí.

Mar shampla úsáid, féach:ref: playing-with-context thíos.

#### `Template.render(context)`

Glaoigh ar an modh render () \`\`réad: \`Teimpléad le a:class: Context chun an teimpléad a “líonadh”:

```pycon
>>> from django.template import Context, Template
>>> template = Template("My name is {{ my_name }}.")

>>> context = Context({"my_name": "Adrian"})
>>> template.render(context)
"My name is Adrian."

>>> context = Context({"my_name": "Dolores"})
>>> template.render(context)
"My name is Dolores."
```

### Athróga agus cuardaigh

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:

```pycon
>>> 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:

```pycon
>>> 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:

  ```pycon
  >>> 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:

  ```html+django
  I will now delete this valuable data. {{ data.delete }}
  ```

  Chun é seo a chosc, socraigh tréith `alters_data` ar an athróg inghlaonta. Ní ghlaoifidh an córas teimpléid athróg má tá `alters_data=True` tacar aige, agus ina ionad sin cuirfidh sé string\_if\_invalid\` in ionad an athróg, gan choinníollacha. Faigheann na modhanna: meth: ~django.db.models.model.delete agus: meth: ~django.db.models.model.save ar rudaí samhail Django `alters_data=true` go huathoibríoch. Sampla:

  ```
  def sensitive_function(self):
      self.database_record.delete()

  sensitive_function.alters_data = True
  ```
- Uaireanta b'fhéidir gur mhaith leat an ghné seo a mhúchadh ar chúiseanna eile, agus insint don chóras teimpléid athróg a fhágáil gan glaoch is cuma cad é. Chun é sin a dhéanamh, socraigh tréith `do_not_call_in_templates` ar an luach `True`. Gníomhóidh an córas teimpléid ansin amhail is mura bhfuil d'athróg inghlaonta (ligeann duit rochtain a fháil ar thréithe an inghlaonta, mar shampla).

### Conas a láimhseáiltear athróga

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.

> **Chun críocha dífhabhtaithe amháin!**
>
> Cé gur féidir le string\_if\_invalid\` a bheith ina uirlis dífhabhtaithe úsáideach, is droch-smaoineamh é a chasadh air mar 'réamhshocrú forbartha'.
>
> Braitheann go leor teimpléid, lena n-áirítear cuid de Django, ar thús an chórais teimpléid nuair a bhíonn athróg nach bhfuil ann. Má shannann tú luach seachas ```"``do `string_if_invalid```, beidh fadhbanna rindreála agat leis na teimpléid agus na suíomhanna seo.
>
> Go ginearálta, níor cheart `string_if_invalid` a chumasú ach d'fhonn fadhb teimpléad ar leith a dhífhabhtú, ansin a ghlanadh nuair a bheidh dífhabhtú críochnaithe.

### Athróga ionsuite

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án

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:

```html+django
{% 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:

```html+django
{{ 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 imirt le rudaí `Context`

An chuid is mó den am, cuirfidh tú rudaí:class: Context trí fhoclóir lán-dhaonra a chur isteach chuig ```Context () ``. Ach is féidir leat míreanna a chur leis agus a scriosadh ó réad ``Context``` nuair a bheidh sé curtha isteach freisin, ag baint úsáide as comhréir caighdeánach foclóra:

```pycon
>>> from django.template import Context
>>> c = Context({"foo": "bar"})
>>> c["foo"]
'bar'
>>> del c["foo"]
>>> c["foo"]
Traceback (most recent call last):
...
KeyError: 'foo'
>>> c["newvariable"] = "hello"
>>> c["newvariable"]
'hello'
```

#### `Context.get(key, otherwise=None)`

Tugann sé an luach le haghaidh `eochair` má tá `eochair` sa chomhthéacs, arís eile filleann eile .

#### `Context.setdefault(key, default=None)`

Má tá `eochair` sa chomhthéacs, filleann sé a luach ar ais. Seachas sin cuireann sé isteach `eochair` le luach `default` agus tugann sé `default` ar ais.

#### `Context.pop()`

#### `Context.push()`

#### `exception ContextPopException`

Is cruach é réad `Context`. Is é sin, is féidir leat ```bhrú () ``agus ``pop ()``` é. Má tá tú ```pop () ``an iomarca, ardóidh sé ``django.template.contextPopException```:

```pycon
>>> c = Context()
>>> c["foo"] = "first level"
>>> c.push()
{}
>>> c["foo"] = "second level"
>>> c["foo"]
'second level'
>>> c.pop()
{'foo': 'second level'}
>>> c["foo"]
'first level'
>>> c["foo"] = "overwritten"
>>> c["foo"]
'overwritten'
>>> c.pop()
Traceback (most recent call last):
...
ContextPopException
```

Is féidir leat ```push () ``a úsáid freisin mar bhainisteoir comhthéacs chun a chinntiú go dtugtar meaitseáil ``pop ()```.

```pycon
>>> c = Context()
>>> c["foo"] = "first level"
>>> with c.push():
...     c["foo"] = "second level"
...     c["foo"]
...
'second level'
>>> c["foo"]
'first level'
```

Cuirfear gach argóint a chuirtear chuig push () \`\`chuig an tógálaí \`\`dict\` a úsáidtear chun an leibhéal comhthéacs nua a thógáil.

```pycon
>>> c = Context()
>>> c["foo"] = "first level"
>>> with c.push(foo="second level"):
...     c["foo"]
...
'second level'
>>> c["foo"]
'first level'
```

#### `Context.update(other_dict)`

Chomh maith le ```push () ``agus `pop ()```, sainmhíníonn an réad `Context` modh update () freisin. Oibríonn sé seo cosúil le push () ach glacann sé foclóir mar argóint agus brúíonn sé an foclóir sin ar an gcruach in ionad ceann folamh.

```pycon
>>> c = Context()
>>> c["foo"] = "first level"
>>> c.update({"foo": "updated"})
{'foo': 'updated'}
>>> c["foo"]
'updated'
>>> c.pop()
{'foo': 'updated'}
>>> c["foo"]
'first level'
```

Cosúil le ```push () ``, is féidir leat ``update ()``` a úsáid mar bhainisteoir comhthéacs chun a chinntiú go dtugtar meaitseáil pop () .

```pycon
>>> c = Context()
>>> c["foo"] = "first level"
>>> with c.update({"foo": "second level"}):
...     c["foo"]
...
'second level'
>>> c["foo"]
'first level'
```

\<howto-writing-custom-template-tags\>Tagann `Context` a úsáid mar chruac úsáideach in:ref: roinnt clibeanna teimpléad saincheapaithe.

#### `Context.flatten()`

Ag baint úsáide as modh ```flatten () ``is féidir leat cruach ``Context``` iomlán a fháil mar fhoclóir amháin lena n-áirítear athróga tógála.

```pycon
>>> c = Context()
>>> c["foo"] = "first level"
>>> c.update({"bar": "second level"})
{'bar': 'second level'}
>>> c.flatten()
{'True': True, 'None': None, 'foo': 'first level', 'False': False, 'bar': 'second level'}
```

Úsáidtear modh flatten () \`\`go hinmheánach freisin chun rudaí \`\`Context\` a dhéanamh inchomparáide.

```pycon
>>> c1 = Context()
>>> c1["foo"] = "first level"
>>> c1["bar"] = "second level"
>>> c2 = Context()
>>> c2.update({"bar": "second level", "foo": "first level"})
{'foo': 'first level', 'bar': 'second level'}
>>> c1 == c2
True
```

Is féidir leis an toradh ó flatten () \`\`a bheith úsáideach i dtástálacha aonaid chun comparáid a dhéanamh idir \`\`Context\` i gcoinne `dict`:

```
class ContextTest(unittest.TestCase):
    def test_against_dictionary(self):
        c1 = Context()
        c1["update"] = "value"
        self.assertEqual(
            c1.flatten(),
            {
                "True": True,
                "None": None,
                "False": False,
                "update": "value",
            },
        )
```

### Ag baint úsáide as `requestContext`

#### `class RequestContext(request, dict_=None, processors=None, use_l10n=None, use_tz=None, autoescape=True)`

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",
]
```

Chomh maith leis seo, cumasaíonn :class: RequestContext `` `django.template.context_processors.csrf' `` i gcónaí. Is próiseálaí comhthéacs a bhaineann le slándáil é seo a éilíonn an riarachán agus aipeanna contrib eile, agus, i gcás míchchumraíochta de thaisme, déantar é a chóstáil isteach d'aon ghnó agus ní féidir é a mhúchadh sa rogha context\_processors.

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

> **Nuair a bhíonn próiseálaithe comhthéacs**
>
> Déantar próiseálaithe comhthéacs i bhfeidhm ar bharr sonraí comhthéacs Ciallaíonn sé seo go bhféadfadh próiseálaí comhthéacs athróga a sholáthraigh tú do d:class: Context nó:class: RequestContext, mar sin bí cúramach ainmneacha athraitheacha a sheachaint a fhorluíonn leo siúd a sholáthraíonn do phróiseálaithe comhthéacs.
>
> Más mian leat go dtógfadh sonraí comhthéacs tosaíocht ar phróiseálaithe comhthéacs, bain úsáid as an patrún seo a leanas
>
> ```
> from django.template import RequestContext
>
> request_context = RequestContext(request)
> request_context.push({"my_name": "Adrian"})
> ```
>
> Déanann Django é seo chun ligean do shonraí comhthéacs próiseálaithe comhthéacs a shárú in APIs mar: func: ~django.shortcuts.render agus:class: ~django.template.response.templateResponse.

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é

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

#### `django.contrib.auth.context_processors.auth`

#### `auth(request)`

Má tá an próiseálaí seo cumasaithe, beidh na hathróga seo i ngach `RequestContext`:

- `user` -- Sampla `Auth.user` a léiríonn an t-úsáideoir atá logáilte isteach faoi láthair (nó sampla AnonymousUser\`, mura bhfuil an cliant logáilte isteach).
- `perms` -- Sampla de django.contrib.auth.context\_processors.permWrapper\`, a léiríonn na ceadanna atá ag an úsáideoir logáilte isteach faoi láthair.

#### `django.template.context_processors.debug`

#### `debug(request)`

Má tá an próiseálaí seo cumasaithe, beidh an dá athróg seo i ngach `RequestContext` \- ach amháin má tá do shuíomh: DEBUG socraithe go True\` agus seoladh IP an iarratais (Request.meta \['REMOTE\_ADDR'\] ) sa socrú: INTERNAL\_IPS:

- `debug` -- `Fíor-`. Is féidir leat é seo a úsáid i dteimpléid chun a thástáil an bhfuil tú i mód: socrú: DEBUG.
- `sql_queries` -- Liosta de `{'sql':..., 'time':...}` foclóirí, a léiríonn gach ceist SQL a tharla go dtí seo le linn an iarratais agus cé chomh fada a thóg sé. Tá an liosta in ord de réir alias bunachar sonraí agus ansin trí cheist. Gintear sé go leisciúil ar rochtain.

#### `django.template.context_processors.i18n`

#### `i18n(request)`

Má tá an próiseálaí seo cumasaithe, beidh na hathróga seo i ngach `RequestContext`:

- `LANGUAGES` \- Luach an shocraithe:setting: LANGUAGES.
- `LANGUAGE_BIDI` \- `True` má tá teanga reatha ina theanga ar dheis go clé, m.sh. an Eabhrais, Araibis. `Fréag` más teanga de chlé go deis í, m.sh. Béarla, Fraincis, Gearmáinis.
- `LANGUAGE_COD` -- `REQUEST.LANGUAGE_COD`, má tá sé ann. Seachas sin, luach an socrú: setting: LANGUAGE\_CODE.

Féach: ref: clibeanna teimpléad i18n \<i18n-template-tags\>\`le haghaidh clibeanna teimpléad a ghineann na luachanna céanna.

#### django.template.context\_processors.media \`\`

Má tá an próiseálaí seo cumasaithe, beidh athróg ```MEDIA_URL` i ngach ``RequestContext```, ag soláthar luach an socruithe: MEDIA\_URL.

#### `django.template.context_processors.static`

#### `static(request)`

Má tá an próiseálaí seo cumasaithe, beidh athróg ```STATIC_URL` i ngach ``RequestContext```, ag soláthar luach an socruithe: STATIC\_URL.

#### `django.template.context_processors.csrf`

Cuireann an próiseálaí seo comhartha a theastaíonn ó chlib teimpléad:ttag: csrf\_token le haghaidh cosanta in aghaidh: doc: Cross Site Request Forgeries \</ref/csrf\>.

#### `django.template.context_processors.request`

Má tá an próiseálaí seo cumasaithe, beidh athróg `request` i ngach requestContext\`, arb é sin an reatha:class: ~django.http.httpRequest.

#### `django.template.context_processors.tz`

#### `tz(request)`

Má tá an próiseálaí seo cumasaithe, beidh athróg `TIME_ZONE` i ngach RequestContext\`, ag soláthar ainm an chrios ama atá gníomhach faoi láthair.

#### django.contrib.teachtaireachtaí context\_processors.teachtaireachtaí \`\`

Má tá an próiseálaí seo cumasaithe, beidh an dá athróg seo i ngach `RequestContext`:

- teachtaireachtaí \- Liosta teachtaireachtaí (mar theagáin) atá socraithe trí:doc: teachtaireachtaí creata'. \</ref/contrib/messages\>
- \<message-level-constants\>\`\`DEFAULT\_MESSAGE\_LEVELS\`\` - Mapáil ar ainmneacha leibhéal na teachtaireachta chuig:ref: a luach uimhriúil .

### Scríobh do phróiseálaithe comhthéacs

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 é.

## Teimpléid á lódáil

Go ginearálta, stóráilfidh tú teimpléid i gcomhaid ar do chóras comhaid seachas an API ísealleibhéil: class: ~django.template.template a úsáid tú féin. Sábháil teimpléid in eolaire a shonraítear mar eolaire teimpléad\*\*.

\<TEMPLATES-DIRS\>Déanann Django cuardach ar eolairí teimpléid i roinnt áiteanna, ag brath ar do shocruithe luchtaithe teimpléad (féach “Cineálacha lódóra” thíos), ach is é an bealach is bunúsaí chun eolairí teimpléad a shonrú ná an rogha: socrú: DIRS a úsáid.

### \<TEMPLATES-DIRS\>An rogha: Socrú: DIRS

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óra

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.Loader`

\<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:

```
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:

```
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.Loader`

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:

```
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\`:

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

`Django.Template.Loaders.Cached.Loader`

#### `class cached.Loader`

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

```
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",
                    ],
                ),
            ],
        },
    }
]
```

> **Note**
>
> Tá gach ceann de na clibeanna teimpléad Django ionsuite sábháilte le húsáid leis an lódóir taisce, ach má tá clibeanna teimpléad saincheaptha á úsáid agat a thagann ó phacáistí tríú páirtí, nó a scríobh tú tú féin, ba cheart duit a chinntiú go bhfuil cur i bhfeidhm Node do gach clib sábháilte ó snáithe. \<template\_tag\_thread\_safety\>Le haghaidh tuilleadh faisnéise, féach:ref: breithnithe sábháilteachta snáithe clib teimpléad

`Django.Template.Loaders.Locmem.Loader`

#### `class locmem.Loader`

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:

```
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.

## Luchtaithe saincheaptha

Is féidir teimpléid a luchtú ó fhoinsí breise ag baint úsáide as luchtóirí teimpléad sain Ba chóir go n-oidhreodh ranganna saincheaptha `Loader` ó django.template.loaders.base.loader\` agus na modhanna ```get_contents () ``agus ``get_template_sources ()``` a shainiú.

### Modhanna lódóra

#### `class Loader`

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

#### `get_template_sources(template_name)`

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

Mar shampla, féadfaidh lódóir an chórais chomhaid `index.html'` a fháil mar argóint `template_name`. Tabharfadh an modh seo bunús don chonair iomlán “index.html” mar atá le feiceáil i ngach eolaire teimpléad a bhreathnaíonn an lódóir air.

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

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

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ú.

> **Tógáil do chuid féin**
>
> \<django/template/loaders\>Mar shamplaí, léigh an:source: cód foinse do luchtóirí ionsuite Django.

## Bunús teimpléad

Tá “bunús” ag teimpléid ina bhfuil tréithe ag brath ar an bhfoinse as a luchtaítear iad.

#### `class Origin(name, template_name=None, loader=None)`

#### `name`

An cosán chuig an teimpléad mar a chuir an lódóir teimpléid ar ais. Maidir le luchtóirí a léann ón gcóras comhaid, is é seo an cosán iomlán chuig an teimpléad.

\<unknown\_source\>Má dhéantar an teimpléad a thionscnamh go díreach seachas trí lódóir teimpléid, is luach teaghrán é seo de .

#### `template_name`

An cosán coibhneasta chuig an teimpléad mar a rith isteach sa lódóir teimpléad

Má dhéantar an teimpléad a thionscnamh go díreach seachas trí lódóir teimpléid, is é seo `None`.

#### `loader`

An tsampla lódóir teimpléad a thóg an Bunaid' seo.

Má dhéantar an teimpléad a thionscnamh go díreach seachas trí lódóir teimpléid, is é seo `None`.

[`django.template.loaders.cached.Loader`](#django.template.loaders.cached.Loader) requires all of its
wrapped loaders to set this attribute, typically by instantiating
the `Origin` with `loader=self`.