Django Tutorial für Anfänger: Erste Einrichtung

Installation von Django

Die Installation von Django und Python unterscheidet sich je nach Betriebssystem. Hier findest du eine detaillierte Anleitung für Windows und Linux (Ubuntu), die dich Schritt für Schritt durch den Prozess führt.

Python und Django unter Windows installieren

1. Python installieren:
   • Besuche python.org und lade die neueste Python-Version für Windows herunter.
   • Starte den Installer. Wichtig: Achte darauf, die Option “Add Python to PATH” anzukreuzen, um Python systemweit verfügbar zu machen.
2. Überprüfung von Python und Pip:
   • Um zu überprüfen, ob Python und Pip korrekt installiert sind, öffne die Kommandozeile (CMD) und gib python --version und pip --version ein. Du solltest die installierten Versionen von Python und Pip sehen.
3. Virtuelle Umgebung erstellen:
   • In der Kommandozeile, erstelle eine virtuelle Umgebung mit python -m venv djangoenv. Dies erzeugt einen neuen Ordner djangoenv in deinem aktuellen Verzeichnis.
   • Aktiviere die Umgebung mit djangoenv\Scripts\activate. Deine Kommandozeile sollte nun den Namen der virtuellen Umgebung anzeigen.
4. Django installieren:
   • Innerhalb der aktivierten virtuellen Umgebung installiere Django mit pip install django.
   • Überprüfe die Installation mit django-admin --version.

Python und Django unter Linux (Ubuntu) installieren

1. Python und Pip installieren:
   • Öffne das Terminal und führe sudo apt-get update durch, um deine Paketlisten zu aktualisieren.
   • Installiere Python mit sudo apt-get install python3.
   • Installiere Pip, den Paketmanager für Python, mit sudo apt-get install python3-pip.
2. Überprüfung von Python und Pip:
   • Gib python3 --version und pip3 --version in das Terminal ein, um die Installationen zu überprüfen.
3. Virtuelle Umgebung erstellen:
   • Installiere das notwendige Paket für die virtuelle Umgebung mit sudo apt-get install python3-venv.
   • Erstelle eine virtuelle Umgebung in deinem gewünschten Verzeichnis mit python3 -m venv djangoenv.
   • Aktiviere sie mit source djangoenv/bin/activate.
4. Django installieren:
   • Innerhalb der aktivierten virtuellen Umgebung, installiere Django mit pip install django.
   • Verifiziere die Installation mit django-admin --version.

Gemeinsame Schritte nach der Django Installation

Nachdem Django installiert ist, kannst du beginnen, dein erstes Projekt zu erstellen. Nutze django-admin startproject meinprojekt, um um ein neues Projekt zu erstellen. Wechsle dann in das Projektverzeichnis mit cd meinprojekt und starte den Entwicklungsserver mit python manage.py runserver. Wenn du dann http://127.0.0.1:8000/ in deinem Browser aufrufst, solltest du die Django-Willkommensseite sehen.

Dein erstes Django-Projekt

Willkommen im Kernstück deines Django-Lernwegs! Hier starten wir mit dem Aufbau deines ersten Django-Projekts. Diese Anleitung ist so gestaltet, dass sie auch für Anfänger leicht verständlich und umsetzbar ist.

Projektstruktur in Django verstehen

Ein Django-Projekt besteht aus mehreren Komponenten, die gemeinsam eine robuste Webanwendung bilden. Die wichtigsten Elemente sind:

• Apps: Modularisierte Komponenten, die spezifische Funktionen in deinem Projekt übernehmen.
• Settings.py: Die Konfigurationsdatei deines Projekts, in der Einstellungen wie Datenbankverbindungen, installierte Apps und Middleware definiert sind.
• Urls.py: Diese Datei definiert die URL-Muster für deine Webanwendung und leitet Anfragen an die entsprechenden Ansichten weiter.
• Wsgi.py/Asgi.py: Einstiegspunkte für WSGI-kompatible Webserver, um deine Anwendung zu bedienen.

