Python Web çerçeveleri, Bölüm 1: Django ve Python ile Web için Geliştirme Yapın

Kuruluş aşamasından tamamlanmış bir Web sitesine kadar Python Django Web çerçevesi

Düzey: Orta

Ian Maurer (ian@itmaurer.com), Üst Düzey Danışman, Brulant, Inc.

6 Haziran 2006

İki bölümlük dizinin bu ilk makalesinde, gücünü Python programlama dilinden alan, açık kaynak model-görünüm-denetleyici (MVC; model-view-controller) biçimindeki Web uygulaması çerçevesi Django'yu tanıtacağız. Django ile, yüksek nitelikli, bakımı kolay, veritabanına dayalı Web uygulamalarını birkaç dakika içinde yaratabilirsiniz.

Django projesi, çevrimiçi bir gazete Web sitesiyle ortaya çıkmış ve ve Temmuz 2005'te açık kaynak olarak yayınlanmıştı. Django çerçevesinin temel bileşenleri şunlardır:

• Modellerin yaratılması için nesne ile ilişkisel eşleme
• Son kullanıcılar için tasarlanmış hoş görünümlü yönetici arabirimi
• Zarif URL tasarımı
• Tasarımı kolay şablon dili
• Önbelleğe alma sistemi

Bu makale, Python Web çerçeveleri konusundaki iki bölümlük dizinin ilkidir. İkinci makalede size TurboGears çerçevesi tanıtılacaktır.

Bu makalede anlatılan kodu kullanmak ve anlamak için, Python'un bilgisayarınızda kurulu olması ve bunun nasıl kullanılacağına ilişkin başlangıç düzeyinde bilgi sahibi olmanız gerekir. python -V yazarak bilgisayarınızda Python'un kurulu olup olmadığını ve hangi sürümün kurulu olduğunu kontrol edin. Django için gereken minimum sürüm 2.3.5'tir; bu sürümü Python Web sitesinden sağlayabilirsiniz (ilgili bağlantı için, bu makalenin devamında yer alan Kaynaklar bölümüne bakın). Tüm bunların yanı sıra, MVC mimarisini de en azından biraz olsun tanıyor olmanız gerekir.

Django'nun Kurulması

Bu makalede, Django çerçevesinde yapılan en son geliştirmelerden yararlanmak için Django'nun geliştirme sürümü kullanılmaktadır. Ben, 0.95 sürümüne kadar bu sürümü kullanmanızı öneririm. En son yayına ulaşmak için Django Web sitesini denetleyin (bağlantı için bkz. Kaynaklar).

Django'yu aşağıda anlatıldığı gibi bilgisayarınıza yükleyin ve kurun:

~/downloads# svn co http://code.djangoproject.com/svn/django/trunk/ django_src
~/downloads# cd django_src
~/downloads# python setup.py install

Django admin (yönetici) aracı

Django'yu kurduktan sonra, yolunuz üzerinde django-admin.py admin (yönetici) aracınızın bulunması gerekir. Liste 2'de admin aracında kullanılabilen komutlardan bazıları gösterilmiştir:

~/dev$ django-admin.py
usage: django-admin.py action [options]
actions:
  adminindex [modelmodule ...]
    Prints the admin-index template snippet for the given model
    module name(s).

  ... snip ...

  startapp [appname]
    Creates a Django app directory structure for the given app name
    in the current directory.

  startproject [projectname]
    Creates a Django project directory structure for the given
    project name in the current directory.

  validate
    Validates all installed models.

options:
  -h, --help		show this help message and exit
  --settings=SETTINGS	Python path to settings module, e.g.
			"myproject.settings.main". If this isn't
			provided, the DJANGO_SETTINGS_MODULE
			environment variable will be used.
  --pythonpath=PYTHONPATH
			Lets you manually add a directory the Python
			path, e.g. "/home/djangoprojects/myproject".

Django projeleri ve uygulamaları

Bir Django projesini başlatmak için, aşağıda anlatıldığı gibi django-admin startproject komutunu kullanın:

~/dev$ django-admin.py startproject djproject

Yukarıdaki komut, bir Django projesini çalıştırmak için gereken temel yapılandırma dosyalarını içeren "djproject" adlı dizini yaratır:

__init__.py
manage.py
settings.py
urls.py

