---
title: "Iarratais"
version: 6.0
locale: ga
source: https://docs.djangoproject.com/ga/6.0/ref/applications/
canonical: https://djangodocs.dev/ga/6.0/ref/applications/
---
# Iarratais

Tá clárlann feidhmchlár suiteáilte i Django a stórálann cumraíocht agus a sholáthraíonn ionchraíocht. Coinníonn sé liosta de na samhlacha atá ar fáil freisin: doc: samhlach \</topics/db/models\>.

Tugtar ar an gclárlann seo: attr: ~django.apps.apps agus tá sé ar fáil in:mod: django.apps:

```pycon
>>> from django.apps import apps
>>> apps.get_app_config("admin").verbose_name
'Administration'
```

## Tionscadail agus iarratais

Déanann an téarma\*\*tionscad\*\* cur síos ar fheidhmchlár gréasáin Django. Sainmhínítear pacáiste an tionscadail Python go príomha ag modúl socruithe, ach de ghnáth bíonn rudaí eile ann. Mar shampla, nuair a reáchtáil tú `django-admin startproject mysite` gheobhaidh tú eolaire tionscadail `mysite` ina bhfuil pacáiste Python `mysite` le settings.py\`, urls.py\`, asgi.py\` agus `wsgi.py`. Is minic a leathnaítear an pacáiste tionscadail chun rudaí cosúil le daingneáin, CSS agus teimpléid nach bhfuil ceangailte le feidhmchlár áirithe a áireamh.

Is iondúil gurb é fréamhsheoltóir tionscadail\*\* (an ceann ina bhfuil manage.py ') an coimeádán d'iarratais uile tionscadail nach bhfuil suiteáilte ar leithligh.

Déanann an téarma\*\*iarratas\*\* cur síos ar phacáiste Python a sholáthraíonn roinnt sraith gnéithe. Iarratais: doc: Is féidir é a athúsáid' i dtionscadail éagsúla. \</intro/reusable-apps/\>

I measc na bhfeidhmchláir tá teaglaim de mhúnlaí, tuairimí, teimpléid, clibeanna teimpléad, comhaid statacha, URLanna, middleware, srl. De ghnáth déantar iad a sreangú isteach i dtionscadail leis an socrú:: INSTALLED\_APPS agus go roghnach le meicníochtaí eile mar URLConfs, an socrú: MIDDLEWARE nó oidhreacht teimpléad.

Tá sé tábhachtach a thuiscint gur sraith cód é feidhmchlár Django a idirghníomhaíonn le codanna éagsúla den chreat. Níl aon rud den sórt sin ann mar réad Feidhmchláir\`. Mar sin féin, tá cúpla áit ann ina gcaithfidh Django idirghníomhú le feidhmchláir suiteáilte, go príomha le haghaidh cumraíochta agus freisin le haghaidh ionbhreithniú. Sin an fáth go gcoinníonn clárlann an fheidhmchláir meiteashonraí in an:class: ~django.apps.appconfig sampla do gach feidhmchlár suiteáilte.

Níl aon srian ann nach féidir pacáiste tionscadail a mheas mar iarratas freisin agus go mbeadh samhlacha aige, srl. (rud a d'éilfeadh é a chur chuig: setting: INSTALLED\_APPS).

## Iarratais a chumrú

Chun feidhmchlár a chumrú, cruthaigh modúl `apps.py` taobh istigh den fheidhmchlár, ansin sainmhínigh fo-aicme de:class: AppConfig ann.

When: Setting: INSTALLED\_APPS tá an cosán poncanach chuig modúl feidhmchláir, de réir réamhshocraithe, má aimsíonn Django go díreach fo-aicme ceann:class: AppConfig sa fho-mhodúl `apps.py`, úsáideann sé an chumraíocht sin don fheidhmchlár. Féadfar an t-iompar seo a dhíchumasú trí shocrú: attr: AppConfig.default go `False`.

Má tá níos mó ná fo-aicme amháin: class: AppConfig sa modúl `apps.py`, cuardóidh Django ceann amháin ina bhfuil: attr: AppConfig.default `True`.

Má aimsítear fo-aicme no:class: AppConfig, úsáidfear an rang base: class: AppConfig.

De rogha air sin, d'fhéadfadh go mbeadh an cosán poncaithe chuig rang cumraíochta ag :setting: INSTALLED\_APPS chun é a shonrú go sainráite:

```
INSTALLED_APPS = [
    ...,
    "polls.apps.PollsAppConfig",
    ...,
]
```

### Maidir le húdair iarratais

Má tá aip inphlugáilte á chruthú agat ar a dtugtar “Rock 'n' roll”, seo conas a chuirfeá ainm ceart ar fáil don riarachán:

```
# rock_n_roll/apps.py

