Erstelle Dein Datenmodell

Django enthält einen objektrelationalen Mapper (ORM), welcher es ermöglicht, das gesamte Datenbanklayout in Python Code zu beschreiben. (Es ist trotzdem möglich, Django auch ohne eine Datenbank zu benutzen.)

Die Syntax für die Datenmodelle bietet einen umfangreichen Weg, die Modelle zu definieren — bis jetzt löst es Datenbankschema-Probleme im Umfang von zwei Jahren. Hier ist ein kurzes Beispiel:

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

    def __unicode__(self):
        return self.full_name

class Article(models.Model):
    pub_date = models.DateTimeField()
    headline = models.CharField(max_length=200)
    article = models.TextField()
    reporter = models.ForeignKey(Reporter)

    def __unicode__(self):
        return self.headline

Installiere es

Als nächstes werden die Datenbanktabellen mit dem Django-Kommandozeilen-Tool automatisch erstellt:

manage.py syncdb

Der syncdb Befehl untersucht alle verfügbaren Modelle und erstellt die entsprechenden Tabellen in der Datenbank, vorausgesetzt diese existieren noch nicht.

Genieße die kostenlose API

Bereits an diesem Punkt bekommt man eine umfangreiche Python API zum Zugriff auf die Daten. Die API wird “on the fly” erstellt, es ist keine Codegenerierung nötig:

>>> from mysite.models import Reporter, Article

# Es gibt noch keine Reporter.
>>> Reporter.objects.all()
[]

# Einen neuen Reporter erstellen.
>>> r = Reporter(full_name='John Smith')

# Zum Speichern des Objekts in der Datenbank muss explizit die
# save()-Methode aufgerufen werden.
>>> r.save()

# Nun hat das Objekt eine ID.
>>> r.id
1

# Der neue Reporter ist nun in der Datenbank.
>>> Reporter.objects.all()
[John Smith]

# Alle Felder sind Attribute des Python-Objekts.
>>> r.full_name
'John Smith'

# Django bietet eine umfangreiche Datenbank-Abfrage-API.
>>> Reporter.objects.get(id=1)
John Smith
>>> Reporter.objects.get(full_name__startswith='John')
John Smith
>>> Reporter.objects.get(full_name__contains='mith')
John Smith
>>> Reporter.objects.get(id=2)
Traceback (most recent call last):
    ...
DoesNotExist: Reporter does not exist for {'id__exact': 2}

# Einen Artikel erstellen.
>>> from datetime import datetime
>>> a = Article(pub_date=datetime.now(), headline='Django is cool',
...     article='Yeah.', reporter=r)
>>> a.save()

# Der Artikel ist nun in der Datenbank.
>>> Article.objects.all()
[Django is cool]

# Artikel-Objekte haben API-Zugriff auf alle zugehörigen Reporter-Objekte.
>>> r = a.reporter
>>> r.full_name
'John Smith'

# Und umgekehrt: Reporter Objekte haben API-Zugriff auf Artikel Objekte.
>>> r.article_set.all()
[Django is cool]

# Die API folgt Beziehungen, so weit man es benötigt, dabei werden hinter
# den Kulissen effektive JOINs eingesetzt.
# Folgende Abfrage findet alle Artikel von Reportern deren Name mit "John"
# beginnt.
>>> Article.objects.filter(reporter__full_name__startswith="John")
[Django is cool]

# Objekte werden durch Ändern der Attribute und dem Aufruf von save() geändert.
>>> r.full_name = 'Billy Goat'
>>> r.save()

# Ein Objekt mit delete() löschen.
>>> r.delete()

Eine dynamische Administrationsoberfläche: Nicht nur ein Gerüst, sondern ein ganzes Haus

Sobald die Datenmodelle definiert sind, kann Django automatisch eine professionelle, einsatzfertige Administrationsoberfläche erstellen — eine Webseite, die es autorisierten Benutzern ermöglicht, Daten hinzuzufügen, zu ändern und zu löschen. Alles was man tun muss, ist eine Zeile Code zur Modell-Klasse hinzuzufügen:

