---
title: "Sracfhéachaint ar Django"
version: 6.0
locale: ga
source: https://docs.djangoproject.com/ga/6.0/intro/overview/
canonical: https://djangodocs.dev/ga/6.0/intro/overview/
---
# Sracfhéachaint ar Django

Toisc gur forbraíodh Django i dtimpeallacht seomra nuachta luas tapa, ceapadh é chun tascanna forbartha gréasáin coitianta a dhéanamh go tapa agus éasca. Seo forbhreathnú neamhfhoirmiúil ar conas aip gréasáin bunaithe ar bhunachar sonraí a scríobh le Django.

Is é sprioc an doiciméid seo go leor sonraí teicniúla a thabhairt duit chun tuiscint a fháil ar an gcaoi a n-oibríonn Django, ach níl sé i gceist gur teagasc nó tagairt a bheadh ​​​​ann -- ach tá an dá cheann againn! Nuair atá tú réidh le tionscadal a thosú, is féidir leat [tosú leis an rang teagaisc](/ga/6.0/intro/tutorial01/) nó :doc: tumadh díreach isteach i gcáipéisíocht níos mionsonraithe \</topics/index\>.

## Dear do mhúnla

Cé gur féidir leat Django a úsáid gan bunachar sonraí, tagann sé le [object-relational mapper](https://en.wikipedia.org/wiki/Object-relational_mapping) ina ndéanann tú cur síos ar leagan amach do bhunachar sonraí i gcód Python.

The [data-model syntax](/ga/6.0/topics/db/models/) offers many rich ways of
representing your models -- so far, it's been solving many years' worth of
database-schema problems. Here's a quick example:

*`news/models.py`*

```python
from django.db import models

class Reporter(models.Model):
    full_name = models.CharField(max_length=70)

    def __str__(self):
        return self.full_name

class Article(models.Model):
    pub_date = models.DateField()
    headline = models.CharField(max_length=200)
    content = models.TextField()
    reporter = models.ForeignKey(Reporter, on_delete=models.CASCADE)

    def __str__(self):
        return self.headline
```

## Suiteáil é

Ansin, reáchtáil na fóntais ordú-líne Django a chruthú ar na táblaí bunachar sonraí go huathoibríoch:

```console
$ python manage.py makemigrations
$ python manage.py migrate
```

*Windows*

```doscon
...\> py manage.py makemigrations
...\> py manage.py migrate
```

Breathnaíonn an t-ordú :d jadmin: makemigrations ar do chuid samhlacha go léir atá ar fáil agus cruthaíonn sé imirce do cibé táblaí nach bhfuil ann cheana féin. :d JADMIN: Ritheann 'imirce' na himirce agus cruthaíonn sé táblaí i do bhunachar sonraí, chomh maith le :d OC: Rialú scéimre i bhfad níos saibhre \</topics/migrations\>Migrations a sholáthar go roghnach .

## Bain sult as an API saor in aisce

Leis sin, tá tú saor in aisce, agus saibhir, :d oc:Python API \</topics/db/queries\> chun rochtain a fháil ar do shonraí. Cruthaítear an API ar an eitilt, gan aon ghiniúint cód riachtanach:

```pycon
# Import the models we created from our "news" app
>>> from news.models import Article, Reporter

# No reporters are in the system yet.
>>> Reporter.objects.all()
<QuerySet []>

# Create a new Reporter.
>>> r = Reporter(full_name="John Smith")

# Save the object into the database. You have to call save() explicitly.
>>> r.save()

# Now it has an ID.
>>> r.id
1

# Now the new reporter is in the database.
>>> Reporter.objects.all()
<QuerySet [<Reporter: John Smith>]>

# Fields are represented as attributes on the Python object.
>>> r.full_name
'John Smith'

# Django provides a rich database lookup API.
>>> Reporter.objects.get(id=1)
<Reporter: John Smith>
>>> Reporter.objects.get(full_name__startswith="John")
<Reporter: John Smith>
>>> Reporter.objects.get(full_name__contains="mith")
<Reporter: John Smith>
>>> Reporter.objects.get(id=2)
Traceback (most recent call last):
    ...
DoesNotExist: Reporter matching query does not exist.

# Create an article.
>>> from datetime import date
>>> a = Article(
...     pub_date=date.today(), headline="Django is cool", content="Yeah.", reporter=r
... )
>>> a.save()

# Now the article is in the database.
>>> Article.objects.all()
<QuerySet [<Article: Django is cool>]>

# Article objects get API access to related Reporter objects.
>>> r = a.reporter
>>> r.full_name
'John Smith'

# And vice versa: Reporter objects get API access to Article objects.
>>> r.article_set.all()
<QuerySet [<Article: Django is cool>]>

# The API follows relationships as far as you need, performing efficient
# JOINs for you behind the scenes.
# This finds all articles by a reporter whose name starts with "John".
>>> Article.objects.filter(reporter__full_name__startswith="John")
<QuerySet [<Article: Django is cool>]>

# Change an object by altering its attributes and calling save().
>>> r.full_name = "Billy Goat"
>>> r.save()

# Delete an object with delete().
>>> r.delete()
```

## Comhéadan dinimiciúil riaracháin: níl sé ach scafall - is é an teach ar fad é

Nuair a shainmhínítear do mhúnlaí, is féidir le Django a chruthú go huathoibríoch gairmiúil, táirgeadh réidh :d oc: comhéadan riaracháin \</ref/contrib/admin/index\> \- suíomh gréasáin a ligeann d'úsáideoirí fíordheimhnithe rudaí a chur leis, a athrú agus a scriosadh. Is é an t-aon chéim atá ag teastáil ná do mhúnla a chlárú ar an suíomh riaracháin:

*`news/models.py`*

```python
from django.db import models

class Article(models.Model):
    pub_date = models.DateField()
    headline = models.CharField(max_length=200)
    content = models.TextField()
    reporter = models.ForeignKey(Reporter, on_delete=models.CASCADE)
```

*`news/admin.py`*

```python
from django.contrib import admin

from . import models

admin.site.register(models.Article)
```

Is é an fhealsúnacht anseo go bhfuil do shuíomh curtha in eagar ag foireann, nó cliant, nó b'fhéidir díreach tú - agus níl tú ag iarraidh déileáil le comhéadain inneall a chruthú ach amháin chun ábhar a bhainistiú.

Sreabhadh oibre tipiciúil amháin chun apps Django a chruthú ná samhlacha a chruthú agus na suíomhanna riaracháin a chur ar bun chomh tapa agus is féidir, ionas gur féidir le d'fhoireann (nó do chliaint) tús a chur le sonraí daonra. Ansin, forbairt a dhéanamh ar an mbealach a chuirtear sonraí i láthair an phobail.

## Dear do URLanna

Is mionsonra tábhachtach é scéim URL glan galánta i bhfeidhmchlár gréasáin ardchaighdeáin. Spreagann Django dearadh URL álainn agus ní chuireann sé aon chrústa in URLanna, cosúil le `.php` nó `.asp`.

Chun URLanna a dhearadh le haghaidh aip, cruthaíonn tú modúl Python ar a dtugtar [URLconf](/ga/6.0/topics/http/urls/). Clár ábhar do d’aip, tá mapáil ann idir patrúin URL agus feidhmeanna aisghlaoite Python. Freastalaíonn URLconfs freisin chun URLanna a dhíchúpláil ó chód Python.

Seo an chuma a bheadh ​​ar URLconf don sampla `Tuairisceoir`/`Airteagal` thuas:

*`news/urls.py`*

```python
from django.urls import path

from . import views

urlpatterns = [
    path("articles/<int:year>/", views.year_archive),
    path("articles/<int:year>/<int:month>/", views.month_archive),
    path("articles/<int:year>/<int:month>/<int:pk>/", views.article_detail),
]
```

Léarscáilíonn an cód thuas cosáin URL chuig feidhmeanna aisghlao Python ("amhairc"). Úsáideann teaghráin na gcosán clibeanna paraiméadar chun luachanna a "ghabháil" ó na URLanna. Nuair a iarrann úsáideoir leathanach, ritheann Django trí gach cosán, in ord, agus stopann sé ag an gcéad cheann a mheaitseálann an URL iarrtha. (Mura n-oireann aon cheann acu, glaonn Django radharc cás speisialta 404.) Tá sé seo blazingly tapa, toisc go bhfuil na cosáin le chéile i nathanna rialta ag am ualach.

Nuair a mheaitseálann ceann de na patrúin URL, glaonn Django ar an radharc a thugtar, arb é feidhm Python é. Rachaidh gach radharc ar aghaidh réad iarratais -- ina bhfuil meiteashonraí iarratais -- agus na luachanna a gabhadh sa phatrún.

Mar shampla, dá n-iarrfadh úsáideoir an URL "/articles/2005/05/39323/", thabharfadh Django an fheidhm `news.views.article_detail(iarratas, year=2005, month=5, pk=39323)`.

## Scríobh do thuairimí

Tá gach amharc freagrach as ceann amháin de dhá rud a dhéanamh: Ag filleadh ar rud `Http404`. Fútsa atá an chuid eile.

Go ginearálta, aisghabhann radharc sonraí de réir na bparaiméadar, lódálann sé teimpléad agus cuireann sé an teimpléad leis na sonraí a aisghabháil. Seo radharc samplach do `year_archive` thuas:

*`news/views.py`*

```python
from django.shortcuts import render

from .models import Article

def year_archive(request, year):
    a_list = Article.objects.filter(pub_date__year=year)
    context = {"year": year, "article_list": a_list}
    return render(request, "news/year_archive.html", context)
```

Úsáideann an sampla seo [córas teimpléid Django](/ga/6.0/topics/templates/), a bhfuil roinnt gnéithe cumhachtacha aige ach a dhéanann iarracht fanacht simplí go leor le húsáid gan ríomhchláraitheoirí.

## Dear do teimpléid

Luchtaíonn an cód thuas an teimpléad `news/year_archive.html`.

Tá cosán cuardaigh teimpléad ag Django, a ligeann duit iomarcaíocht a íoslaghdú i measc teimpléid. I do shocruithe Django, sonraíonn tú liosta eolairí le seiceáil le haghaidh teimpléid le:setting:'DIRS\<TEMPLATES-DIRS\>'. Mura bhfuil teimpléad ann sa chéad eolaire, seiceálann sé an dara ceann, agus mar sin de.

Abraimis gur aimsíodh an teimpléad `news/year_archive.html`. Seo an chuma a d'fhéadfadh a bheith air sin:

*`news/templates/news/year_archive.html`*

```html+django
{% extends "base.html" %}

{% block title %}Articles for {{ year }}{% endblock %}

{% block content %}
<h1>Articles for {{ year }}</h1>

{% for article in article_list %}
    <p>{{ article.headline }}</p>
    <p>By {{ article.reporter.full_name }}</p>
    <p>Published {{ article.pub_date|date:"F j, Y" }}</p>
{% endfor %}
{% endblock %}
```

Tá athróga timpeallaithe ag braces dúbailte-curly. Ciallaíonn `{{ article.headline }}` "Aschur luach phríomhthréith an ailt." Ach ní úsáidtear poncanna ach amháin le haghaidh lookup tréith. Is féidir leo cuardach foclóra-eochair, cuardach innéacs agus glaonna feidhme a dhéanamh freisin.

Nóta `{{ article.pub_date|date:"F j, Y" }}` úsáideann "píopa" stíl Unix (an carachtar "|"). Tugtar scagaire teimpléid air seo, agus is bealach é chun luach athróg a scagadh. Sa chás seo, formáidí an scagaire dáta réad datetime Python san fhormáid a thugtar (mar atá le fáil i bhfeidhm dáta PHP).

Is féidir leat an oiread scagairí agus is mian leat a shlabhra le chéile. Is féidir leat scríobh: ref: 'custom template \<howto-writing-custom-template-filters\>filters'. Is féidir leat scríobh :d oc: 'custom template tags \</howto/custom-template-tags\>', a ritheann cód saincheaptha Python taobh thiar de na radhairc.

Ar deireadh, úsáideann Django coincheap "oidhreacht teimpléid". Sin a dhéanann an `{% extends "base.html" %}` . Ciallaíonn sé "An chéad luchtú an teimpléad ar a dtugtar 'bonn', a bhfuil sainithe a bunch de bloic, agus líon na bloic leis na bloic seo a leanas." I mbeagán focal, ligeann sé sin duit gearradh síos go mór ar iomarcaíocht i dteimpléid: ní mór do gach teimpléad ach an méid atá uathúil don teimpléad sin a shainiú.

Seo an méid a d'fhéadfadh an teimpléad "base.html", lena n-áirítear úsáid a bhaint as :d oc: 'comhaid statacha \< / howto / static-files / index\>, cuma mhaith:

*`templates/base.html`*

```html+django
{% load static %}
<html lang="en">
<head>
    <title>{% block title %}{% endblock %}</title>
</head>
<body>
    <img src="{% static 'images/sitelogo.png' %}" alt="Logo">
    {% block content %}{% endblock %}
</body>
</html>
```

Go simplí, sainmhíníonn sé cuma agus mothú an tsuímh (le lógó an tsuímh), agus soláthraíonn sé "poill" le haghaidh teimpléid leanaí a líonadh. Ciallaíonn sé seo gur féidir athdhearadh láithreáin a dhéanamh trí chomhad amháin a athrú - an teimpléad bonn.

Ligeann sé duit leaganacha éagsúla de shuíomh a chruthú freisin, le teimpléid bhunúsacha éagsúla, agus teimpléid leanaí á n-athúsáid. D'úsáid cruthaitheoirí Django an teicníc seo chun leaganacha soghluaiste éagsúla de shuíomhanna a chruthú trí theimpléad bonn nua a chruthú.

Note that you don't have to use Django's template system if you prefer another
system. While Django's template system is particularly well-integrated with
Django's model layer, nothing forces you to use it. For that matter, you don't
have to use Django's database API, either. You can use another database
abstraction layer, you can read XML files, you can read files off disk, or
anything you want. Each piece of Django -- models, views, templates -- is
decoupled from the next.

## Níl anseo ach an dromchla

Ní raibh anseo ach forbhreathnú tapa ar fheidhmiúlacht Django. Roinnt gnéithe níos úsáidí:

- A :d oc:caching framework \</topics/cache\> a chomhtháthaíonn le memcached nó le cúil eile.
- A :d oc:syndication framework \</ref/contrib/syndication\> a ligeann duit fothaí RSS agus Adamh a chruthú trí rang beag Python a scríobh.
- Gnéithe riaracháin níos tarraingtí a ghintear go huathoibríoch - is ar éigean a scríob an forbhreathnú seo an dromchla.

Is iad na chéad chéimeanna eile ná [íoslódáil Django](https://www.djangoproject.com/download/), léigh :d oc:the tutorial \</intro/tutorial01\> agus páirt a ghlacadh i [the community](https://www.djangoproject.com/community/). Go raibh maith agat as do spéis!