Ein Django Projekt erstellen

Um dein erstes Django-Projekt zu erstellen, öffne deine Kommandozeile oder Terminal und führe folgenden Befehl aus:

django-admin startproject meinprojekt

Dies erstellt ein neues Django-Projekt mit dem Namen ‘meinprojekt’ in deinem aktuellen Verzeichnis. Wechsle mit cd meinprojekt in das Projektverzeichnis, um mit der weiteren Konfiguration fortzufahren.

Entwicklungsumgebung einrichten

Als Anfänger in der Django-Entwicklung ist es wichtig, eine Entwicklungsumgebung zu wählen, die sowohl unterstützend als auch nicht überfordernd ist. Hier ein kurzer Überblick über die verschiedenen Optionen und eine detaillierte Anleitung zur Einrichtung einer anfängerfreundlichen Umgebung.

Was ist eine Entwicklungsumgebung?

Eine Entwicklungsumgebung ist der Ort, an dem du deinen Code schreibst, testest und debuggst. Sie besteht in der Regel aus einem Texteditor oder einer integrierten Entwicklungsumgebung (IDE), die zusätzliche Funktionen wie Code-Vervollständigung, Syntax-Hervorhebung und Debugging-Tools bietet.

Anfängerfreundliche Option: Visual Studio Code

Für Anfänger empfehlen wir Visual Studio Code (VS Code), eine leichte, aber leistungsfähige IDE, die gut für die Django-Entwicklung geeignet ist.

1. VS Code installieren:
   • Lade VS Code von der offiziellen Website herunter und installiere es.
   • Öffne VS Code und erkunde die Benutzeroberfläche, um dich mit den grundlegenden Funktionen vertraut zu machen.
2. Python- und Django-Erweiterungen:
   • Installiere die Python-Erweiterung, indem du in VS Code zum Extensions-Tab gehst und nach ‘Python’ suchst.
   • Für Django gibt es auch Erweiterungen, die du installieren kannst, wie z.B. ‘Django Template’ von Roberth Solis oder ‘Django’ von Baptiste Darthenay .
3. Projektordner öffnen:
   • Öffne deinen Django-Projektordner in VS Code, indem du auf “Datei” > “Ordner öffnen” gehst und deinen Projektordner auswählst.

Fortgeschrittene Tools

Wenn du dich etwas sicherer fühlst, solltest du dich mit weiteren Tools vertraut machen, die für die Entwicklung essenziell sind:

• PyCharm: Eine spezialisierte Python- und Django-IDE mit fortgeschrittenen Funktionen, ideal für größere Projekte.
• Sublime Text: Ein schneller und einfacher Texteditor, gut geeignet für kleinere Projekte oder schnelle Änderungen.
• Git: Ein Versionskontrollsystem, das dir hilft, Änderungen an deinem Code zu verfolgen und mit anderen zu teilen. Es ist wichtig, frühzeitig zu lernen, wie man Git verwendet, da es ein Standardwerkzeug in der Softwareentwicklung ist.

In dieser Phase deiner Lernreise ist es wichtig, sich auf die Grundlagen zu konzentrieren und nicht von Tools für eher fortgeschrittene Entwickler überwältigen zu lassen. Beginne mit dem, was du hast und baue dein Wissen und deine Fähigkeiten schrittweise aus.

Der Django-Entwicklungsserver

Der Django-Entwicklungsserver ist ein leichtgewichtiger Webserver, der speziell für die Entwicklung von Django-Projekten konzipiert wurde. Er ist nicht für den Produktionsgebrauch gedacht, aber ideal für die Entwicklung, da er eine schnelle und einfache Möglichkeit bietet, deine Django-Anwendung lokal zu testen und zu debuggen.

Was ist der Django-Entwicklungsserver?