Bu proje için, "jobs" (işler) adı verilen bir "job-board" (iş panosu) uygulaması oluşturacaksınız. Bir uygulama yaratmak için, settings.py dosyasının otomatik olarak sağlandığı ve projeye özgü bir django-admin.py komut dosyası olan manage.py komut dosyasını kullanın:

~/dev$ cd djproject
~/dev/djproject$ python manage.py startapp jobs

Bu komut, modelleriniz için bir Python modülü ve görünümleriniz için bir Python modülü olan temel bir uygulama bir yaratır. "jobs" dizini aşağıdaki dosyaları içerecektir:

__init__.py
models.py
views.py

Uygulamanın proje içindeki yeri, yalnızca yeni Django geliştiricileri için yaratılan bir kural olup, bir gereksinim değildir. Çeşitli projeler üzerinde uygulamaları birbirleriyle farklı kombinasyonlarda eşleştirmeye başladığınızda, uygulamaları kendi modül adı alanlarına yerleştirebilir ve ayarları ve ana URL dosyalarını kullanarak bunları birbirine bağlayabilirsiniz. Şimdilik ilgili adımları aşağıda gösterildiği gibi uygulayın.

Django'nun yeni bir uygulamadan haberdar olması için, settings.py dosyasında INSTALLED_APPS alanına bir giriş eklemeniz gerekir. Bu "job board" uygulaması için, djproject.jobs dizisi eklenmelidir:

INSTALLED_APPS = (
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.sites',
    'djproject.jobs',
)

Bir model yaratılması

Django, bir Python nesne arabirimi yoluyla dinamik veritabanı arabirimi erişimini destekleyen kendi nesne ile ilişkisel eşleyici (ORM; object-relational mapper) kitaplığıyla birlikte sağlanır. Python arabirimi çok kullanışlı ve güçlüdür, ancak gerekirse SQL'i de doğrudan kullanmakta serbestsiniz.

ORM şu anda PostgreSQL, MySQL, SQLite ve Microsoft® SQL veritabanları için destek sağlar.

Bu örnekte veritabanı arka ucu olarak SQLite kullanılmıştır. SQLite, hiçbir yapılandırma gerektirmeyen ve diskte basit bir dosya olarak yer alan basit bir veritabanıdır. SQLite'ı kullanmak için, ayar araçlarını kullanarak yalnızca pysqlite kitaplığını kurun (kuruluş araçları ve özellikle de ayrı kurmanız gereken easy_install (kolay kuruluş) aracı hakkında daha fazla bilgi için, bkz. Kaynaklar):

easy_install pysqlite

Model üzerinde çalışmaya başlamadan önce, ayarlar dosyasındaki veritabanını yapılandırın. SQLite, yalnızca veritabanı motorunun ve adının belirtilmesini gerektirir.

DATABASE_ENGINE = 'sqlite3'
DATABASE_NAME = '/path/to/dev/djproject/database.db'
DATABASE_USER = ''
DATABASE_PASSWORD = ''
DATABASE_HOST = ''
DATABASE_PORT = ''

Bu "job board" uygulamasının, Locations (Yerler) ve Jobs (İşler) olmak üzere iki tip nesnesi olacaktır. Bir Location nesnesi, yalnızca şehir, bölge (isteğe bağlı) ve ülke alanlarını içerir. Bir "Job" nesnesi de bir yer, unvan tanımı ve yayınlanma tarihi içerir.

from django.db import models

class Location(models.Model):
    city = models.CharField(maxlength=50)
    state = models.CharField(maxlength=50, null=True, blank=True)
    country = models.CharField(maxlength=50)

    def __str__(self):
        if self.state:
            return "%s, %s, %s" % (self.city, self.state, self.country)
        else:
            return "%s, %s" % (self.city, self.country)

class Job(models.Model):
    pub_date = models.DateField()
    job_title = models.CharField(maxlength=50)
    job_description = models.TextField()
    location = models.ForeignKey(Location)

    def __str__(self):
        return "%s (%s)" % (self.job_title, self.location)

__str__ yöntemi, bir nesnenin dize gösterimini döndüren Python ürününün içerdiği özel bir sınıf yöntemidir. Django Admin aracında nesneleri görüntülerken bu yöntemi yaygın olarak kullanır.