from django.apps import AppConfig

class RockNRollConfig(AppConfig):
    name = "rock_n_roll"
    verbose_name = "Rock ’n’ roll"
```

Luchtaítear `RocknrollConfig` go huathoibríoch nuai:setting: INSTALLED\_APPS tá `` `rock_n_roll' ``. Más gá duit é seo a chosc, socraí:attr: ~appconfig.default go `False` sa sainmhíniú ranga.

Is féidir leat fo-aicmí roinnt: class: AppConfig a sholáthar le hiompraíochtaí éagsúla. Chun insint do Django cén ceann atá le húsáid de réir réamhshocraithe, socraí:attr: ~AppConfig.default go `True` ina sainmhíniú. Más mian le d'úsáideoirí cumraíocht neamh-réamhshocraithe a roghnú, ní mór dóibh `rock_n_roll'` a chur in ionad leis an gcosán ponctha chuig an rang sonrach sin ina socrú: setting: INSTALLED\_APPS.

Insíonn an tréith: Attr: AppConfig.name do Django cén feidhmchlár a bhaineann an chumraíocht seo leis. Is féidir leat aon tréith eile a dhoiciméadaithe sa tagairt API: class: ~django.apps.appconfig a shainiú.

[`AppConfig`](#django.apps.AppConfig) subclasses may be defined anywhere. The `apps.py`
convention merely allows Django to load them automatically when
[`INSTALLED_APPS`](/ga/6.0/ref/settings/#std-setting-INSTALLED_APPS) contains the path to an application module rather
than the path to a configuration class.

> **Note**
>
> Má allmhairíonn do chód clárlann an iarratais i `__init__.py` iarratais, beidh an t-ainm apps\` ag teacht leis an bhfo-mhodúl `apps`. Is é an cleachtas is fearr ná an cód sin a bhogadh chuig fo-mhodúl agus é a iompórtáil. Is é an réiteach ná an clárlann a iompórtáil faoi ainm difriúil:
>
> ```
> from django.apps import apps as django_apps
> ```

### Do úsáideoirí feidhmchláir

Má tá “Rock 'n' roll” á úsáid agat i dtionscadal ar a dtugtar anthology , ach ba mhaith leat go dtaispeánfaidh sé suas mar “Jazz Manouche” ina ionad sin, is féidir leat do chumraíocht féin a sholáthar:

```
# anthology/apps.py

from rock_n_roll.apps import RockNRollConfig

class JazzManoucheConfig(RockNRollConfig):
    verbose_name = "Jazz Manouche"

# anthology/settings.py