Der Entwicklungsserver ist in Django integriert und erfordert keine separate Installation. Er bietet einige nützliche Funktionen für Entwickler:

• Automatisches Neuladen: Der Server erkennt Änderungen in deinen Projektdateien und lädt die Anwendung automatisch neu, sodass du Änderungen sofort im Browser sehen kannst.
• Fehlerberichte: Bei Fehlern in deinem Code zeigt der Server detaillierte Fehlerberichte direkt im Browser an, was das Debugging erleichtert.

Wie startet man den Django Entwicklungsserver?

Öffne das Terminal oder die Kommandozeile: Navigiere zu dem Verzeichnis deines Django-Projekts, in dem sich die manage.py-Datei befindet.

• Starte den Server: Führe den Befehl python manage.py runserver aus. Dies startet den Django-Entwicklungsserver auf dem Standardport 8000.
• Zugriff auf dein Projekt: Öffne einen Webbrowser und gehe zu http://127.0.0.1:8000/. Du solltest nun die Startseite deines Django-Projekts sehen. Sollte die Seite nicht geladen werden, überprüfe die Konsole auf Fehlermeldungen.
• Server stoppen: Um den Server zu stoppen, gehe zurück zur Kommandozeile oder zum Terminal und drücke CTRL + C.

Durch die Verwendung des Django-Entwicklungsservers kannst du Änderungen an deinem Projekt schnell und effizient testen, ohne jedes Mal einen externen Webserver starten zu müssen. Dies macht deinen Entwicklungsprozess deutlich schneller und intuitiver.

Wichtige Tools und Erweiterungen

Für eine effiziente Entwicklung mit Django gibt es eine Reihe von Tools und Erweiterungen, die besonders nützlich sind:

• Django Debug Toolbar: Ein unverzichtbares Tool zur Analyse und Optimierung deiner Django-Anwendungen.
• Django Extensions: Eine Sammlung von benutzerdefinierten Erweiterungen, die die Entwicklung vereinfachen.
• Datenbank-Tools: Werkzeuge wie DBeaver oder pgAdmin für die Verwaltung deiner Datenbank.
• Weitere Ressourcen: Für eine tiefere Auseinandersetzung mit Django empfehlen wir, unsere Artikel über fortgeschrittene Django-Themen und Best Practices zu lesen.

Mit diesen Schritten und Tools bist du gut aufgestellt, um in die Welt der Django-Entwicklung einzusteigen.

Eine Django-App erstellen

In diesem Abschnitt unseres Django-Tutorials für Anfänger konzentrieren wir uns darauf, wie du deine erste Django-App erstellen kannst. Eine App in Django ist eine Webanwendung, die eine bestimmte Funktion oder einen bestimmten Bereich deines Projekts abdeckt.

Was ist eine Django-App?

Eine Django-App ist eine Komponente innerhalb eines Django-Projekts, die eine spezifische Funktion erfüllt. Im Gegensatz zu einem Projekt, das die Gesamtstruktur und Konfiguration deiner Website repräsentiert, ist eine App ein modularer Baustein, der bestimmte Aspekte wie Nutzerverwaltung, Blog-Posts oder andere Funktionen handhabt.

Deine erste App erstellen

Um eine neue App in deinem Django-Projekt zu erstellen, folge diesen Schritten:

1. Öffne das Terminal oder die Kommandozeile: Gehe zum Verzeichnis deines Django-Projekts, in dem auch die manage.py-Datei liegt.
2. Starte die Erstellung einer App: Gib den Befehl python manage.py startapp meineapp ein. Ersetze ‘meineapp’ mit dem gewünschten Namen deiner App. Dadurch wird ein neues Verzeichnis mit dem Namen deiner App und einigen Starterdateien erstellt.
3. Struktur der App erkunden: In deinem App-Verzeichnis findest du verschiedene Dateien wie models.py, views.py und apps.py, die die Grundlage deiner App bilden.

Grundlegende Komponenten einer App