Modele ilişkin veritabanı şemasını görmek için manage.py'nin sql komutunu çalıştırın. Şema henüz canlandırılmayacaktır (enact).

~/dev/djproject$ python manage.py sql jobs

BEGIN;
CREATE TABLE "jobs_job" (
    "id" integer NOT NULL PRIMARY KEY,
    "pub_date" date NOT NULL,
    "job_title" varchar(50) NOT NULL,
    "job_description" text NOT NULL,
    "location_id" integer NOT NULL
);
CREATE TABLE "jobs_location" (
    "id" integer NOT NULL PRIMARY KEY,
    "city" varchar(50) NOT NULL,
    "state" varchar(50) NULL,
    "country" varchar(50) NOT NULL
);
COMMIT;

Modeli başlatmak ve kurmak için, syncdb veritabanını eşitle komutunu çalıştırın:

~/dev/djproject$ python manage.py syncdb

syncdb komutunun sizden bir süper kullanıcı hesabı yaratmanızı istediğine dikkat edin. Bunun nedeni, temel kullanıcı doğrulaması işlevini sağlayan django.contrib.auth uygulamasının, INSTALLED_APPS ayarlarınızda varsayılan değer olarak sağlanmasıdır. Süper kullanıcı adı ve parolası, bir sonraki bölümde açıklanan admin aracında oturum açmak için kullanılacaktır. Bunun, sisteminizin süper kullanıcısı değil, Django süper kullanıcısı olduğu unutmayın.

Sorgu dizileri

Django modelleri, objects olarak adlandırılan, varsayılan Manager sınıfı yoluyla veritabanına erişir. Örneğin, tüm işlerin (job) bir listesini yazdırmak için, objects manager'in all yöntemini kullanırsınız:

>>> from jobs.models import Job
>>> for job in Job.objects.all():
...     print job

Manager sınıfının ayrıca filter ve exclude olarak adlandırılan süzme yöntemleri de bulunur. Süzme (filter) yönteminde bir koşulu karşılayan tüm nesneler sağlanırken, dışla (exclude) yönteminde bir koşulu karşılamayan tüm nesneler verilir. Aşağıdaki sorguların aynı sonuçları vermesi gerekir ("gte", "büyük ya da eşit" ve "lt" de "daha küçük" anlamına gelir).

>>> from jobs.models import Job
>>> from datetime import datetime
>>> q1 = Job.objects.filter(pub_date__gte=datetime(2006, 1, 1))
>>> q2 = Job.objects.exclude(pub_date__lt=datetime(2006, 1, 1))

filter (süz) ve exclude (dışla) yöntemleri, birbirlerine zincirleme olarak bağlanabilen ve hatta birleştirmeler gerçekleştirebilen QuerySet nesnelerini döndürür. Aşağıdaki q4 sorgusu, Cleveland Ohio'da 1 Ocak 2006 tarihinden bugüne kadar gönderilen işleri bulacaktır:

>>> from jobs.models import Job
>>> from datetime import datetime
>>> q3 = Job.objects.filter(pub_date__gte=datetime(2006, 1, 1))
>>> q4 = q3.filter(location__city__exact="Cleveland",
...                location__state__exact="Ohio")

QuerySets sorgu dizilerinin tembel olması oldukça yararlı bir özelliktir. Bunun anlamı, değerlendirilinceye kadar bunların veritabanında yürütme yapmamasıdır ve böylece anında gerçekleştirilebilen sorgulardan çok daha hızlı çalışır.

Bu tembellik, Python'un slicing (dilimleme) işleviyle çok kullanışlıdır. Tüm kayıtları isteyip bunların arasından gerekenleri ayırmak yerine, gerçek SQL sorgusunda aşağıdaki kod 5'lik bir OFFSET ve 10'luk bir LIMIT kullanarak performansı büyük ölçüde artırır.

>>> from jobs.models import Job
>>> for job in Job.objects.all()[5:15]
...     print job

Not: Bir QuerySet'te kaç adet kayıt olduğunu öğrenmek için count yöntemini kullanın. Python len yöntemi, tam bir değerlendirme yapar ve sonra kayıt olarak döndürülen satırları sayar; count yöntemi ise çok daha hızlı olan gerçek bir SQL COUNT (SQL Sayımı) gerçekleştirir. Sistem yönteciniz bunun için size teşekkür edecektir.