INSTALLED_APPS = [
    "anthology.apps.JazzManoucheConfig",
    # ...
]
```

Taispeánann an sampla seo ranganna cumraíochta sonracha tionscadail atá suite i bhfo-mhodúl ar a dtugtar `apps.py`. Is coinbhinsiún é seo, ní riachtanas. :class: Is féidir fo-aicmí AppConfig a shainiú áit ar bith.

Sa chás seo, ní mór go mbeadh an cosán poncaithe chuig an rang cumraíochta ag :setting: INSTALLED\_APPS toisc go gcónaíonn sé lasmuigh d'iarratas agus dá bhrí sin ní féidir é a bhrath go huathoibríoch.

## Cumraíocht feidhmchláir

#### `class AppConfig`

Stóráil rudaí cumraíochta feidhmchláir meiteashonraí d'fheidh Is féidir roinnt tréithe a chumrú in:class: ~django.apps.appconfig fo-aicmí. Tá daoine eile leagtha síos ag Django agus léite amháin.

### tréithe inchumraithe

#### `AppConfig.name`

Conair iomlán Python chuig an bhfeidhmchlár, m.sh. `` `django.contrib.admin' ``.

Sainmhíníonn an tréith seo cén feidhmchlár a bhaineann an chumraíocht leis. Caithfear é a shocrú i ngach:class: ~django.apps.appconfig fo-aicmí.

Caithfidh sé a bheith uathúil ar fud tionscadal Django.

#### `AppConfig.label`

Ainm gearr don iarratas, m.sh. ``` ``admin' ```

Ligeann an tréith seo feidhmchlár a athlipéadú nuair a bhíonn lipéid contrártha ag dhá iarratas. Tá sé réamhshocraithe go dtí an chomhpháirt deireanach de ainm . Ba chóir go mbeadh sé ina aitheantóir bailí Python.

Caithfidh sé a bheith uathúil ar fud tionscadal Django.

> **Warning**
>
> Mar thoradh ar an tréith seo a athrú tar éis imirce a chur i bhfeidhm ar iarratas beidh athruithe briste ar thionscadal nó, i gcás aip in-athúsáidte, aon shuiteálacha atá ann cheana den aip sin. Tá sé seo toisc go n-úsáidtear `AppConfig.label` i dtáblaí bunachar sonraí agus comhaid imirce agus tú ag tagairt do aip sa liosta spleáchais.

#### `AppConfig.verbose_name`

Ainm inléite don duine don iarratas, m.sh. “Riarachán”.

Tá an tréith seo réamhshocraithe go label.title () .

#### `AppConfig.path`

Conair an chórais chomhaid chuig an eolaire feidhmchláir, m.sh. `'/usr/lib/pythonx.y/dist-packages/django/contrib/admin'`.