Jede Django-App besteht aus mehreren Schlüsselkomponenten:

• Models.py: Definiert die Datenstruktur, die in der Datenbank gespeichert wird.
• Views.py: Steuert die Logik der App und die Interaktion mit dem Modell und dem Template.
• Templates: Verantwortlich für die Darstellung der Daten, in der Regel HTML-Dateien.
• Urls.py: Definiert die URL-Muster für die App.

App in dein Projekt integrieren

Nachdem du deine App erstellt hast, musst du sie in dein Projekt integrieren:

1. Füge die App zu den installierten Apps hinzu: Öffne settings.py in deinem Projektverzeichnis und füge den Namen deiner App zur INSTALLED_APPS Liste hinzu.
2. URLs konfigurieren: Um URLs für deine App zu definieren, erstelle eine urls.py-Datei in deinem App-Verzeichnis und definiere die URL-Muster. Du musst auch das Haupt-URL-Muster in urls.py deines Projekts aktualisieren, um auf deine App-URLs zu verweisen.

Eine einfache Ansicht und URL erstellen

Zum Abschluss erstellst du eine einfache Ansicht in deiner App:

1. Erstelle eine Ansicht: Öffne views.py in deinem App-Verzeichnis und füge eine Funktion hinzu, z.B.:

   from django.http import HttpResponse
   
   def startseite(request):
       return HttpResponse("Hallo Welt!")
   

2. URL für die Ansicht definieren: In der urls.py deiner App, füge ein URL-Muster hinzu, das auf deine Ansicht verweist:

   from django.urls import path
   from . import views
   
   urlpatterns = [
       path('', views.startseite, name='startseite'),
   ]
   

3. Teste deine App: Starte den Django-Entwicklungsserver erneut und besuche http://127.0.0.1:8000/ in deinem Browser. Du solltest nun deine “Hallo Welt!” Nachricht sehen.

Glückwunsch! Du hast nun deine erste Django-App erstellt und bist bereit, weiter in die Welt von Django einzutauchen.

Ansichten und URLs in Django

Als Anfänger in Django wirst du schnell feststellen, dass Ansichten und URLs das Herzstück jeder Webanwendung bilden. Sie sind verantwortlich für die Verarbeitung von Benutzeranfragen und die Bestimmung der darauffolgenden Antworten. In diesem Abschnitt unseres Tutorials werden wir diese Konzepte detailliert und anfängerfreundlich erkunden.

Deine erste Ansicht erstellen

Beginnen wir mit dem Grundbaustein einer Django-Anwendung: der Ansicht. Eine Ansicht in Django ist eine Funktion, die eine HTTP-Anfrage empfängt und eine Antwort darauf gibt.

1. Verstehen der Ansichtsfunktion: Jede Ansicht nimmt als Hauptargument ein HttpRequest-Objekt entgegen und gibt ein HttpResponse-Objekt zurück. Diese Objekte beinhalten alle Informationen über die Anfrage des Benutzers und die Antwort deiner Anwendung.

2. Erstellen einer einfachen Ansicht: In deiner App findest du eine Datei namens views.py. Hier definierst du deine Ansichten. Um zu beginnen, fügen wir eine einfache Funktion hinzu:

   from django.http import HttpResponse
   
   def startseite(request):
       return HttpResponse('Willkommen auf meiner Seite!')
   

   Diese Funktion, startseite, wird aufgerufen, wenn ein Benutzer die entsprechende URL besucht. Sie gibt einfach einen Text zurück, der im Browser angezeigt wird.

URL-Routing verstehen und anwenden

Das URL-Routing ist das System, das Django verwendet, um eingehende Anfragen an die entsprechenden Ansichten weiterzuleiten.

• URL-Muster festlegen: In der Datei urls.py deines Projekts definierst du Muster, die Django verwendet, um URLs den richtigen Ansichten zuzuordnen. Jedes Muster ist mit einer Ansicht verknüpft, so dass Django weiß, welche Funktion es aufrufen soll, wenn eine bestimmte URL angefordert wird.