>>> from jobs.models import Job
>>> print "Count = ", Job.objects.count()       # GOOD!
>>> print "Count = ", len(Job.objects.all())    # BAD!

Ek bilgi için, bkz. Kaynaklar bölümündeki Django "Database API reference" bağlantısı.

Admin (Yönetici) aracı

Django'nun tercih edilmesinde en büyük rolü taşıyan özelliği, sahip olduğu hoş görünümlü yönetici arabirimidir. Bu araç, son kullanıcılar düşünülerek tasarlanmıştır. Bu araç projelerinize büyük bir veri girişi aracı sağlar.

Admin aracı, Django ile birlikte sağlanan bir uygulamadır. Kullanabilmeniz için bunun da jobs uygulaması gibi, önce kurulması gerekir. Bunun için ilk adım, uygulamanın modülünü (django.contrib.admin) INSTALLED_APPS ayarına eklemektir:

INSTALLED_APPS = (
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.sites',
    'djproject.jobs',
    'django.contrib.admin',
)

Admin aracının /admin URL'sinden kullanılmasını sağlamak için, yalnızca projenizin urls.py dosyasında sağlanan satırı devre dışı bırakın. Bir sonraki bölümde URL yapılandırması daha ayrıntılı biçimde açıklanacaktır.

from django.conf.urls.defaults import *

urlpatterns = patterns('',
    (r'^admin/', include('django.contrib.admin.urls.admin')),
)

Admin uygulamasının kendine ait bir veritabanı modeli vardır ve öncelikle kurulması gerekir. Bunu gerçekleştirmek için yeniden syncdb komutunu kullanın:

python manage.py syncdb

Admin aracını görüntülemek için, Django ile birlikte sağlanan test sunucusunu kullanabilirsiniz.

~/dev/djproject$ python manage.py runserver
Validating models...
0 errors found.

Django version 0.95 (post-magic-removal), using settings 'djproject.settings'
Development server is running at http://127.0.0.1:8000/
Quit the server with CONTROL-C (Unix) or CTRL-BREAK (Windows).

http://localhost:8000/admin adresine giderek Admin aracına erişebilir ve daha önce yaratmış olduğunuz süper kullanıcı hesabını kullanarak oturum açabilirsiniz. Modellerinizden hiçbirinin kullanılabilir durumda olmadığını fark edeceksiniz.

Admin aracını kullanarak bir sınıfı erişilebilir kılmak için, bu sınıfa ait bir Admin altsınıfı yaratın. Daha sonra bu altsınıfa sınıf öznitelikleri ekleyerek her bir sınıfın nasıl yönetileceğine ilişkin ayarları özelleştirebilirsiniz. Liste 19, Admin aracına Location (Yer) sınıfının nasıl ekleneceğini gösterir.

class Location(meta.Model):
    ...
    class Admin:
        list_display = ("city", "state", "country")

Şimdi admin arabirimi yoluyla Location kayıtlarını yaratabilir, güncelleyebilir ve silebilirsiniz.

Kayıtları, list_display sınıf özniteliğinde belirtildiği şekilde şehre, bölgeye ve ülkeye göre listeleyebilir ve sıralayabilirsiniz.

Admin aracı, her bir model sınıfı tipini yönetmek için çeşitli seçenekler içerir. Liste 20'de Job sınıfına uygulanan çeşitli örnekler gösterilmiştir:

class Job(meta.Model):
    ...
    class Admin:
	list_display = ("job_title", "location", "pub_date")
	ordering = ["-pub_date"]
	search_fields = ("job_title", "job_description")
	list_filter = ("location",)

Yukarıdaki ayarlara göre, iş kayıtları listelenirken işin unvanı, yeri ve yayınlanma tarihi kullanılacaktır. İşler, en yeni (eksi işareti azalan sırayı gösterir) olandan başlayarak yayınlanma tarihine göre sıralanacaktır. Kullanıcılar işleri unvana ve açıklamaya göre bulabilir, yöneticiler de kayıtları yere dayalı olarak süzebilirler.

URL düzeninizin tasarlanması

Django URL dağıtım sistemi, URL dizesi desenlerini views (görünümler) olarak adlandırılan Python yöntemleriyle eşleyen normal anlatım yapılandırma modüllerini kullanır. Bu sistem, URL'lerin temel koddan tamamen ayrıştırılmalarına olanak tanıyarak en üst düzeyde denetim ve esneklik sağlar.