class Article(models.Model):
    pub_date = models.DateTimeField()
    headline = models.CharField(max_length=200)
    article = models.TextField()
    reporter = models.ForeignKey(Reporter)
    class Admin: pass

Die Philosophie hierbei ist, dass die Webseite von Mitarbeitern, einem Kunden oder vielleicht nur von dir selbst editiert wird. In diesem Fall will man sich nicht damit rumschlagen, eine Administrationsoberfläche nur für das Verwalten der Inhalte zu erstellen.

Ein typischer Arbeitsablauf beim Erstellen einer Django-Anwendung ist es, zuerst die Datenmodelle zu erstellen und dann die Administrationsoberfläche so schnell wie möglich verfügbar zu machen. Mitarbeiter oder Kunden können dann beginnen, Inhalte einzufügen. Erst dann wird begonnen, die öffentliche Darstellung der Daten zu programmieren.

Gestalte Deine URLs

Ein sauberes, elegantes URL-Schema ist ein wichtiges Detail einer qualitativ hochwertigen Webanwendung. Django unterstützt hübsche URLs und benötigt keine überflüssigen Teile in den URLs, wie etwa .php oder .asp.

Um URLs für eine Anwendung zu entwerfen, wird ein Python Modul, informell URLconf (URL configuration) genannt, erstellt. Im Prinzip eine einfache Zuordnung zwischen URL-Mustern und Python Funktionen. Die URL-Konfiguration dient außerdem dazu die URLs vom Python-Code zu entkoppeln.

Hier ist ein Beispiel, wie eine URL-Konfiguration für das Reporter/Article Beispiel aussehen könnte:

from django.conf.urls.defaults import *

urlpatterns = patterns('',
    (r'^articles/(\d{4})/$', 'mysite.views.year_archive'),
    (r'^articles/(\d{4})/(\d{2})/$', 'mysite.views.month_archive'),
    (r'^articles/(\d{4})/(\d{2})/(\d+)/$', 'mysite.views.article_detail'),
)

Der obige Code bildet URLs mit simplen regulären Ausdrücken auf Python-Funktionen (“Views”) ab. Die regulären Ausdrücke benutzen runde Klammern um Werte aus der URL zu erfassen. Ruft ein Benutzer eine Seite auf, prüft Django nacheinander jedes der Muster und stoppt beim ersten Treffer, der auf die aufgerufene URL passt. (Passt keines der Muster, ruft Django einen speziellen 404 View auf.) Dieses Verfahren ist sehr schnell, da die regulären Ausdrücke beim Laden der Anwendung kompiliert werden.

Sobald einer der regulären Ausdrücke passt, importiert Django den entsprechenden View, welcher eine einfache Python-Funktion ist, und ruft ihn auf. Jedem View wird ein Request-Objekt übergeben, welches Meta-Daten des Aufrufs enthält, sowie alle Werte, die vom regulären Ausdruck erfasst wurden.

Wenn zum Beispiel ein Benutzer die URL “/articles/2005/05/39323/” aufruft, würde Django die Funktion mysite.views.article_detail(request, '2005', '05', '39323') aufrufen.

Schreib Deine Views

Jeder View ist verantwortlich dafür, genau eines von zwei Dingen zu tun: Entweder ein HttpResponse-Objekt mit dem Inhalt der aufgerufenen Seite zurückgeben oder eine Exception, wie z.B. Http404, auszulösen. Alles Weitere ist Deine Aufgabe.

Im Prinzip lädt ein View Daten mit Hilfe der übergebenen Parameter, lädt ein Template und füllt das Template mit den entsprechenden Daten. Hier ist ein Beispiel für den View year_archive von weiter oben:

def year_archive(request, year):
    a_list = Article.objects.filter(pub_date__year=year)
    return render_to_response('news/year_archive.html', {'year': year, 'article_list': a_list})

Dieses Beispiel benutzt Djangos Template-System, welches sehr mächtige Features hat, gleichzeitig aber anstrebt, für Nicht-Programmierer einfach genug zu bleiben.

Entwerfe Deine Templates

Der obige Code lädt das news/year_archive.html-Template.

