Ein Projekt erstellen¶

Wenn dies dein erstes Mal ist, dass du Django benutzt, wirst du dich um einige grundlegende Einstellungen kümmern müssen. Du wirst nämlich einigen Code autogenerieren müssen, der ein Django-Projekt erstellt – eine Sammlung von Einstellungen für eine Instanz von Django, einschließlich Datenbank-Konfiguration, djangospezifischen Optionen und Applikationsspezifischen Einstellungen.

Auf der Kommandozeile bewege dich mit cd in ein Verzeichnis, wo du deinen Code ablegen möchtest. Dann führe den Befehl django-admin.py startproject mysite aus. Dieses erstellt ein mysite-Verzeichnis in deinem aktuellen Verzeichnis.

django-admin.py sollte sich auf deinem Systempfad befinden, wenn du Django über python setup.py installiert hast. Wenn es sich nicht auf deinem Pfad befindet, kannst du es in site-packages/django/bin finden, wobei site-packages ein Verzeichnis innerhalb deiner Python-Installation ist. Du solltest in Erwägung ziehen, einen symbolischen Link auf django-admin.py von irgendeinem Ort auf deinem Pfad, wie z. B. /usr/local/bin zu erstellen.

Lass uns einen Blick auf das werfen, was startproject erstellt hat:

mysite/
    __init__.py
    manage.py
    settings.py
    urls.py

Diese Dateien sind:

• __init__.py: Eine leere Datei, die Python mitteilt, dass dieses Verzeichnis als Python-Paket betrachtet werden soll (Lies mehr über Pakete in der offiziellen Python-Dokumentation, wenn du ein Anfänger bist).
• manage.py: Ein Kommandozeilen-Hilfsprogramm, dass dich mit dem Django-Projekt auf verschiedene Weise interagieren lässt. Du kannst alle Details über manage.py in ref-django-admin nachlesen.
• settings.py: Die Einstellungs-/Konfigurationsdatei für dieses Django-Projekt. topics-settings wird dir alles darüber erzählen, wie Einstellungen funktionieren.
• urls.py: Die URL-Deklarationen für dieses Django-Projekt. Eine "Tabelle mit Inhalten" deiner Django-betriebenen Seite. Du kannst mehr über URLs in topics-http-urls nachlesen.

Validating models...
0 errors found.

Django version 1.0, using settings 'mysite.settings'
Development server is running at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

python manage.py runserver 8080

python manage.py syncdb

Datenbankmodelle erstellen¶

Jetzt ist deine Umgebung – ein "Projekt" – eingerichtet, und du kannst mit der Arbeit beginnen.

Jede Applikation, die du in Django schreibst, besteht aus einem Python-Paket, irgendwo auf deinem Python-Pfad, der einer bestimmten Konvention folgt. Django wird mit einem Dienstprogramm geliefert, das automatisch eine grundlegende Struktur für eine Applikation erstellt, so dass du dich auf das Schreiben von Code konzentrieren kannst und nicht darauf Verzeichnisse zu erstellen.

In diesem Tutorial werden wir der Einfachheit halber unsere Umfrageapplikation im mysite-Verzeichnis erstellen. In der Konsequenz wird die Applikation an das Projekt gekoppelt – das bedeutet Python-Code innerhalb der Umfrageapplikation verweist auf mysite.polls. Später in diesem Tutorial, werden wir die Entkopplung deiner Applikationen für die Verbreitung diskutieren.

Um deine Applikation zu erstellen, stelle sicher, dass du dich im Verzeichnis mysite befindest wenn du und diesen Befehl tippst:

python manage.py startapp polls

Dies erstellt ein Verzeichnis polls, das so aussieht:

polls/
    __init__.py
    models.py
    views.py

Diese Verzeichnisstruktur wird die Umfrageapplikation enthalten.

Der erste Schritt beim Schreiben einer Datenbank-Webapplikation in Django ist es, deine Datenmodelle – hauptsächlich dein Datenbanklayout mit zusätzlichen Metadaten – zu definieren.

In unserer einfachen Umfrageapplikation erzeugen wir zwei Datenmodelle: Umfragen (polls) und Auswahlmöglichkeiten (choices). Eine Umfrage hat eine Frage und ein Veröffentlichungsdatum. Eine Auswahlmöglichkeit hat zwei Felder: einen Text der Auswahlmöglichkeit und einen Stimmenzähler. Jede Auswahlmöglichkeit ist mit einer Umfrage verknüpft.

Diese Konzepte werden durch einfache Python-Klassen repräsentiert. Bearbeite die Datei polls/models.py, so dass sie so aussieht:

from django.db import models

class Poll(models.Model):
    question = models.CharField(max_length=200)
    pub_date = models.DateTimeField('date published')