Bir urls.py modülü, URL yapılandırmaları için varsayılan başlangıç noktası olarak yaratılır ve tanımlanır (settings.py modülündeki ROOT_URLCONF değeri yoluyla). Bir URL yapılandırma dosyası için tek gereksinim, urlpatterns olarak adlandırılan desenleri tanımlayan bir nesne içermesi zorunluluğudur.

Job board uygulaması, aşağıdaki URL eşlemeleri yoluyla erişilebilecek bir dizin ve ayrıntılı görünümle başlayacaktır:

• /jobs dizin görünümü: En son 10 işi görüntüler
• /jobs/1 ayrıntılı görünüm: 1 tanıtıcısına sahip işleri görüntüler

Her iki görünüm de (dizin ve ayrıntılı) jobs uygulamasında views.py olarak adlandırılan bir modüle uygulanacaktır. Bu yapılandırmayı projenin urls.py dosyasında kurduğunuzda aşağıdaki şekilde görünecektir:

from django.conf.urls.defaults import *

urlpatterns = patterns('',
    (r'^admin/', include('django.contrib.admin.urls.admin')),

    (r'^jobs/$', 'djproject.jobs.views.index'),
    (r'^jobs/(?P\d+)/$', 'djproject.jobs.views.detail'),
)

<job_id> bölümüne dikkat edin. Bu, daha sonrası için önemlidir.

En iyi yöntem, uygulamaya özgü URL desenlerini çıkartıp bunları uygulamanın kendisine yerleştirmektir. Bu, projeyi uygulamadan ayrıştırır ve daha geniş kapsamlı bir yeniden kullanıma olanak tanır. İş için bir uygulama düzeyinde URL yapılandırma dosyası şu şekilde görünecektir:

from django.conf.urls.defaults import *

urlpatterns = patterns('',
    (r'^$', 'djproject.jobs.views.index'),
    (r'^(?P\d+)/$', 'djproject.jobs.views.detail'),
)

Artık görünüm yöntemleri aynı modülden geldiği için, modülün kök adını djproject.jobs.views olarak belirtmek amacıyla ilk değişken kullanılabilir ve Django bunu index (dizin) ve detail (ayrıntılı) yöntemlerini aramak için kullanır:

from django.conf.urls.defaults import *

urlpatterns = patterns('djproject.jobs.views',
    (r'^$', 'index'),
    (r'^(?P\d+)/$', 'detail'),
)

Yukarıdaki işlerin URL'lerinin bir bütün olarak projeye geri bağlanması, include işlevi kullanılarak gerçekleştirilir. Uygulama düzeyi URL'leri /jobs bölümünün altına yeniden bağlanır:

from django.conf.urls.defaults import *

urlpatterns = patterns('',
    (r'^admin/', include('django.contrib.admin.urls.admin')),
    (r'^jobs/', include('djproject.jobs.urls')),
)