I bhformhór na gcásanna, is féidir le Django é seo a bhrath agus a shocrú go huathoibríoch, ach is féidir leat athshlánú follasach a sholáthar mar thréith ranga ar d'fho-aicme: ~django.apps.appconfig. I gcúpla cás tá sé seo ag teastáil; mar shampla más 'pacáiste spás ainmneacha\`\_ é an pacáiste aip le cosáin iolracha.

#### `AppConfig.default`

Socraigh an tréith seo go False\` chun Django a chosc ó rang cumraíochta a roghnú go huathoibríoch. Tá sé seo úsáideach nuair a shainmhíníonn `apps.py` ach fo-aicme amháin: class: AppConfig ach níl tú ag iarraidh Django é a úsáid de réir réamhshocraithe.

Socraigh an tréith seo go True\` chun a rá le Django rang cumraíochta a roghnú go huathoibríoch. Tá sé seo úsáideach nuair a shainmhíníonn `apps.py` níos mó ná fo-aicme amháin: class: AppConfig agus ba mhaith leat Django ceann acu a úsáid de réir réamhshocraithe.

De réir réamhshocraithe, níl an tréith seo socraithe.

#### `AppConfig.default_auto_field`

The implicit primary key type to add to models within this app.

Reusable applications that define models **must** set this attribute to
ensure migrations included in the application match the models. Otherwise,
migrations will be generated for the application when a user runs
[`makemigrations`](/ga/6.0/ref/django-admin/#django-admin-makemigrations) with a different [`DEFAULT_AUTO_FIELD`](/ga/6.0/ref/settings/#std-setting-DEFAULT_AUTO_FIELD),
which may conflict with future migrations shipped by the application.

For example, to keep using [`AutoField`](/ga/6.0/ref/models/fields/#django.db.models.AutoField):

```
default_auto_field = "django.db.models.AutoField"
```

De réir réamhshocraithe, is é seo an luach de:setting: DEFAULT\_AUTO\_FIELD.

### Tréithe léite amháin

#### `AppConfig.module`

\<module 'django.contrib.admin' from 'django/contrib/admin/\_\_init\_\_.py'\>Modúl fréimhe don fheidhmchlár, m.sh. .

#### `AppConfig.models_module`

\<module 'django.contrib.admin.models' from 'django/contrib/admin/models.py'\>Modúl ina bhfuil na samhlacha, m.sh. .

D'fhéadfadh sé a bheith `None` mura bhfuil modúl ```samhlacha ``san iarratas. Tabhair faoi deara nach n-astaítear comharthaí a bhaineann leis an mbunachar sonraí mar: data: `~django.db.models.signals.pre_migrate` agus:data: `~django.db.models.signals.post_migrate` ach le haghaidh feidhmchláir a bhfuil modúl ``models``` acu.

### Modhanna

#### `AppConfig.get_models(include_auto_created=False, include_swapped=False)`

Tugann sé athrá arís de: class: ~django.db.models.model ranganna don fheidhmchlár seo.

Éilíonn clárlann an aip a bheith daonra go hiomlán.

#### `AppConfig.get_model(model_name, require_ready=True)`

Tugann sé sean:class: ~django.db.models.model leis an `model_name` a thugtar. Tá `model_name` neamh-íogair ó cháis.

Ardaithe:exc: LookuPerror mura bhfuil samhail den sórt sin ann san iarratas seo.

Requires the app registry to be fully populated unless the
`require_ready` argument is set to `False`. `require_ready` behaves
exactly as in [`apps.get_model()`](#django.apps.apps.get_model).

#### `AppConfig.ready()`

Is féidir le fo-aicmí an modh seo a shárú chun tascanna tosaithe a dhéanamh mar chomharthaí a chlárú. Tugtar air chomh luath agus a bhíonn an chlárlann daonra go hiomlán.

Cé nach féidir leat samhlacha a iompórtáil ag an leibhéal modúl ina bhfuil aicmí: class: ~django.apps.appconfig sainmhínithe, is féidir leat iad a iompórtáil i ready () \`, ag baint úsáide as ráiteas `import` nó:meth: ~AppConfig.get\_model.

Má tá tú ag clárú: mod: comharthaí samhail \<django.db.models.signals\>, is féidir leat tagairt a dhéanamh don seoltóir trína lipéad teaghrán in ionad an rang samhail féin a úsáid.

Sampla:

```
from django.apps import AppConfig
from django.db.models.signals import pre_save

class RockNRollConfig(AppConfig):
    # ...

    def ready(self):
        # importing model classes
        from .models import MyModel  # or...

        MyModel = self.get_model("MyModel")

        # registering signals with the model's string label
        pre_save.connect(receiver, sender="app_label.MyModel")