class Choice(models.Model):
    poll = models.ForeignKey(Poll)
    choice = models.CharField(max_length=200)
    votes = models.IntegerField()

Der Code ist einfach. Jedes Datenmodell wird von einer Klasse repräsentiert, die django.db.models.Model subklassifiziert. Jedes Datenmodell hat eine Nummer von Klassenvariablen, die jeweils ein Datenbankfeld im Datenmodell repräsentieren.

Jedes Feld wird von einer Instanz der Klasse Field repräsentiert – z. B. CharField für Zeichenfelder und DateTimeField für Datum- und Zeitfelder. Dies teilt Django mit, welchen Typ von Daten jedes Feld enthält.

Der Name von jeder Field-Instanz (z. B. question oder pub_date) ist der Name des Feldes in maschinenlesbares Format. Du benutzt diesen Wert in deinem Python-Code und deine Datenbank wird ihn als Spaltennamen benutzen.

Du kannst ein optionales, an erster Stelle positioniertes Argument bei einem Field benutzen, um einen visuell lesbaren Namen zu bestimmen. Das wird bei einer Reihe von introspektiven Teilen von Django benutzt, und dient als zusätzliche Dokumentation. Wenn dieses Feld nicht festgelegt ist, benutzt Django den maschinenlesbaren Namen. In diesem Beispiel haben wir nur den visuell lesbaren Namen für Poll.pub_date definiert. Für alle anderen Felder in diesem Datenmodell dient der maschinenlesbare Name als visuell lesbarer Name.

Einige Field-Klassen haben erfoderliche Elemente. Field benötigt z. B. die Angabe eines max_length. Dieses wird nicht nur im Datenbankschema verwendet, sondern auch für die Validierung, wie wir bald sehen werden.

Schließlich wurde noch ein Verknüpfungsfeld definiert, unter Verwendung von ForeignKey. Dieses teilt Django mit, dass jede Auswahl mit einer einzigen Umfrage verknüpft ist. Django unterstützt alle üblichen Datenbankverknüpfungen: 1:n, n:m und 1:1.

Datenmodelle aktivieren¶

Dieses kleines bisschen Datenmodellcode liefert Django eine Menge Informationen. Damit ist Django in der Lage:

• ein Datenbankschema (CREATE TABLE-Anweisung) für diese Applikation zu erstellen.
• eine Python-Datenbankzugriff-API für den Zugriff auf Poll- und Choice-Objekte zu erstellen.

Aber zuerst müssen wir unserem Projekt noch mitteilen, dass die Applikation polls installiert ist.

Bearbeite die Datei settings.py noch einmal und ändere die Einstellung INSTALLED_APPS, dass sie 'mysite.polls' enthält. Dann sieht sie so aus:

INSTALLED_APPS = (
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.sites',
    'mysite.polls'
)

Jetzt weiß Django das mysite die Applikation polls enthält. Lass uns einen weiteren Befehl ausführen:

python manage.py sql polls

Du solltest etwas ähnliches (die CREATE TABLE SQL-Befehle für die Umfrageapplikation) wie dieses sehen:

BEGIN;
CREATE TABLE "polls_poll" (
    "id" serial NOT NULL PRIMARY KEY,
    "question" varchar(200) NOT NULL,
    "pub_date" timestamp with time zone NOT NULL
);
CREATE TABLE "polls_choice" (
    "id" serial NOT NULL PRIMARY KEY,
    "poll_id" integer NOT NULL REFERENCES "polls_poll" ("id"),
    "choice" varchar(200) NOT NULL,
    "votes" integer NOT NULL
);
COMMIT;

Beachte das folgende:

• Die exakte Ausgabe wird in Abhängigkeit der von dir benutzten Datenbank variieren.
• Die Tabellennamen werden automatisch generiert, indem der Name der Applikation (polls) und der kleingeschriebene Name des Datenmodells – poll und choice kombiniert werden (dieses Verhalten kann verändert werden).
• Primärschlüssel (IDs) werden automatisch hinzugefügt (du kannst auch dies verändern).
• Durch Konvention hängt Django "_id" an den Fremdschlüsselfeldnamen an. Und ja, auch dies kann verändert werden.
• Die Fremdschlüsselverknüpfung wird explizit mit einem REFERENCES-Befehl gemacht.
• Es ist maßgeschneidert auf die Datenbank, die du benutzt, weshalb datenbankspezifische Feldertypen, wie auto_increment (MySQL), serial (PostgreSQL) oder integer primary key (SQLite) automatisch verarbeitet werden. Das gleiche gilt für die Notierung von Feldnamen – z. B. die Benutzung von doppelten oder einfachen Anführungszeichen. Der Autor dieses Tutorials benutzt PostgreSQL, deshalb sind die Beispielausgaben in der PostgreSQL-Syntax.
• Der Befehl sql führt das SQL nicht in der Datenbank aus, sondern druckt es nur auf den Bildschirm, damit du sehen kannst, welches SQL Django für erforderlich hält. Wenn du willst, könntest du diese Ausgabe kopieren und in deine Datenbankeingabe einfügen. Aber, wie wir in Kürze sehen werden, bietet Django einen leichteren Weg SQL in die Datenbank zu übergeben.

