---
title: "Μια πρώτη ματιά στο Django"
version: 6.1
locale: el
source: https://docs.djangoproject.com/el/6.1/intro/overview/
canonical: https://djangodocs.dev/el/6.1/intro/overview/
---
# Μια πρώτη ματιά στο Django

Because Django was developed in a fast-paced newsroom environment, it was
designed to make common web development tasks fast and easy. Here’s an informal
overview of how to write a database-driven web app with Django.

Ο στόχος αυτού το άρθρου είναι να σας δώσει μερικά τεχνικά στοιχεία (γνώσεις, αν θέλετε) προκειμένου να καταλάβετε πως λειτουργεί το Django. Δεν αποτελεί, ωστόσο, κάποιον οδηγό ή αναφορά για να ανατρέξετε (παρόλο που τα έχουμε και τα δύο)! Όταν είστε έτοιμοι για να ξεκινήσετε κάποιο project, μπορείτε να [ξεκινήσετε με τον οδηγό (tutorial)](/el/6.1/intro/tutorial01/) ή να ανατρέξετε σε πιο λεπτομερείς κείμενα [όπως το εγχειρίδιο (documentation) του Django](/el/6.1/topics/).

## Σχεδιάστε το μοντέλο σας

Το Django μπορείτε να το χρησιμοποιήσετε χωρίς τη χρήση κάποιας βάσης δεδομένων (στατικές σελίδες). Από την άλλη, για τη δημιουργία δυναμικών σελίδων, το Django σας δίνει τη δυνατότητα να σχεδιάσετε τη διάταξη της βάσης δεδομένων (database layout) σε κώδικα γραμμένο αποκλειστικά σε Python, με τη χρήση του [object-relational mapper](https://en.wikipedia.org/wiki/Object-relational_mapping) το οποίο είναι προεγκατεστημένο.

Το άρθρο [σχεδίαση μοντέλων](/el/6.1/topics/db/models/) προσφέρει πολλούς τρόπους σχεδίασης και αναπαράστασης των μοντέλων σας – μέχρι τώρα, έχει λύσει πολλών χρόνων προβλήματα που έχουν να κάνουν με τη σχεδίαση του schema της βάσης δεδομένων. Να ένα γρήγορο παράδειγμα:

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

## Εγκαταστήστε το

Next, run the Django command-line utilities to create the database tables
automatically:

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

*Windows*

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

The [`makemigrations`](/el/6.1/ref/django-admin/#django-admin-makemigrations) command looks at all your available models and
creates migrations for whichever tables don’t already exist. [`migrate`](/el/6.1/ref/django-admin/#django-admin-migrate)
runs the migrations and creates tables in your database, as well as optionally
providing [much richer schema control](/el/6.1/topics/migrations/).

## Απολαύστε το δωρεάν API

Με αυτά, έχετε ένα δωρεάν και πλούσιο [Python API](/el/6.1/topics/db/queries/)
για να αποκτήσετε πρόσβαση στα δεδομένα σας (που βρίσκονται μέσα στους πίνακες). Το API δημιουργείται “επί ποδός” (on the fly), δεν απαιτείται κώδικας για να το δημιουργήσει:

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

## Ένα δυναμικό διαχειριστικό περιβάλλον: δεν είναι απλά οικοδομή – είναι ολόκληρο το σπίτι

Once your models are defined, Django can automatically create a professional,
production ready [administrative interface](/el/6.1/ref/contrib/admin/) –
a website that lets authenticated users add, change and delete objects. The
only step required is to register your model in the admin site:

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

The philosophy here is that your site is edited by a staff, or a client, or
maybe just you – and you don’t want to have to deal with creating backend
interfaces only to manage content.

Ένας τυπικός μπούσουλας στη σχεδίαση Django apps είναι να δημιουργείτε μοντέλα και αμέσως μετά να τα καταχωρείτε (register) με το admin site ούτως ώστε να μπορείτε να τα διαχειρίζεστε όσο γίνεται πιο γρήγορα. Έτσι, το προσωπικό σας (ή οι πελάτες σας) θα μπορούν να καταχωρούν δεδομένα (περιεχόμενο) και να αναπτύξουν το τρόπο με το οποίο θα τα παρουσιάσουν στο ευρύ κοινό.

## Σχεδίαση των URLs

A clean, elegant URL scheme is an important detail in a high-quality web
application. Django encourages beautiful URL design and doesn’t put any cruft
in URLs, like `.php` or `.asp`.

To design URLs for an app, you create a Python module called a [URLconf](/el/6.1/topics/http/urls/). A table of contents for your app, it contains a mapping
between URL patterns and Python callback functions. URLconfs also serve to
decouple URLs from Python code.

Ένα URLconf module θα έδειχνε κάπως έτσι, αναφορικά με το παράδειγμα `Reporter`/`Article` πιο πάνω:

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

The code above maps URL paths to Python callback functions («views»). The path
strings use parameter tags to «capture» values from the URLs. When a user
requests a page, Django runs through each path, in order, and stops at the
first one that matches the requested URL. (If none of them matches, Django
calls a special-case 404 view.) This is blazingly fast, because the paths are
compiled into regular expressions at load time.

Once one of the URL patterns matches, Django calls the given view, which is a
Python function. Each view gets passed a request object – which contains
request metadata – and the values captured in the pattern.

For example, if a user requested the URL «/articles/2005/05/39323/», Django
would call the function `news.views.article_detail(request,
year=2005, month=5, pk=39323)`.

## Γράψτε τα views σας

Κάθε view είναι υπεύθυνο να κάνει ένα από δύο πράγματα: Θα επιστρέφει ένα [`HttpResponse`](/el/6.1/ref/request-response/#django.http.HttpResponse) object το οποίο θα περιέχει τα δεδομένα της ζητούμενης σελίδας ή θα κάνει raise κάποιο exception όπως το [`Http404`](/el/6.1/topics/http/views/#django.http.Http404). Τα υπόλοιπα άπτονται σε εσάς.

Γενικά, ένα view ανακτά τα δεδομένα ανάλογα τις παραμέτρους, φορτώνει το template και κάνει render το template με τα δεδομένα που ανέκτησε. Αναφερόμενοι στο παραπάνω παράδειγμα και πιο συγκεκριμένα στο πρώτο URL regex, θα υλοποιήσουμε το `year_archive` view:

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

Αυτό το παράδειγμα χρησιμοποιεί το [template system](/el/6.1/topics/templates/) του Django, το οποίο παρέχει πολλά ισχυρά χαρακτηριστικά και παράλληλα προσπαθεί να παραμείνει απλό στη χρήση του για αυτούς που δεν είναι προγραμματιστές.

## Σχεδιάστε τα templates σας

Ο κώδικας παραπάνω φορτώνει το template με το όνομα `news/year_archive.html`.

Το Django έχει ειδική μηχανή αναζήτησης template, η οποία επιτρέπει στην ελαχιστοποίηση της επαναληπτικότητας (redundancy) ανάμεσα στα templates. Στις ρυθμίσεις (settings) του Django, καθορίζετε μία λίστα από φακέλους (directories) στους οποίους θα κοιτάξει το Django να βρει το αντίστοιχο template αρχείο. Η ρύθμιση αυτή γίνεται μέσω του [`DIRS`](/el/6.1/ref/settings/#std-setting-TEMPLATES-DIRS). Αν ένα template δεν βρεθεί στον πρώτο φάκελο τότε εξερευνάται ο δεύτερος κοκ.

Ας υποθέσουμε ότι το template `news/year_archive.html` βρέθηκε. Αυτό θα μοιάζει κάπως έτσι:

*`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 %}
```

Οι μεταβλητές περιβάλλονται από διπλές αγκύλες. Το `{{ article.headline }}`
σημαίνει «Δώσε μου την τιμή του headline attribute του object article». Αλλά οι τελείες δεν χρησιμοποιούνται μόνο για να ανακαλούμε τα attributes ενός object. Χρησιμεύουν επίσης και για να ψάχνουμε μέσα σε Python dictionaries, μέσα σε Python λίστες (lists) καθώς και για να καλούμε μεθόδους ενός object.

Σημειώστε ότι το `{{ article.pub_date|date:"F j, Y" }}` χρησιμοποιεί ένα στυλ του Unix που λέγεται «pipe» (ο χαρακτήρας «|»). Αυτό ονομάζεται template filter και είναι ένας τρόπος να φιλτράρουμε την τιμή ή την μεταβλητή. Στην συγκεκριμένη περίπτωση, το φίλτρο με το όνομα “date” φιλτράρει το Python datetime object ούτως ώστε να παρουσιαστεί σε μία συγκεκριμένη μορφή (σύμφωνα με την συνάρτηση date της γλώσσας PHP).

Μπορείτε να συνδέσετε (chain) περισσότερα από ένα φίλτρα, ανάλογα τις απαιτήσεις σας. Μπορείτε να γράψετε [δικά σας template filters](/el/6.1/howto/custom-template-tags/#howto-writing-custom-template-filters). Μπορείτε να γράψετε [δικά σας template tags](/el/6.1/howto/custom-template-tags/), τα οποία θα τρέχουν το δικό σας Python κώδικα στο παρασκήνιο.

Εν κατακλείδι, το Django χρησιμοποιεί την έννοια του «template inheritance». Αν προσέξατε, στην αρχή του template υπάρχει το `{% extends "base.html" %}`. Αυτό σημαίνει «πρώτα φόρτωσε το template με το όνομα “base.html”, το οποίο “base” έχει ορίσει κάποια τμήματα blocks (όπως είναι το title και το content) και αντικατέστησε τα κομμάτια αυτά του “base.html” με αυτά του year\_archive.html». Με άλλα λόγια, το Django template system ελαχιστοποιεί στο έπακρο την επαναληπτικότητα ανάμεσα στα template σας: κάθε template θα πρέπει να ορίζει μόνο ότι είναι μοναδικό στο δικό του template.

Δείτε και το «base.html» template, συμπεριλαμβανομένου και του [static files](/el/6.1/howto/static-files/) template tag:

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

Simplistically, it defines the look-and-feel of the site (with the site’s
logo), and provides «holes» for child templates to fill. This means that a site
redesign can be done by changing a single file – the base template.

It also lets you create multiple versions of a site, with different base
templates, while reusing child templates. Django’s creators have used this
technique to create strikingly different mobile versions of sites by only
creating a new base template.

Σημειώστε επίσης ότι δεν χρειάζεται να χρησιμοποιήσετε το template system του Django αν δεν σας ταιριάζει. Ενώ δουλεύει και επικοινωνεί εξαιρετικά με το model layer του Django, μπορείτε να χρησιμοποιήσετε κάποιο άλλο template system. Με την ίδια λογική μπορείτε να αλλάξετε και το API για την επικοινωνία με την βάση δεδομένων. Μπορείτε να δουλέψετε με άλλο abstraction layer βάσης δεδομένων, να διαβάζετε XML αρχεία, να διαβάζετε αρχεία εκτός δίσκου ή οτιδήποτε θέλετε. Κάθε κομμάτι του Django – models, views, templates – είναι αποσυνδεδεμένο με το επόμενο.

## Και αυτό είναι μόνο η επιφάνεια

Αυτό το άρθρο ήταν μόνο μια γρήγορη προεπισκόπηση των δυνατοτήτων και λειτουργιών του Django. Μερικά πιο χρήσιμα χαρακτηριστικά είναι:

- Το [caching framework](/el/6.1/topics/cache/) το οποίο ενσωματώνεται με το memcached ή άλλα backends.
- A [syndication framework](/el/6.1/ref/contrib/syndication/) that lets you
  create RSS and Atom feeds by writing a small Python class.
- More attractive automatically-generated admin features – this overview
  barely scratched the surface.

The next steps are for you to [download Django](https://www.djangoproject.com/download/), read [the tutorial](/el/6.1/intro/tutorial01/) and join [the community](https://www.djangoproject.com/community/). Thanks for your interest!