• Beispiel für URL-Routing: Angenommen, wir wollen unsere startseite-Ansicht aufrufen, wenn jemand die Hauptseite unserer Website besucht. Wir würden Folgendesfolgendes in urls.py schreiben:

  from django.urls import path
  from meineapp.views import startseite
  
  urlpatterns = [
      path('', startseite, name='startseite'),
  ]
  

  Dieses Muster sagt Django, dass es die startseite-Ansicht verwenden soll, wenn die Root-URL ('') der Website aufgerufen wird.

HTTP-Anfragen und -Antworten in Ansichten

In Django arbeitest du intensiv mit HTTP-Anfragen und -Antworten. Jede Ansicht empfängt Informationen über die Anfrage des Benutzers und muss entsprechend darauf reagieren.

• HttpRequest-Objekt: Jede Ansicht erhält ein HttpRequest-Objekt von Django, das Details über die Benutzeranfrage enthält, wie z.B. GET- und POST-Daten, Cookies, Header und mehr.

• HttpResponse-Objekt: Die Aufgabe der Ansicht ist es, ein HttpResponse-Objekt zurückzugeben. Dieses Objekt enthält die Antwort deiner Anwendung, die an den Benutzer zurückgesendet wird. Es kann sich um HTML-Code, reine Textnachrichten, eine Umleitung oder sogar um JSON für AJAX-Anfragen handeln.

Ansichten und Templates verbinden

In den meisten Fällen wirst du in deinen Ansichten HTML-Templates statt einfachem Text verwenden wollen. Templates ermöglichen es dir, dynamische Inhalte in strukturierten HTML-Dateien zu präsentieren.

• Einbinden von Templates: Um ein Template zu verwenden, änderst du deine Ansicht, um das render-Hilfsprogramm von Django zu nutzen. Dieses liest eine HTML-Datei und übergibt ihr Kontextdaten.

• Beispiel für eine Template-Ansicht: Erstelle eine HTML-Datei im templates-Ordner deiner App und ändere deine Ansicht, um das Template zu rendern:

  from django.shortcuts import render
  
  def startseite(request):
      return render(request, 'startseite.html', {'nachricht': 'Hallo Welt!'})
  

  Hier wird das Template startseite.html gerendert und ein Kontext mit einer Nachricht übergeben.

Klassenbasierte Ansichten vs. Funktionenbasierte Ansichten

Schließlich ist es wichtig zu wissen, dass Django zwei Arten von Ansichten bietet: klassenbasierte und funktionenbasierte. Für Anfänger sind funktionenbasierte Ansichten oft einfacher zu verstehen und zu handhaben.

• Klassenbasierte Ansichten: Sie bieten eine strukturierte Herangehensweise und sind nützlich für komplexere Funktionalitäten. Klassenbasierte Ansichten sind wiederverwendbar und können die Code-Organisation verbessern.

• Funktionenbasierte Ansichten: Sie sind direkter und oft intuitiver für einfache Anwendungen. Funktionenbasierte Ansichten sind ein guter Startpunkt, um das Konzept von Anfragen und Antworten in Django zu verstehen.

Als Anfänger ist es empfehlenswert, mit funktionenbasierten Ansichten zu starten und sich allmählich mit klassenbasierten Ansichten vertraut zu machen, wenn du komplexere Anwendungen entwickelst.

Durch das Verständnis dieser Schlüsselkonzepte bist du gut gerüstet, um effektive und benutzerfreundliche Webseiten in Django zu erstellen.

Django Einrichtung abschließen und Testen