```

> **Warning**
>
> Although you can access model classes as described above, avoid
> interacting with the database in your [`ready()`](#django.apps.AppConfig.ready) implementation.
> This includes model methods that execute queries
> ([`save()`](/ga/6.0/ref/models/instances/#django.db.models.Model.save),
> [`delete()`](/ga/6.0/ref/models/instances/#django.db.models.Model.delete), manager methods etc.), and
> also raw SQL queries via `django.db.connection`. Your
> [`ready()`](#django.apps.AppConfig.ready) method will run during startup of every management
> command. For example, even though the test database configuration is
> separate from the production settings, `manage.py test` would still
> execute some queries against your **production** database!

> **Note**
>
> Sa ghnáthphróiseas tionscnaíochta, ní ghlaonn Django ar an modh réidh \`\`ach uair amháin. Ach i roinnt cásanna cúinne, go háirithe i dtástálacha atá ag feiceáil le feidhmchláir suiteáilte, d'fhéadfaí “réidh” a ghlaoch níos mó ná uair amháin. Sa chás sin, scríobh modhanna idempotent, nó cuir bratach ar d'aicmí \`\`AppConfig chun cosc a chur ar chód athreáchtáil ar chóir a fhorghníomhú go díreach uair amháin.

### Pacáistí spás ainmneacha mar aipeanna

Tugtar “pacáistí spás ainmneacha” ar phacáistí Python gan comhad `__init__.py` agus féadfar iad a scaipeadh ar fud eolairí iolracha ag áiteanna éagsúla ar sys.path\` (féach: pep: 420).

Éilíonn feidhmchláir Django cosán chórais comhaid bonn amháin ina ndéanfaidh Django (ag brath ar chumraíocht) cuardach ar theimpléid, sócmhainní statacha, srl. Mar sin, ní fhéadfaidh pacáistí spás ainmneacha a bheith ina bhfeidhmchláir Django ach má tá ceann díobh seo a leanas fíor:

1. Níl ach suíomh amháin ag an bpacáiste spás ainmneacha i ndáiríre (ie níl sé scaipthe thar níos mó ná eolaire amháin.)
2. Tá a: attr: ~django.apps.appconfig tréith aicme: ~django.apps.appconfig a úsáidtear chun an feidhmchlár a chumrú: ~django.apps.path tréith aicme, arb é an cosán eolaire iomlán a úsáidfidh Django mar an bonn aonair don fheidhmchlár.

Mura gcomhlíontar ceachtar de na coinníollacha seo, ardóidh Django: exc: ~Django.Core.Exceptions.ImProperlyConfigured.

## Clárlann iarratais

#### `apps`

Soláthraíonn an clárlann feidhmchláir an API poiblí seo a Meastar go bhfuil modhanna nach bhfuil liostaithe thíos príobháideacha agus féadfaidh siad athrú gan fógra.

#### `apps.ready`

Tréith Boolean atá socraithe go `True` tar éis don chlárlann a bheith daonra go hiomlán agus tugtar gach modh: meth: AppConfig.ready.

#### `apps.get_app_configs()`

Filleann sé cásanna in-athraithe de:class: ~django.apps.appconfig.

#### `apps.get_app_config(app_label)`

Tugann tuairisce:class: ~django.apps.appconfig don iarratas leis an `app_label` a thugtar. Ardaithe:exc: LookuPerror mura bhfuil aon fheidhmchlár den sórt sin ann.

#### `apps.is_installed(app_name)`

Seiceálann an bhfuil iarratas leis an ainm tugtha sa chlárlann. Is é `app_name` ainm iomlán an aip, m.sh. `` `django.contrib.admin' ``.

#### `apps.get_model(app_label, model_name, require_ready=True)`

Tugann sé sean:class: ~django.db.models.model leis an `app_label` agus `model_name` a thugtar. Mar aicearra, glacann an modh seo le argóint amháin sa fhoirm `app_label.model_name`. Tá `model_name` cás-neamh-íogair.

Ardaithe:exc: LookuPerror mura bhfuil aon fheidhmchlár nó samhail den sórt sin ann. Ardaithe:exc: ValueError nuair a ghlaonn sé le argóint amháin nach bhfuil ponc amháin go díreach ann.