Wenn du interesiert bist, kannst du auch die folgenden Befehle ausführen:

• python manage.py validate – Prüft auf irgendwelche Fehler in der Struktur der Datenmodelle.
• python manage.py sqlcustom polls – Gibt alle benutzerdefinierten SQL-Statements (wie Tabellenmodifikationen oder Beschränkungen) aus, die für die Applikation definiert sind.
• python manage.py sqlclear polls – Gibt die notwendigen DROP TABLE-Befehle für diese Applikation aus, entsprechend der Tabellen, die bereits in der Datenbank existieren (wenn welche existieren).
• python manage.py sqlindexes polls – Gibt die CREATE INDEX-Befehle für diese Applikation aus.
• python manage.py sqlall polls – Eine Kombination von allem SQL aus den Befehlen sql, sqlcustom und sqlindexes.

Wenn du auf die Ausgabe von diesen Befehlen schaust, kann es dir helfen zu verstehen, was wirklich unter der Haube vor sich geht.

Jetzt führe noch einmal syncdb für diese Tabellen der Datenmodelle in deiner Datenbank aus:

python manage.py syncdb

Der Befehl syncdb führt das SQL von 'sqlall' für alle Applikationen, in INSTALLED_APPS, die nicht bereits in der Datenbank existieren auf deiner Datenbank aus. Dies erstellt alle Tabellen, anfängliche Daten und Indizes für alle Applikationen, die du zu deinem Projekt seit dem letzten Mal, dass du syncdb ausgeführt hast, hinzugefügt hast. syncdb kann so oft aufgerufen werden, wie es dir gefällt, und es wird nur Tabellen anlegen, die nicht existieren.

Lies die django-admin.py-Dokumentation für vollständige Informationen darüber, was das Dienstprogramm manage.py kann.

Mit der API spielen¶

Als nächstes wagen wir einen Sprung in die interaktive Python-Shell und spielen mit der gratis API herum, die Django dir bietet. Um die Python-Shell zu aktivieren, benutzte diesen Befehl:

python manage.py shell

Wir benutzen dies, anstatt einfach "python" zu tippen, weil manage.py die Projektumgebung für dich einrichtet. "Die Projektumgebung einrichten" beinhaltet zwei Dinge:

• mysite wird auf sys.path gesetzt. Für bessere Flexibilität verweisen einige Teile von Django auf Projekte in der Python-Punktsyntax (z. B. 'mysite.polls.models'). Damit dies funktioniert, muss das Paket mysite sich auf sys.path befinden.

  Wir haben bereits ein Beispiel hiervon gesehen: die Einstellung INSTALLED_APPS ist eine Liste von Paketen in der Punktsyntax-Schreibung.

• die Umgebungsvariable DJANGO_SETTINGS_MODULE wird gesetzt, die Django den Pfad zu deiner Datei settings.py gibt.

Wenn du dich erst auf der Shell befindest, erkunde die Datenbank-API:

# Importiere die Modellklassen, die wir gerade geschrieben haben.
>>> from mysite.polls.models import Poll, Choice

# Noch keine Umfragen im System.
>>> Poll.objects.all()
[]

# Erstelle eine neue Umfrage.
>>> import datetime
>>> p = Poll(question="What's up?", pub_date=datetime.datetime.now())

# Speichere das Objet in die Datenbank. Du musst save() explizit aufrufen.
>>> p.save()

# Jetzt hat es eine ID. Beachte, dass es auch "1L" anstelle von "1" heißen
# kann, abhängig von der Datenbank, die du benutzt. Das ist kein Problem, es
# bedeutet nur, dass dein Datenbank-Backend es vorzieht integer als Python
# long integer Objekte zurückzugeben.
>>> p.id
1

# Greife auf die Datenbankspalten über Python-Attribute zu.
>>> p.question
"What's up?"
>>> p.pub_date
datetime.datetime(2007, 7, 15, 12, 00, 53)

# Veränderte Werte, indem du die Attribute veränderst und dann
# save() aufrufst.
>>> p.pub_date = datetime.datetime(2007, 4, 1, 0, 0)
>>> p.save()

# objects.all() zeigt alle Umfragen in der Datenbank.
>>> Poll.objects.all()
[<Poll: Poll object>]