Bu noktada test sunucunuzu kullanarak dizin sayfasına (http://localhost:8000/jobs) erişmeye çalışırsanız, çağrılan görünüm (djproject.jobs.views.index) henüz var olmadığı için bir hata iletisi alırsınız.

Görünümlerin uygulanması

Görünüm, bir istek nesnesini kabul eden bir Python yöntemidir ve aşağıdakilerden sorumludur:

• Herhangi bir iş mantığı (doğrudan ya da dolaylı olarak)
• Şablona ilişkin verileri kapsayan bir içerik sözlüğü
• Şablonun bir içerikle oluşturulması
• Oluşturulan sonuçları çerçeveye geri taşıyan yanıt nesnesi

Django'da, bir URL istendiğinde çağrılan Python yöntemi bir view (görünüm) olarak adlandırılır ve view tarafından yüklenen ve oluşturulan sayfaya template (şablon) adı verilir. Bu nedenle, Django ekibi Django'dan bir MVT (model-görünüm-şablon) çerçevesi olarak bahseder. Diğer yandan, TurboGears, MVC kısaltmasına tam olarak uyması için, yöntemlerini controllers (denetleyiciler) ve bunların oluşturduğu şablonları views (görünümler) olarak adlandırır. Bunlar aynı işlevleri içerdiğinden, fark büyük ölçüde anlama dayalıdır.

Olası en basit görünüm, bir dizeyle başlatılan bir HttpResponse nesnesi üretir. Aşağıdaki yöntemi yaratın ve urls.py ve views.py dosyalarınızın düzgün bir biçimde kurulduğundan emin olmak için bir /jobs HTTP isteğinde bulunun.

from django.http import HttpResponse

def index(request):
    return HttpResponse("Job Index View")

Aşağıdaki kod, en son 10 işi alır, bunları bir şablon yoluyla oluşturur ve bir yanıt üretir. Bu kod, sonraki bölümdeki şablon dosyası olmadan çalışmayacaktır.

from django.template import Context, loader
from django.http import HttpResponse
from jobs.models import Job

def index(request):
    object_list = Job.objects.order_by('-pub_date')[:10]
    t = loader.get_template('jobs/job_list.html')
    c = Context({
        'object_list': object_list,
    })
    return HttpResponse(t.render(c))

Yukarıdaki kodda, şablon jobs/job_list.html dizesi tarafından adlandırılır. Şablon, object_list (nesne listesi) olarak adlandırılan iş listesi içeriğiyle oluşturulur. Oluşturulan şablon dizesi daha sonra bir HTTPResponse yapılandırıcıya geçirilir ve bu da çerçeve yoluyla isteği yapan istemciye geri gönderilir.

Bir şablonun yüklenmesi, içeriğin yaratılması ve yeni yanıt nesnesinin döndürülmesi adımlarının yerini, render_to_response olarak adlandırılan daha kolay bir yöntem alır. Yeni olan bir başka şey de, sağlanan değişkenleri kullanarak bir İş nesnesini almak için get_object_or_404 olarak adlandırılan kolay bir yöntemi kullanan ayrıntı görünümüdür. Nesne bulunmazsa, 404 kodlu olağandışı durum iletisi verilir. Bu iki yöntem, birçok Web uygulamasındaki ortak kodlardan çoğunu ortadan kaldırır.

from django.shortcuts import get_object_or_404, render_to_response
from jobs.models import Job

def index(request):
    object_list = Job.objects.order_by('-pub_date')[:10]
    return render_to_response('jobs/job_list.html',
                              {'object_list': object_list})

def detail(request, object_id):
    job = get_object_or_404(Job, pk=object_id)
    return render_to_response('jobs/job_detail.html',
                              {'object': job})

detail (ayrıntı) görünümü, bir değişken olarak object_id'yi alır. Bu, jobs urls.py dosyasındaki /jobs/ URL yolundan sonra belirtilen sayıdır. Buradan da birincil anahtar (pk; primary key) olarak get_object_or_404 yöntemine geçirilir.

Yukarıdaki görünümler yine de çalışmayacaktır çünkü bunların yüklediği ve oluşturduğu şablonlar (jobs/job_list.html and jobs/job_detail.html) henüz yoktur.

Şablonların yaratılması

Django, hızlı oluşturma ve kullanım kolaylığı için tasarlanan basit bir şablon dili sağlar. Django şablonları, {{ variables }} (değişkenler) ve {% tags %} (etiketler) ile yerleşik olan düz metin kullanılarak yaratılır. Değişkenler değerlendirilir ve bunların yerini temsil ettiği değerler alır. Etiketler temel denetim mantığı için kullanılır. Şablonlar, HTML, XML, CSV ve düz metin de dahil olmak üzere herhangi bir metne dayalı biçimi oluşturmak için kullanılabilir.

Gerçekleştirilecek ilk adım, şablonların bulunduğu yeri tanımlamaktır. Karmaşıklıktan kaçınmak için, djproject altında bir "templates" (şablonlar) dizini oluşturun ve bunun yolunu TEMPLATE_DIRS settings.py girişine ekleyin:

TEMPLATE_DIRS = (
    '/path/to/devdir/djproject/templates/',
)

Django şablonları, site tasarımcılarının, içeriği her bir şablonda yinelemeksizin birörnek bir görünüm yaratmalarını sağlayan template inheritance kavramını destekler. Bu kavramı, blok etiketli bir iskelet ya da temel belge tanımlayarak kullanabilirsiniz. Bu blok etiketleri, içerikli sayfa şablonları tarafından doldurulur. Bu örnekte, title, extrahead ve content olarak adlandırılan blokları içeren bir HTML iskeleti gösterilmiştir:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
  <head>
    <title>Company Site: {% block title %}Page{% endblock %}</title>
    {% block extrahead %}{% endblock %}
  </head>
  <body>
    {% block content %}{% endblock %}
  </body>
</html>

Uygulamayı projeden ayrıştırılmış olarak tutmak amacıyla, tüm İş uygulama sayfası dosyaları için temel olarak bir aracı temel dosya kullanın. Bu örnek için, uygulama CSS'sini temel dosyaya koyun. Gerçek uygulamada, düzgün bir biçimde yapılandırılmış bir Web sunucusuyla bu CSS'yi ayıklayın ve Web sunucusu tarafından sunulan statik bir dosyaya koyun.

{% extends "base.html" %}

{% block extrahead %}
    <style>
        body {
            font-style: arial;
        }
        h1 {
            text-align: center;
        }
        .job .title {
            font-size: 120%;
            font-weight: bold;
        }
        .job .posted {
            font-style: italic;
        }
    </style>
{% endblock %}

Varsayılan değer olarak, Django test sunucusu statik dosyalar sunmaz çünkü bu Web sunucusunun işidir. Geliştirme sırasında Django'nun resimler, stil sayfaları vb. sunmasını isterseniz, bu özelliğin nasıl etkinleştirileceğini görmek için Kaynaklar bölümündeki bağlantıyı tıklatın.

Şimdi, görünümler tarafından yüklenecek ve oluşturulacak iki sayfa şablonu yaratın. jobs/job_list.html şablonu object_list sayesinde basitçe yinelenir, index (dizin) görünümü sayesinde içeriğe ulaşır ve her bir kaydın ayrıntı sayfasına bir bağlantı içerir.

{% extends "jobs/base.html" %}

{% block title %}Job List{% endblock %}

{% block content %}
    <h1>Job List</h1>
    <ul>
    {% for job in object_list %}
        <li><a href="{{ job.id }}">{{ job.job_title }}</a></li>
    {% endfor %}
    </ul>
{% endblock %}

jobs/job_detail.html sayfası job adlı tek bir kayıt gösterir:

{% extends "jobs/base.html" %}

{% block title %}Job Detail{% endblock %}

{% block content %}
    <h1>Job Detail</h1>

    <div class="job">
        <div class="title">
            {{ job.job_title }}
            -
            {{ job.location }}
        </div>
        <div class="posted">
            Posted: {{ job.pub_date|date:"d-M-Y" }}
        </div>
        <div class="description">
            {{ job.job_description }}
        </div>
    </div>
{% endblock %}

Django şablon dili, sınırlı işlevsel yetenekler içerecek şekilde tasarlanmıştır. Bu sınırlandırma, şablonların programcı olmayan kişiler için kolay anlaşılır olmasını ve programcılar için de iş mantığını ait olmadığı bir yer olan sunu düzeyine yerleştirmemelerini sağlar. Kaynaklar bölümünde yer alan şablon dili belgesindeki bağlantıyı tıklatın.

Genel görünümler

Django, geliştiricilerin tipik örnekleri izleyen uygulamalar yaratmasını sağlayan dört dizi generic views (genel görünüm) içerir:

• Liste/ayrıntı sayfaları (yukarıdaki örnekte olduğu gibi)
• Kayıtların tarihe dayalı dökümü (haber ya da Web günlüğü siteleri için yararlı)
• Nesnelerin yaratılması, güncellenmesi ve silinmesi (CRUD)
• Basit doğrudan şablon oluşturma ya da basit HTTP yeniden yönlendirme

Ortak görünüm yöntemleri yaratmak yerine, iş mantığının tümü urls.py dosyasında bulunur ve Django tarafından sağlanan genel görünüm yöntemleri tarafından işlenir.

from django.conf.urls.defaults import *
from jobs.models import Job

info_dict = {
    'queryset': Job.objects.all(),
}

urlpatterns = patterns('django.views.generic.list_detail',
    (r'^$', 'object_list', info_dict),
    (r'^(?P<object_id>\d+)/$', 'object_detail', info_dict),
)

Bu urls.py dosyasında gerçekleştirilen üç temel değişiklik:

• Bir info_dict eşleştirme nesnesi, Jobs'a erişilebilmesi için bir sorgu dizisinden geçer.
• Bu dosya, django.views.generic.list_detail yerine djproject.jobs.views'u kullanır.
• Çağrılan gerçek görünümler, object_list ve object_detail'dir.

Bu proje, genel görünümlere geçişin otomatik olarak çalışmasını sağlamak için bazı gereksinimleri izler:

• Genel ayrıntı görünümü, object_id adlı bir değişkene gereksinim duyar.
• Şablonlar şu adlandırma kalıbını kullanır: app_label/model_name_list.html (jobs/job_list.html) app_label/model_name_detail.html (jobs/job_detail.html)
• Liste şablonu object_list adlı bir listeyi ele alır.
• Ayrıtnı şablonu object adlı bir nesneyi ele alır.

Sayfa başına düşen nesne sayısını belirten bir paginate_by değeri de eklenerek info_dict üzerinden daha fazla seçenek geçirilebilir.

Sonuç

Bu dizideki bir sonraki makalede, başka bir Web çerçevesi olan TurboGears incelenecek ve Django ile kaşılaştırılacaktır.

Kaynaklar

• Wikipedia'da overview of the MVC architecture (MVC mimarisine genel bakış) konusunu okuyun.
  
  
• "Fast-track your Web apps with Ruby on Rails" (Web uygulamalarınızı Ruby on Rails ile daha hızlı izleyin) (developerWorks, Haziran 2005), Ruby on Rails olanağının Web tabanlı uygulamaları nasıl yarattığını gösterir.
  
  
• Python.org, Python yorumlayıcıyı ve standart kitaplıkları yüklemek için kullanılacak bağlantılar içeren bir Python programlama dili ana sayfasıdır.
  
  
• Python öğreticisi, Python ile çalışmaya başlamanızı sağlar.
  
  
• DjangoProject.com, Django çerçevesinin ana sayfasıdır. Ana sayfa aşağıdaki belgeleri içerir:
  • Django'nun bir geliştirme makinesine nasıl kurulacağını gösteren How to install Django (Django nasıl kurulur) belgesi
  • Django ORM kitaplığının kullanılmasına ilişkin bir yol gösterici olan Database API reference (Veritabanı API başvurusu) belgesi
  • Şablon yazarları için basit bir yol gösterici olan Django template language (Django şablon dili) belgesi
  • Geliştirme sırasında Django'nun statik dosyaları sunması için nasıl kurulması gerektiğini gösteren How to serve static files (Statik dosyalar nasıl sunulur) (bunu üretimde yapmayın) belgesi
  • mod_python modülünü kullanarak Django'nun Apache ile birleştirilmesini açıklayan bir kılavuz niteliğindeki How to use Django with mod_python (Django mod_python ile nasıl kullanılır) belgesi
  • Genel Web uygulamaları kalıplarının Django'nun genel görünümleriyle çok daha hızlı bir biçimde nasıl kurulacağını gösteren Generic views (Genel görünümler) belgesi
  
  
• (Python Eggs paketinin bir parçası olan) easy_install (kolay kuruluş) ile birlikte kuruluş araçlarının nasıl kurulacağını gösteren Building and Distributing Packages with setuptools (kuruluş araçlarıyla Paketlerin Kurulması ve Dağıtılması) belgesi.
  
  
• Django performans ipuçları , Django ile yoğun bir trafiğin nasıl yönetileceğini gösterir.
  
  
• developerWorks Linux zone'da Linux geliştiricileri için daha fazla kaynak bulabilirsiniz.
  
  
• developerWorks teknik etkinlikler ve Web yayınları sayesinde güncel bilgiler edinebilirsiniz.

• SEK for Linux ürününü sipariş edin. Bu ürün, DB2®, Lotus®, Rational®, Tivoli® ve WebSphere® üzerinde Linux için en güncel IBM deneme yazılımlarını içeren ikili DVD setidir.
  
  
• Doğrudan developerWorks sitesinden yükleyebileceğiniz IBM deneme yazılımını kullanarak bir sonraki geliştirme projenizi Linux üzerinde oluşturabilirsiniz.
  
  

• developerWorks Web günlüklerine bakın ve developerWorks topluluğuna katılın.
  
  

Yazar hakkında