Éilíonn clárlann an aip a bheith daonra go hiomlán mura bhfuil an argóint requeri\_ready\` socraithe go `False`.

\<app-loading-process\>Má shocraíonn `requi_ready` go False\`, is féidir samhlacha a lorg suas: ref: agus clárlann an aip á dhaonrú \`, go sonrach le linn an dara céim ina n-allmhairíonn sé samhlacha. Ansin tá an éifeacht chéanna ag \`\`get\_model () \`\`agus an tsamhail a allmhairiú. Is é an príomhchás úsáide ná ranganna samhail a chumrú le socruithe, mar shampla:setting: \`AUTH\_USER\_MODEL.

Nuair is é `requi_ready` False\`,, get\_model () ```filleann ``get_model ()``` aicme samhail nach bhféadfadh a bheith feidhmiúil go hiomlán (d'fhéadfadh rochtainí droim a bheith in easnamh, mar shampla) go dtí go mbeidh clárlann an aip daonra go hiomlán. Ar an gcúis seo, is fearr `requi_ready` a fhágáil go luach réamhshocraithe `True` nuair is féidir.

## Próiseas tionscnaíochta

### Conas a luchtaítear feidhmchláir

When Django starts, [`django.setup()`](#django.setup) is responsible for populating the
application registry.

#### `setup(set_prefix=True)`

Cumraíonn Django ag:

- Ag luchtú na socruithe.
- Logáil a chur ar bun.
- Má tá `set_prefix` Fíor, socraigh an réimír script réiteach URL to:setting: FORCE\_SCRIPT\_NAME má tá sé sainmhínithe, nó `/` ar shlí eile.
- An clárlann iarratais a thionscnamh.

Tugtar an feidhm seo go huathoibríoch:

- Agus freastalaí HTTP á reáchtáil agat trí thacaíocht ASGI nó WSGI Django.
- Agus ordú bainistíochta á ghairm agat.

Caithfear é a ghlaoch go sainráite i gcásanna eile, mar shampla i scripteanna Python simplí.

Cuirtear clárlann an iarratais a thionscnamh i dtrí chéim. Ag gach céim, próiseálann Django gach feidhmchlár san ordó:setting: INSTALLED\_APPS.

1. Allmhairíonn Django ar dtús gach mír in:setting: INSTALLED\_APPS.

   Más rang cumraíochta feidhmchláir é, allmhairíonn Django pacáiste fréimhe an fheidhmchláir, atá sainmhínithe ag a tréith: attr: ~AppConfig.name. Más pacáiste Python é, lorgaíonn Django cumraíocht feidhmchláir i bhfo-mhodúl apps.py, nó cruthaíonn sé cumraíocht feidhmchláir réamhshocraithe eile.

   *At this stage, your code shouldn't import any models!*

   Is é sin le rá, níor cheart do phacáistí fréimhe d'iarratais agus na modúil a shainmhíníonn do ranganna cumraíochta feidhmchláir aon mhúnlaí a allmhairiú, fiú

   Go docht, ceadaíonn Django samhlacha a allmhairiú nuair a luchtar a gcumraíocht feidhmchlá Mar sin féin, d'fhonn srianta gan ghá a sheachaint ar an ord de:setting: INSTALLED\_APPS, moltar go láidir gan aon mhúnlaí a allmhairiú ag an gcéim seo.

   Once this stage completes, APIs that operate on application configurations
   such as [`get_app_config()`](#django.apps.apps.get_app_config) become usable.
2. Ansin déanann Django iarracht an fo-mhodúl samhlacha de gach feidhmchlár a allmhairiú, má tá ceann ann.

   Ní mór duit na samhlacha go léir i models.py\` nó `models/__init__.py` d'iarratais a shainiú nó a allmhairiú. Seachas sin, b'fhéidir nach mbeadh an chlárlann iarratais daonra go hiomlán ag an bpointe seo, rud a d'fhéadfadh a bheith ina chúis le mífhe

   Once this stage completes, APIs that operate on models such as
   [`get_model()`](#django.apps.apps.get_model) become usable.
3. Finally Django runs the [`ready()`](#django.apps.AppConfig.ready) method of each application
   configuration.

### Fabhtcheartú

Seo roinnt fadhbanna coitianta a d'fhéadfadh teacht ort le linn tionscnaimh:

- [`AppRegistryNotReady`](/ga/6.0/ref/exceptions/#django.core.exceptions.AppRegistryNotReady): This happens when
  importing an application configuration or a models module triggers code that
  depends on the app registry.

  For example, [`gettext()`](/ga/6.0/ref/utils/#django.utils.translation.gettext) uses the app
  registry to look up translation catalogs in applications. To translate at
  import time, you need [`gettext_lazy()`](/ga/6.0/ref/utils/#django.utils.translation.gettext_lazy)
  instead. (Using [`gettext()`](/ga/6.0/ref/utils/#django.utils.translation.gettext) would be a bug,
  because the translation would happen at import time, rather than at each
  request depending on the active language.)

  Spreagfaidh an eisceacht seo freisin fiosrúcháin bunachar sonraí a fhorghníomhú leis an ORM ag am allmhairithe i modúil Ní féidir leis an ORM feidhmiú i gceart go dtí go mbeidh gach samhail ar fáil.

  This exception also happens if you forget to call [`django.setup()`](#django.setup) in
  a standalone Python script.
- ImportError: ní féidir ainm a allmhairiú... Tarlaíonn sé seo má chríochnaíonn an seicheamh allmhairithe i lúb.

  Chun deireadh a chur le fadhbanna den sórt sin, ba cheart duit spleáchais idir do mhodúil samhlacha a íoslaghdú agus an oibre is lú agus is féidir a dhéanamh ag am Chun an cód a fhorghníomhú ag am allmhairithe a sheachaint, is féidir leat é a bhogadh isteach i bhfeidhm agus a thorthaí a Cuirfear an cód i bhfeidhm nuair a theastaíonn a thorthaí uait ar dtús. Tugtar “meastóireacht leisciúil” ar an gcoincheap seo.
- Déanann `django.contrib.admin` uathoibríoch modúil ````admin ``in iarratais suiteáilte. Chun é a chosc, athraigh do th:setting: `INSTALLED_APPS` chun go mbeidh ```django.contrib.admin.apps.simpleAdminConfig'```` in ionad `'django.contrib.admin'`.
- RuntimeWarning: Tá sé díspreagtha ar rochtain a fháil ar an mbunachar sonraí le linn tionscnaíodh aipeanna. Cuirtear an rabhadh seo a spreagadh le haghaidh ceisteanna bunachar sonraí a fhorghníomhú sula mbeidh aipeanna réidh, mar shampla le linn allmhairí modúl nó sa modh: AppConfig.ready. Cuirtear díspreagadh ar cheisteanna bunachar sonraí roimh am den sórt sin toisc go rithfidh siad le linn tosú gach ordaithe bainistíochta, rud a mhoilliú ar thosú do thionscadail, a d'fhéadfadh sonraí seasta a thaisceadh, agus a d'fhéadfadh go dteipeann fiú má

  Mar shampla, botún coitianta ná ceist bunachar sonraí a dhéanamh chun roghanna réimse foirme a líonadh:

  ```
  class LocationForm(forms.Form):
      country = forms.ChoiceField(choices=[c.name for c in Country.objects.all()])
  ```

  Sa sampla thuas, déantar an cheist ó Country.Objects.all () \`\`a fhorghníomhú le linn allmhairiú modúl, toisc go ndéantar an \`QuerySet a athrá. Chun an rabhadh a sheachaint, d'fhéadfadh an fhoirm a:class: ~django.forms.ModelChoiceField a úsáid ina ionad:

  ```
  class LocationForm(forms.Form):
      country = forms.ModelChoiceField(queryset=Country.objects.all())
  ```

  Chun é a dhéanamh níos éasca an cód a spreag an rabhadh seo a aimsiú, is féidir leat Python: ref: rabhaidh a chóireáil mar earráidí \<python:warning-filter\>\`chun an rian cruach a nochtadh, mar shampla le \`\`python -Werror manage.py shell\`.