Aber warte einen Moment. <Poll: Poll object> ist eine völlig nutzlose Darstellung von diesem Objekt. Lass uns das beheben, indem wir das Datenmodell der Umfrage (in der Datei polls/models.py) bearbeiten und eine Methode __unicode__() zu Poll und Choice hinzufügen:

class Poll(models.Model):
    # ...
    def __unicode__(self):
        return self.question

class Choice(models.Model):
    # ...
    def __unicode__(self):
        return self.choice

Es ist wichtig die __unicode__()-Methoden zu deinen Datenmodellen hinzuzufügen, nicht nur für dich, wenn du mit der interaktiven Eingabezeile arbeitest, sondern auch weil die Repräsentationen der Objekte in Djangos automatisch-erzeugtem Admin-Interface benutzt werden.

Beachte, dass dies normale Python-Methoden sind. Lass uns eine benutzerdefinierte Methode hinzufügen, nur zur Demonstration:

import datetime
# ...
class Poll(models.Model):
    # ...
    def was_published_today(self):
        return self.pub_date.date() == datetime.date.today()

Beachte das Hinzufügen von import datetime, um Pythons Standard-datetime-Modul zu referenzieren.

Springen wir jetzt zurück in die interaktive Python-Konsole, indem wir den Befehl python manage.py shell erneut ausführen:

>>> from mysite.polls.models import Poll, Choice

# Stelle sicher, dass unsere __unicode__()-Hinzufügung funktioniert.
>>> Poll.objects.all()
[<Poll: What's up?>]

# Django bietet eine umfassende Datenbankabfrage-API, die vollständig durch
# Schlüsselwortargumente betrieben wird.
>>> Poll.objects.filter(id=1)
[<Poll: What's up?>]
>>> Poll.objects.filter(question__startswith='What')
[<Poll: What's up?>]

# Hole dir die Umfrage, deren Jahr 2007 ist. Natürlich solltest du diese Zahl
# anpassen, wenn du das Tutorial in einem anderen Jahr durcharbeitest.
>>> Poll.objects.get(pub_date__year=2007)
<Poll: What's up?>

>>> Poll.objects.get(id=2)
Traceback (most recent call last):
    ...
DoesNotExist: Poll matching query does not exist.

# Abfrage durch einen Primärschlüssel ist der üblichste Fall, daher bietet
# Django eine Abkürzung für Primärschlüsselabfragen.
# The following is identical to Poll.objects.get(id=1).
>>> Poll.objects.get(pk=1)
<Poll: What's up?>

# Stelle sicher, dass unsere benutzerdefinierte Methode funktioniert.
>>> p = Poll.objects.get(pk=1)
>>> p.was_published_today()
False

# Gib der Umfrage einige Auswahlmöglichkeiten. Der Aufruf von `create()`
# erzeugt ein neues Auswahl-Objekt, führt den INSERT-Befehl aus, fügt die
# Auswahl zur Gruppe Auswahlmöglichkeiten hinzu und gibt das neue
# Choice-Object zurück.
>>> p = Poll.objects.get(pk=1)
>>> p.choice_set.create(choice='Not much', votes=0)
<Choice: Not much>
>>> p.choice_set.create(choice='The sky', votes=0)
<Choice: The sky>
>>> c = p.choice_set.create(choice='Just hacking again', votes=0)

# Choice-Objekte haben API-Zugriff zu ihren verknüpften Poll-Objekten.
>>> c.poll
<Poll: What's up?>

# Und auch umgekehrt: Poll-Objekte haben Zugriff auf Choice-Objtekte.
>>> p.choice_set.all()
[<Choice: Not much>, <Choice: The sky>, <Choice: Just hacking again>]
>>> p.choice_set.count()
3

# Die API folgt automatisch Verknüpfungen, so weit wie du sie brauchst.
# Benutze doppelte Unterstriche um Verknüpfungen zu trennen.
# Dies funktioniert so viele Ebenen tief, wie du willst, es gibt kein Limit.
# Finde alle Choices for alle Umfragen, deren pub_date in 2007 liegt.
>>> Choice.objects.filter(poll__pub_date__year=2007)
[<Choice: Not much>, <Choice: The sky>, <Choice: Just hacking again>]

# Lass uns eine der Auswahlmöglichkeiten löschen. Benutze delete() dafür.
>>> c = p.choice_set.filter(choice__startswith='Just hacking')
>>> c.delete()

Für vollständige Details der Datenbank-API, schaue in unsere Datenbank-API-Referenz.

Wenn du dich etwas in den Umgang mit der API eingearbeitet hast, lies Teil 2 von diesem Tutorial um Djangos automatisches Admin-Interface zum Laufen zu bringen.