Wir nähern uns dem Ende unseres Django-Tutorials für Anfänger, und es ist Zeit, die wichtigsten Punkte zusammenzufassen. Bisher haben wir Django installiert, ein Projekt erstellt, die grundlegende Struktur verstanden, unsere erste App entwickelt, mit Modellen und Datenbanken gearbeitet, das Verständnis für Ansichten und URLs vertieft und die Macht der Templates genutzt. Außerdem haben wir das leistungsstarke Django Admin-Interface aktiviert. Jetzt konzentrieren wir uns darauf, unsere Einrichtung abzuschließen und grundlegende Testmethoden zu erlernen, um sicherzustellen, dass unsere Anwendung wie erwartet funktioniert.

Die Anwendung lokal testen

Das Testen deiner Anwendung ist ein entscheidender Schritt in der Entwicklung. Es hilft dir, Fehler zu finden und sicherzustellen, dass deine Anwendung wie erwartet funktioniert.

1. Django-Entwicklungsserver verwenden:

   • Starte den Django-Entwicklungsserver erneut mit python manage.py runserver.
   • Überprüfe deine Anwendung, indem du sie im Browser unter http://127.0.0.1:8000/ aufrufst. Teste alle URLs und Funktionen, um sicherzustellen, dass alles richtig funktioniert.

2. Admin-Interface testen:

   • Besuche http://127.0.0.1:8000/admin/ und logge dich mit deinem Superuser-Konto ein.
   • Füge Testdaten hinzu, bearbeite sie und lösche sie, um sicherzustellen, dass dein Admin-Interface wie erwartet funktioniert.

3. Templates und statische Dateien:

   • Überprüfe, ob alle deine Templates korrekt rendern und ob die Einbindung statischer Dateien wie CSS und Bilder funktioniert.

4. Formulare und Benutzereingaben:

   • Wenn deine Anwendung Formulare verwendet, teste sie, indem du verschiedene Arten von Benutzereingaben machst, um sicherzustellen, dass die Validierung und Verarbeitung korrekt erfolgen.

5. Fehlermeldungen:

   • Provoziere bewusst Fehler, um zu sehen, ob deine Anwendung angemessene Fehlermeldungen liefert.

Grundlegende Debugging-Methoden

Wenn beim Testen Fehler auftreten, ist es wichtig, effektive Debugging-Methoden zu kennen:

1. Django-Fehlerseiten:

   • Wenn ein Fehler auftritt, bietet Django detaillierte Fehlerseiten, die dir helfen, das Problem zu identifizieren. Diese sind nur im Debug-Modus verfügbar.

2. Logging:

   • Implementiere Logging in deinem Projekt, um Fehlermeldungen und wichtige Informationen zu erfassen. Django bietet ein leistungsstarkes Logging-System, das du konfigurieren und an deine Bedürfnisse anpassen kannst.

3. Django Shell:

   • Nutze die Django-Shell, um mit deinen Modellen und Ansichten zu interagieren und Probleme zu diagnostizieren. Starte die Shell mit python manage.py shell.

4. Debugging-Tools:

   • Nutze Tools wie die Django Debug Toolbar, um zusätzliche Informationen über deine Anfragen, Templates und SQL-Abfragen zu erhalten.

5. Unit Tests:

   • Schreibe und führe Unit Tests für deine Anwendungen aus. Django bietet ein eingebautes Framework für Unit Tests, das es dir ermöglicht, die Funktionalität deiner Anwendungen systematisch zu überprüfen.

6. Community und Ressourcen:

   • Wenn du nicht weiterkommst, zögere nicht, die umfangreiche Django-Community um Hilfe zu bitten. Foren, Stack Overflow und die offizielle Django-Dokumentation sind hervorragende Ressourcen.

Durch die Anwendung dieser Test- und Debugging-Methoden kannst du sicherstellen, dass deine Django-Anwendung stabil, sicher und bereit für die nächsten Schritte ist.

Mit diesen Kenntnissen bist du nun in der Lage, eigene Django-Projekte zu starten und weiterzuentwickeln. Denke daran, dass Praxis und kontinuierliches Lernen der Schlüssel zum Erfolg in der Welt der Webentwicklung sind.