Django wurde von Ruby on Rails inspiriert und verwendet entsprechend in vielen Fällen dieselben Metaphern, um die Webentwicklung möglichst schnell und einfach zu gestalten. Dank seiner zahlreichen Features und Flexibilität hat sich Django inzwischen zum meistgenutzten Web Framework für Python gemausert.

Allerdings steht das quelloffene Framework auch im Ruf, äußerst komplex zu sein - zahlreichen Komponenten und einer Menge Konfigurationsoptionen sei Dank. Zur Wahrheit gehört allerdings auch, dass sich einfache Python-Applikationen in relativ überschaubarer Zeit erstellen lassen - deren Funktionalität anschließend nach Bedarf erweitert werden kann. Wie das mit Django geht, erfahren Sie in diesem Tutorial.

Django-Kernbibliotheken installieren

Um Django 5.0 zu installieren, benötigen Sie mindestens Python 3.10. Falls Sie mit einer älteren Version arbeiten, sollten Sie die Kompatibilität überprüfen. Idealerweise sollten Sie die neueste Python-Version einsetzen.

Im ersten Schritt gilt es zunächst, eine virtuelle Umgebung aufzusetzen, in der Django installiert werden kann. Auf diese Weise separieren Sie Django und die zugehörigen Libraries von Ihrer Python-Basisinstallation.

Anschließend installieren Sie Django in der von Ihnen gewählten virtuellen Umgebung mit Pythons pip-Utility:

pip install django

Damit werden die zentralen Django-Bibliotheken und das Kommandozeilen-Tool django-admin installiert. Letzteres kommt zum Einsatz, um Django-Projekte zu managen.

Django-Projekt neu aufsetzen

Django-Instanzen sind in zwei Kategorien organisiert - Projects und Apps.

• Ein Project ist eine Django-Instanz mit eigener Datenbankkonfiguration, eigenen Settings und eigenen Apps. Ein Django-Projekt könnte man sich als einen Ort vorstellen, an dem sämtliche Konfigurationen gespeichert sind, die auf Site-Ebene verwendet werden.

• Eine App ist eine Unterkategorie eines Projekts, mit eigener Route und Rendering-Logik. Mehrere Apps können in einem einzelnen Django-Projekt untergebracht werden.

Um ein neues Django-Projekt anzulegen, müssen Sie zunächst das Verzeichnis angeben, indem Sie das Project speichern möchten:

django-admin startproject <project_name>

Dabei ist <project_name> zugleich der Name des Projekts und des Unterverzeichnisses, in dem das Projekt gespeichert werden soll. Das neu erstellte Verzeichnis sollte eine Datei namens manage.py enthalten. Mit dieser wird das Verhalten der Applikation über die Kommandozeile gesteuert. Darüber hinaus sollte ein weiteres Unterverzeichnis vorhanden sein, das die folgenden Dateien enthält:

• __init__.py wird von Python verwendet, um ein Unterverzeichnis als Codemodul zu kennzeichnen.

• settings.py enthält die für das Projekt verwendeten Einstellungen. Die gebräuchlichsten Einstellungen werden vorausgefüllt.

• urls.py listet die Routes oder URLs auf, die in Ihrem Django-Projekt zur Verfügung stehen oder für die das Projekt Antworten liefert.

• wsgi.py wird von WSGI-kompatiblen Webservern wie Apache HTTP oder Nginx verwendet, um die Apps in Ihrem Projekts zu bedienen.

• asgi.py wird von ASGI-kompatiblen Webservern verwendet wird, um die Apps in Ihrem Projekt zu bedienen. ASGI ist ein relativ neuer Standard für asynchrone Server und Anwendungen und erfordert einen Support-Server wie uvicorn. Django unterstützt erst seit kurzem nativ asynchrone Anwendungen. Diese müssen ebenfalls auf einem Async-kompatiblen Server gehostet werden, um wirklich effektiv zu sein.

Als Nächstes testen Sie das Projekt, um sicherzustellen, dass es funktioniert. Füttern Sie dazu die Befehlszeile in dem Verzeichnis, in dem sich die Datei manage.py Ihres Projekts befindet, mit folgendem Kommando:

python manage.py runserver

Dieser Befehl startet einen Development Web Server, der unter der URL http://127.0.0.1:8000/ abrufbar ist. Wenn die Installation erfolgreich war, sehen Sie dort eine Willkommensseite. Zu beachten ist dabei, dass der Development Web Server nicht geeignet ist, um öffentlich zugängliche Django-Projekte bereitzustellen - er ist ausschließlich für lokale Tests gedacht.

Django-App erstellen

Im nächsten Schritt erstellen wir eine Anwendung im eben aufgesetzten Projekt. Wechseln Sie dazu in das Verzeichnis von manage.py und nutzen Sie den Befehl:

python manage.py startapp myapp

Hierdurch wird ein Unterverzeichnis für eine Anwendung namens myapp erstellt, das folgende Inhalte aufweist:

• Ein migrations-Verzeichnis, dessen Code verwendet wird, um die Site zwischen ihren Datenschema-Versionen zu migrieren. Django-Projekte nutzen für gewöhnlich eine Datenbank - entsprechend wird deren Schema (sowie Änderungen daran) im Rahmen des Projekts verwaltet.

• admin.py enthält Objekte, die von Djangos integrierten Administrations-Tools genutzt werden. Wenn Ihre Anwendung ein Admin Interface oder privilegierte Benutzer hat, werden die entsprechenden Objekte hier konfiguriert.

• apps.py stellt dem gesamten Projekt Konfigurationsinformationen über die Anwendung in Form eines AppConfig-Objekts zur Verfügung.

• models.py enthält Objekte, die Datenstrukturen definieren. Diese werden von der Applikation als Schnittstelle zu Datenbanken genutzt.

• tests.py beinhaltet sämtliche Tests, die die Funktionalität der Webseite und ihrer Module sicherstellen.

• views.py enthält Funktionen, um Antworten zu rendern und zurückzugeben.

Um mit der Django-Anwendung arbeiten zu können, müssen Sie sie zunächst im Projekt registrieren. Dazu bearbeiten Sie myproj/settings.py wie folgt:

INSTALLED_APPS = [

"myapp.apps.MyappConfig",

"django.contrib.admin",

...

Das vorgenerierte Objekt MyappConfig, auf das wir hier referenzieren, finden Sie in der Datei myproj/myapp/apps.py.

Sie wollen weitere interessante Beiträge zu Themen rund um die IT-Welt lesen? Unsere kostenlosen Newsletter liefern Ihnen nützliche Infos zu allem, was für Sie als Technologieprofi relevant ist - direkt in Ihre Inbox.

Jetzt CW-Newsletter sichern

Routes und Views zu Django-Apps hinzufügen

Um Requests zu verarbeiten, folgen Django-Applikationen einem grundlegenden Muster:

• Wenn eine Anfrage eingeht, analysiert Django die URL, um eine Route zu finden, auf die sie angewendet werden kann.

• Routes werden in urls.py definiert, wobei jede Route mit einem View verknüpft ist - also einer Funktion, die Daten zurückgibt, die an den Client gesendet werden. Views können überall in einem Django-Projekt platziert werden, sind aber idealerweise in eigenen Modulen organisiert.

• Views können die Ergebnisse eines Templates beinhalten, also Code, der angeforderte Daten auf Grundlage bestimmter Designstandards formatiert.

Um eine Vorstellung davon zu bekommen, wie all diese Teile zusammenpassen, wollen wir im nächsten Schritt die Standard-Route unserer Beispielanwendung so verändern, dass sie eine benutzerdefinierte Nachricht zurückgibt.

Routes werden wie bereits erwähnt in urls.py definiert - in einer Liste namens urlpatterns. Wenn Sie die Datei öffnen, sehen Sie, dass urlpatterns dabei bereits vordefiniert ist:

urlpatterns = [

path('admin/', admin.site.urls),

]

Die path-Funktion ist in Django integriert und generiert aus einer Route und einer View-Funktion eine Referenz zu einem URL-Pfad. Standardmäßig erstellt Django einen admin-Pfad, der für die Website-Administration verwendet wird. Um eigene Routes zu erstellen, verändern Sie die Datei wie folgt:

from django.contrib import admin

from django.urls import include, path

urlpatterns = [

path('admin/', admin.site.urls),

path('myapp/', include('myapp.urls'))

]

Die include-Funktion weist Django an, in myapp.urls nach weiteren Informationen über Route Patterns zu suchen. Alle in dieser Datei gefundenen Routes werden an die Top-Level-Route myapp angehängt (beispielsweise http://127.0.0.1:8080/myapp).

Nun erstellen Sie eine neue urls.py-Datei in myapp und fügen hinzu:

from django.urls import path

from . import views

urlpatterns = [

path('', views.index)

]

Django stellt jeder URL einen Slash (/) voran. Um das Root-Verzeichnis der Seite zu spezifizieren, nutzen Sie einen Blank String als URL.

Bearbeiten Sie nun die Datei myapp/views.py folgendermaßen:

from django.http import HttpResponse

def index(request):

return HttpResponse("Hello, world!")

Bei django.http.HttpResponse handelt es sich um eine Django-Integration, die eine HTTP-Antwort aus einem übergebenen String generiert. Dabei ist zu beachten, dass request (das die Informationen für eine eingehende HTTP-Anfrage enthält), als erster Parameter an eine view-Funktion übergeben werden muss.

Starten Sie den Entwicklungs-Web-Server anschließend neu und navigieren Sie zu http://127.0.0.1:8000/myapp/. Sie sollten nun "Hello, World!" in Ihrem Browser sehen.

Routes mit Variablen hinzufügen

Django akzeptiert Routes, die im Rahmen ihrer Syntax Variablen enthalten. Angenommen, Sie wollen URLs akzeptieren, die das Format year/<int:year> aufweisen. Das könnten Sie umsetzen, indem Sie urlpatterns um folgenden Eintrag ergänzen:

path('year/', views.year)

Die Funktion views.year würde dann über Routes wie year/1996, year/2010, et cetera aufgerufen werden. Dabei wird die Variable year als Parameter an views.year übergeben. Um das selbst auszuprobieren, fügen Sie obigen urlpatterns-Eintrag zu myapp/urls.py hinzu und ergänzen myapp/views.py um folgende Funktion:

def year(request, year):

return HttpResponse('Year: {}'.format(year))

Wenn Sie auf Ihrer Website nun zu /myapp/year/2010 navigieren, sollte als Antwort Year: 2010 angezeigt werden. Dabei ist zu beachten, dass Routen wie /myapp/year/rutabaga zu einem Fehler führen. Das liegt daran, dass die Einschränkung int: für die Variable year an dieser Stelle nur eine Ganzzahl zulässt. Ganz allgemein sind für Routes viele weitere Formatierungsoptionen verfügbar.

Frühere Versionen von Django wiesen eine komplexere Syntax für Routes auf, die schwer zu parsen war. Falls Sie dennoch Routes mit der alten Syntax hinzufügen müssen - beispielsweise, um Abwärtskompatibilität mit älteren Django-Projekten zu gewährleisten - können Sie dazu die Funktion django.urls.re_path verwenden, die Routen mit regulären Ausdrücken matcht.

Django Templates

Mit Hilfe von Djangos integrierter Template-Sprache lassen sich Webseiten aus Daten generieren.

Die Templates für Django-Apps werden in einem zentralen Projektverzeichnis abgelegt: <app_name>/templates/<app_name>/. Für unser myapp-Projekt würde der Verzeichnisname myapp/templates/myapp/ lauten. Diese Struktur mag auf den ersten Blick umständlich erscheinen. Dadurch, dass Django an mehreren Stellen nach Templates suchen kann, werden allerdings Namenskollisionen zwischen gleichnamigen Templates geräteübergreifend vermieden.

Erstellen Sie nun in myapp/templates/myapp/ eine Datei namens year.html mit folgendem Inhalt:

Year: {{year}}

Jeder Wert innerhalb der doppelten geschweiften Klammern wird als Variable behandelt.

Ändern Sie nun myapp/views.py ab, so dass sich folgendes Bild ergibt:

from django.shortcuts import render

from django.http import HttpResponse

def index(request):

return HttpResponse("Hello, world!")

def year(request, year):

data = {'year':year}

return render(request, 'myapp/year.html', data)

Die render-Funktion ist ein Django-Shortcut und bezieht sich auf das request-Objekt. Sie durchsucht die Liste der verfügbaren Template-Speicherorte nach myapp/year.html und übergibt das Dictionary data als Template-Kontext. Das Template nutzt das Dictionary als Namespace für Variablen, die dort zur Anwendung kommen. Ist das der Fall, wird die Variable {{year}} innerhalb des Templates durch den Wert des Keys year im Dictionary data ersetzt (data["year"]).

Der Umfang der Datenverarbeitung in Django-Templates ist absichtlich limitiert. Das liegt an der Philosophie von Django, Präsentations- und Business-Logik - wann immer möglich - voneinander zu trennen. Sie können also über iterierbare Objekte loopen und if/then/else-Tests fahren - Daten innerhalb eines Templates zu ändern, ist jedoch nicht zu empfehlen.

Ein einfacher if-Test ließe sich folgendermaßen realisieren:

{% if year > 2000 %}

21st century year: {{year}}

{% else %}

Pre-21st century year: {{year}}

{% endif %}

Die {% x %}-Markierungen grenzen dabei die Codeblöcke ab, die in der Template-Sprache von Django ausgeführt werden können.

Sie können darüber hinaus auch anspruchsvollere Template-Sprachen verwenden: Django enthält beispielsweise eine Backend-Integration für Jinja2. Ganz allgemein können Sie jedoch jede Template-Sprache einsetzen, die einen String zurückgibt.

Django kann noch mehr

Dieses Tutorial deckt lediglich die absoluten Django-Basics ab. Das Python Web Framework enthält eine Vielzahl weiterer Komponenten für den Einsatz in Web-Development-Projekten. Ein abschließender, kurzer Überblick:

• Datenbanken und Datenmodelle: Mit dem in Django integrierten ORM lassen sich Datenstrukturen und -beziehungen für Ihre Anwendung sowie Migrationspfade zwischen diesen definieren.

• Forms: Django bietet einen konsistenten Weg, um zu gewährleisten, dass views den Benutzern Input Forms bereitstellen, um Daten abzurufen, die Ergebnisse zu normalisieren und konsistente Reportings zu generieren.

• Security und Utilities: Django enthält diverse integrierte Funktionen für Caching-, Logging- und Session-Handling-Zwecke sowie um mit statischen Daten umzugehen und URLs zu normalisieren. Auch für allgemeine Sicherheitsbedürfnisse stehen entsprechende Tool-Bundles zur Verfügung.

(fm)