Django benutzt einen Template-Suchpfad, welcher es erlaubt, Redundanzen in den Templates zu minimieren. In den Django-Einstellungen kann man eine Liste mit Verzeichnissen angeben, in denen nach Templates gesucht werden soll. Existiert ein Template nicht im ersten Verzeichnis, wird im zweiten gesucht und so weiter.

Angenommen das news/article_detail.html-Template wurde gefunden, so könnte es aussehen:

{% 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 %}

Variablen sind von doppelten geschweiften Klammern umgeben. {{ article.headline }} bedeutet “Gib den Wert vom headline-Attribut des article-Objekts aus”. Punkte werden allerdings nicht nur für das Nachschlagen von Attributen benutzt, sondern auch für das Nachschlagen von Dictionary-Keys und List-Indices sowie für Funktionsaufrufe.

Beachte: {{ article.pub_date|date:"F j, Y" }} benutzt eine Unix-artige “Pipe” (Das “|” Zeichen). Dies nennt man einen Template-Filter und es ist ein Weg, Werte einer Variablen zu verändern. In diesem Fall formatiert der “date”-Filter ein Python datetime-Objekt in das angegebene Format. (Das Format entspricht dem der PHP date()-Funktion; ja, es gibt tatsächlich eine gute Idee in PHP.)

Man kann so viele Filter aneinander hängen, wie man möchte. Außerdem kann man eigene Filter schreiben und man kann so genannte Template-Tags schreiben, welche hinter den Kulissen Python-Code ausführen.

Außerdem benutzt Django das Konzept der “Template-Vererbung”. Das ist genau das, was hier passiert: {% extends "base.html" %}. Es bedeutet: “Lade zuerst das Template mit dem Namen ‘base.html’, welches eine Reihe von Blöcken definiert und fülle diese Blöcke mit den nachfolgenden Blöcken”. Zusammengefasst lassen sich dadurch Redundanzen in den Templates drastisch reduzieren. Jedes Template muss nur das definieren, was es von anderen Templates unterscheidet.

So könnte das “base.html” Template aussehen:

<html>
<head>
    <title>{% block title %}{% endblock %}</title>
</head>
<body>
    <img src="sitelogo.gif" alt="Logo" />
    {% block content %}{% endblock %}
</body>
</html>

Vereinfacht dargestellt, definiert dieses Basis-Template Aussehen und Handhabung der Webseite (mit dem Logo der Seite) und bietet Platzhalter, die von den Child-Templates gefüllt werden. Ein Redesign der Seite wird dadurch genauso einfach wie das Austauschen einer einzigen Datei — dem Basis-Template.

Es wird dadurch auch möglich, mehrere Versionen einer Seite mit unterschiedlichen Basis-Templates zu erstellen und die gleichen Child-Templates zu verwenden. Die Erfinder von Django haben diese Technik benutzt, um spezielle Versionen von Webseiten, optimiert für verschiedene Mobiltelefone, zu erstellen — einfach nur durch Erstellen eines neuen Basis-Templates.

Beachte bitte auch, dass Du nicht gezwungen bist, das Template-System von Django zu benutzen, falls Du ein anderes bevorzugst. Djangos Template-System ist zwar mit dem Model-Layer sehr gut integriert, aber niemand wird gezwungen es zu benutzen. Ebenso muss man nicht die Datenbank-API von Django benutzen. Man kann einen anderen Datenbankabstraktions-Layer verwenden, kann XML-Dateien lesen, Dateien direkt von der Festplatte lesen oder irgendeine andere Lösung, die man sich vorstellen kann. Jeder Teil von Django — Datenmodelle, Views, Templates — ist vom Rest entkoppelt.

Das war nur der Anfang

Dies war nur ein schneller Überblick über den Funktionsumfang von Django. Einige weitere nützliche Features sind:

• Ein komplettes Cache-Framework, welches memcached oder andere Backends benutzen kann.
• Ein Syndication-Framework, welches das Erstellen von RSS und Atom Feeds so einfach wie das Schreiben einer kleinen Python-Klasse macht.
• Viele weitere automatisch generierte Administrations-Features — die Übersicht war nur die Spitze des Eisbergs.

Die nächsten Schritte für Dich wären Django herunterladen, das Tutorial lesen und der Community beitreten. Danke für Dein Interesse!