Einführung in Django-Views
Views (Ansichten) sind ein wesentlicher Bestandteil des Django-Architekturkonzepts und es ist für Framework-Entwickler*innen entscheidend, ein fundiertes Wissen über den Umgang mit ihnen zu haben. Wenn Sie erst mit der Entwicklung von Web-Apps mittels Django beginnen oder eine Auffrischung zu Views benötigen, sind Sie hier genau richtig.
Ein besseres Verständnis von Views wird Ihnen helfen, in Ihrem Django-Projekt schneller voranzukommen. Ganz gleich, ob Sie an einem API-Backend oder an Web-UI-Flows arbeiten: Das Wissen um den Einsatz von Views ist entscheidend.
Lesen Sie weiter, um zu erfahren, was Django Views sind, welche verschiedenen Arten es gibt, welche Best Practices für die Arbeit mit ihnen zu beachten sind und welche Anwendungsfälle es gibt.
Was sind Django Views?
Views sind eine Kernkomponente des MTV-Architekturkonzepts (Model-Template-View) von Django. Sie fungieren im Wesentlichen als Vermittler zwischen Models (Modellen) und Templates (Vorlagen), die Anfragen von Benutzer*innen verarbeiten und Antworten zurückgeben.
Vielleicht sind Ihnen Views im Rahmen des MVC-Konzepts (Model-View-Controller) bereits untergekommen. Diese unterscheiden sich jedoch leicht von Views in Django und lassen sich nicht direkt als solche abbilden. Django Views sind im Wesentlichen Controller in MVC, während Django Templates in etwa mit Views in MVC übereinstimmen. Daher ist es wichtig, die Nuancen von Django Views zu verstehen, selbst wenn Sie mit Views im MVC-Kontext vertraut sind.
Views sind Teil der Bedienschnittstelle in Django. Sie übernehmen die Logik und die Datenverarbeitung für Webanfragen, die an Ihre Django-basierten Apps und Websites gestellt werden. Sie setzen Ihre Templates in das um, was Benutzer*innen sehen, wenn sie Ihre Webseite aufrufen. Jede funktions- oder klassenbasierte View nimmt die Anfragen von Benutzer*innen entgegen, ruft die Daten aus den entsprechenden Modellen ab, wendet Geschäftslogik oder Datenverarbeitung an und bereitet dann eine HTTP-Antwort vor, welche an die Template zurückgegeben wird.
Diese Rückmeldung kann jegliche Art von Inhalten enthalten, die ein Webbrowser darstellt – in der Regel ist es eine HTML-Webseite. Django Views können jedoch auch Bilder, XML-Dokumente, Weiterleitungen, Fehlerseiten und mehr zurückgeben.
Rendering und Übergabe von Daten an Templates
Django stellt den Kurzbefehl render() zur Verfügung, um das Rendern von Templates innerhalb von Views zu vereinfachen. Wenn Sie render() verwenden, vermeiden Sie das Laden der Vorlage und die manuelle Erstellung der Antwort.
PyCharm bietet intelligente Code-Completion, die automatisch die Funktion render() aus django.shortcuts vorschlägt, wenn Sie mit der Eingabe in Ihren Views beginnen. Sie erkennt auch Template-Namen und bietet Auto-Completion für Template-Pfade, sodass Sie Tippfehler und Versehen vermeiden können.
Benutzer*innen geben die Anfrage, den Namen der Template und ein Kontext-Wörterbuch an, das die Daten für die Template enthält. Sobald die erforderlichen Daten vorliegen, übergibt die View sie an die Template, wo sie gerendert und den Benutzer*innen präsentiert werden können.
from django.shortcuts import render
def my_view(request):
# Some business logic to obtain data
data_to_pass = {'variable1': 'value1', 'variable2': 'value2'}
# Pass the data to the template
return render(request, 'my_template.html', context=data_to_pass)
In diesem Beispiel ist data_to_pass ein Wörterbuch, das die Daten enthält, welche Sie an die Template senden möchten. Die Funktion render wird dann zum Rendern der Template (my_template.html) mit den bereitgestellten Kontextdaten verwendet.
Jetzt können Sie in Ihrer Template (my_template.html) auf die Daten zugreifen und sie anzeigen.
{{ variable1 }}
{{ variable2 }}
In der Template verwenden Sie doppelte geschweifte Klammern ({{ }}), um die entsprechenden Variablen zu kennzeichnen. Diese werden durch die Werte aus den von der View übergebenen Kontextdaten ersetzt.
PyCharm bietet Completion und Syntaxhervorhebung für Django-Template-Tags, -Variablen und -Schleifen. Außerdem bietet das Tool Linting im Editor zur Beseitigung häufiger Fehler. So können Sie sich auf die Erstellung von Views und die Verarbeitungslogik konzentrieren, anstatt Zeit mit dem manuellen Ausfüllen von Template-Elementen oder dem Debuggen gängiger Versehen zu verbringen.
Funktionsbasierte Views
Django bietet zwei Arten von Views: funktionsbasierte und klassenbasierte.
Funktionsbasierte Views werden mit einfachen Python-Funktionen erstellt und sind im Allgemeinen in vier grundlegende Kategorien unterteilt: Erstellen, Lesen, Aktualisieren und Löschen (CRUD). Dies ist die Grundlage eines jeden Entwicklungsframeworks. Sie nehmen eine HTTP-Anfrage entgegen und geben eine HTTP-Antwort zurück.
from django.http import HttpResponse
def my_view(request):
# View logic goes here
context = {"message": "Hello world"}
return HttpResponse(render(request, "mytemplate.html", context))
Dieser Ausschnitt verarbeitet die View-Logik, bereitet ein Kontextwörterbuch für die Übergabe von Daten an eine Template vor, die gerendert wird, und gibt den endgültigen HTML-Text der Template in einem Antwortobjekt zurück.
Funktionsbasierte Views sind einfach und überschaubar. Die Logik wird in einer einzigen Python-Funktion abgedeckt und nicht über Methoden in einer Klasse verteilt, wodurch sie sich am besten für Anwendungsfälle mit minimaler Verarbeitung eignen.
PyCharm ermöglicht Ihnen die automatische Generierung von def my_view(request)-Strukturen mit Live-Vorlagen. Live-Vorlagen sind vorab definierte Codeausschnitte, die zu Textbaustein-Code erweitert werden können. Dieses Feature spart Ihnen Zeit und gewährleistet eine konsistente Struktur für Ihre View-Definitionen.
Sie können Live-Vorlagen einfach aufrufen, indem Sie ⌘J drücken, Listview eingeben und die Tabulatortaste betätigen.
Außerdem gibt es in PyCharm das Toolfenster Django Structure (Django-Struktur), in dem Sie geordnet nach App eine Liste aller Views in Ihrem Django-Projekt sehen können. So können Sie Views schnell finden, zwischen ihnen navigieren und feststellen, zu welcher Datei die jeweilige View gehört.
Klassenbasierte Views
Django hat klassenbasierte Views eingeführt, damit Benutzer*innen nicht immer wieder denselben Code schreiben müssen. Sie ersetzen funktionsbasierte Views nicht, sondern haben bestimmte Anwendungsbereiche und Vorteile, insbesondere in Fällen, in denen komplexe Logik erforderlich ist.
Klassenbasierte Views in Django bieten wiederverwendbare übergeordnete Klassen, die verschiedene Muster und Funktionen implementieren, welche typischerweise für Views in Webanwendungen benötigt werden. Sie können Ihre Views aus diesen übergeordneten Klassen übernehmen, um Boilerplate-Code zu reduzieren.
Klassenbasierte Views bieten generische übergeordnete Klassen wie:
ListViewDetailViewCreateView- Und vieles mehr.
Im Folgenden finden Sie zwei ähnliche Codeausschnitte, die eine einfache BookListView darstellen. Der erste zeigt eine grundlegende Implementierung unter Verwendung der standardmäßigen klassenbasierten Konventionen, während der zweite veranschaulicht, wie Sie die View durch Angabe zusätzlicher Parameter anpassen können.
Grundlegende Implementierung:
from django.views.generic import ListView
from .models import Book
class BookListView(ListView):
model = Book
# The template_name is omitted because Django defaults to 'book_list.html'
# based on the convention of _list.html for ListView.
Wenn BookListView gerendert wird, fragt der Code automatisch die Book–Datensätze ab und übergibt sie unter der Variablen books beim Rendern an book_list.html. Das bedeutet, dass Sie schnell eine View zur Auflistung von Objekten erstellen können, ohne die zugrunde liegende Logik umschreiben zu müssen.
Angepasste Implementierung:
from django.views.generic import ListView
from .models import Book
class BookListView(ListView):
model = Book
# You can customize the view further by adding additional attributes or methods
def get_queryset(self):
# Example of customizing the queryset to filter books
return Book.objects.filter(is_available=True)
Im zweiten Ausschnitt haben wir die angepasste Methode get_queryset() eingeführt, mit der wir die in der View angezeigten Datensätze genauer filtern können. Dies demonstriert, wie klassenbasierte Views über ihre Standardfunktionalität hinaus erweitert werden können, um den Anforderungen Ihrer Anwendung gerecht zu werden.
In klassenbasierten Views werden auch Methoden definiert, die mit wichtigen Teilen des Anfrage- und Antwortlebenszyklus verknüpft sind, z. B:
get()– Logik fürGET-Anfragen.post()– Logik fürPOST-Anfragen.dispatch()– bestimmt, ob die Methodeget()oderpost()aufgerufen werden soll.
Diese Arten von Views sorgen für Struktur und bieten gleichzeitig die Möglichkeit, sie bei Bedarf anzupassen, wodurch sie sich gut für komplexe Anwendungsfälle eignen.
PyCharm verfügt über Live-Vorlagen für klassenbasierte Views wie ListView, DetailView und TemplateView, mit denen Sie in Sekundenschnelle komplette View-Klassen mit Textbaustein-Methoden und Docstrings erstellen können.
Erstellen angepasster klassenbasierter Views
Sie können auch Ihre eigenen View-Klassen erstellen, indem Sie die generischen Klassen von Django unterklassifizieren und sie an Ihre Bedürfnisse anpassen.
Einige Anwendungsfälle, in denen Sie womöglich Ihre eigenen Klassen erstellen möchten, sind folgende:
- Hinzufügen von Geschäftslogik, z. B. komplizierte Berechnungen.
- Kombinieren mehrerer generischer übergeordneter Teile zur Erweiterung der Funktionalität.
- Verwaltung von Sitzungen oder Status über mehrere Anfragen hinweg.
- Optimieren des Datenbankzugriffs mit individuellen Anfragen.
- Wiederverwendung gemeinsamer Rendering-Logik in verschiedenen Bereichen.
Eine angepasste klassenbasierte View könnte wie folgt aussehen:
from django.views.generic import View
from django.shortcuts import render
from . import models
class ProductSalesView(View):
def get(self, request):
# Custom data processing
sales = get_sales_data()
return render(request, "sales.html", {"sales": sales})
def post(self, request):
# Custom form handling
form = SalesSearchForm(request.POST)
if form.is_valid():
results = models.Sale.objects.filter(date__gte=form.cleaned_data['start_date'])
context = {"results": results}
return render(request, "search_results.html", context)
# Invalid form handling
errors = form.errors
return render(request, "sales.html", {"errors": errors})
Mit den angepassten get- und post-Handlern können Sie die vorhandenen zwischen den Anfragen erweitern.
Einsatzbereiche der View-Arten
Funktionsbasierte und klassenbasierte Views können je nach Logikkomplexität und -bedarf beide nützlich sein.
Die Hauptunterschiede sind, dass klassenbasierte Ansichten …:
- … die Wiederverwendung durch Unterklassifizierung und Vererbung des Verhaltens der übergeordneten Teile fördern.
- … sich ideal für die Statusverwaltung zwischen Anfragen eignen.
- … für mehr Struktur und erzwungene Disziplin sorgen.
Sie können sie etwa in folgenden Bereichen verwenden:
- Dashboard-Seiten mit komplexer Rendering-Logik.
- öffentlich zugängliche Seiten, die dynamische Daten anzeigen.
- Admin-Portale für die Inhaltsverwaltung.
- Listen- oder Detailseiten mit Datenbankmodellen.
Auf der anderen Seite sind funktionsbasierte Views …:
- … einfacher und sie benötigen weniger Code.
- … für Python-Entwickler*innen unter Umständen leichter zu verstehen.
- … sehr flexibel und sie unterliegen weniger Beschränkungen.
Ihre Anwendungsfälle umfassen:
- Prototyping von Ideen.
- einfache CRUD- oder Datenbankansichten.
- Landing- oder Marketingseiten.
- API-Endpunkte für die Bearbeitung von Webanfragen.
Zusammenfassend sind funktionsbasierte Views anpassungsfähig, unkompliziert und leichter zu verstehen. Für komplexere Fälle müssen Sie jedoch mehr Code schreiben, den Sie nicht wiederverwenden können.
Klassenbasierte Views in Django erzwingen Struktur und sind wiederverwendbar, aber sie können schwieriger zu verstehen sowie zu implementieren sein und sind auch schwieriger zu debuggen.
Views und URLs
Wie wir bereits festgestellt haben, sind Views in Django die Funktionen oder Klassen, die bestimmen, wie eine Template gerendert wird. Jede View verweist auf ein bestimmtes URL-Muster und leitet eingehende Anfragen an die richtige Stelle.
Es ist wichtig, die Verbindung zwischen Views und URLs zu verstehen, um den Ablauf Ihrer Anwendung effektiv zu steuern.
Jede View entspricht einem URL-Muster, das in der Datei urls.py Ihrer Django-App definiert ist. Diese URL-Zuordnung stellt sicher, dass Django genau weiß, welche View aufgerufen werden soll, wenn Benutzer*innen zu einer bestimmten Adresse in Ihrer Anwendung navigieren.
Werfen wir einen Blick auf eine einfache URL-Konfiguration:
from django.urls import path
from .views import BookListView
urlpatterns = [
path('books/', BookListView.as_view(), name='book-list'),
]
Wenn Benutzer*innen in diesem Beispiel /books/ aufrufen, wird BookListView angesprochen, um die Liste der Bücher zu rendern. Indem Sie die URLs eindeutig den Views zuordnen, machen Sie Ihre Codebasis übersichtlicher und verbessern deren Organisation.
URL-Verwaltung mithilfe von PyCharm vereinfachen
Die Verwaltung und Visualisierung von Endpunkten in Django kann zu einer Herausforderung werden, wenn Ihre Anwendung wächst. PyCharm löst dieses Problem mit dem Toolfenster Endpoints (Endpunkte), das eine zentrale Ansicht aller URL-Muster, verknüpften Views und HTTP-Methoden Ihrer App bietet. Mit diesem Feature können Sie sich eine Liste aller Endpunkte in Ihrem Projekt anzeigen lassen, sodass Sie leichter nachvollziehen können, welche Views mit bestimmten URLs verbunden sind.
Anstatt mehrere urls.py-Dateien zu durchsuchen, können Sie die entsprechenden Views mit nur einem Klick sofort finden und aufrufen. Dies ist besonders nützlich für größere Django-Projekte, bei denen sich die URL-Konfigurationen über mehrere Dateien erstrecken, oder bei der Arbeit in Teams, wo es wichtig ist, den Kontext schnell zu erfassen.
Außerdem können Sie mit dem Toolfenster Endpoints alle Endpunkte in einer tabellenähnlichen Schnittstelle anzeigen lassen. Jede Zeile stellt den URL-Pfad, die HTTP-Methode (GET, POST usw.) sowie die zugehörige View-Funktion oder -Klasse eines bestimmten Endpunkts dar.
Dieses Feature steigert nicht nur die Produktivität, sondern verbessert auch die Code-Navigation. So können Sie fehlende oder doppelte URL-Muster ganz einfach erkennen. Diese Transparenz ist von unschätzbarem Wert, wenn es darum geht, Routing-Probleme zu debuggen oder neue Entwickler*innen in ein Projekt einzubinden.
Sehen Sie sich dieses Video an, um mehr über das Toolfenster Endpoints und dessen Nutzen für Sie zu erfahren.
Best Practices für die Verwendung von Django Views
Im Folgenden finden Sie einige Richtlinien, die Ihnen bei der Erstellung gut strukturierter und wartungsfähiger Views helfen können.
Klar strukturierte Views
Views sollten sich auf die Bearbeitung von Anfragen, das Abrufen von Daten, die Übergabe von Daten an Templates sowie die Steuerung des Ablaufs und von Umleitungen konzentrieren. Komplizierte Geschäftslogik und komplexe Verarbeitungen sollten an anderer Stelle stattfinden, z. B. in Model-Methoden oder speziellen Serviceklassen.
Sie sollten jedoch darauf achten, Ihre Models nicht mit zu viel Logik zu überladen, da dies in Django zu einem „Fat Model“-Anti-Pattern führen kann. In der Django-Dokumentation zu Views finden Sie weitere Erkenntnisse zur richtigen Strukturierung derselben.
Überschaubare Views und Templates
Es ist ratsam, sowohl Views als auch Templates schlank zu gestalten. Views sollten die Verarbeitung von Anfragen und den Abruf von Daten übernehmen, während Templates sich auf die Präsentation mit minimaler Logik konzentrieren.
Komplexe Verarbeitungen sollten in Python außerhalb der Templates durchgeführt werden, um die Wartungsfähigkeit und Testvorgänge zu optimieren. Mehr dazu finden Sie in der Dokumentation zu Django Templates.
Entkopplung von Datenbankabfragen
Es ist vorteilhaft, Datenbankabfragen in eigene Model-Manager oder Repositorys zu verlagern, anstatt sie direkt in Views zu integrieren, um Wiederholungen zu vermeiden. In der Dokumentation zu Django Models finden Sie Hinweise zur effektiven Verwaltung von Datenbankinteraktionen.
Bevorzugung generischer klassenbasierter Views
Die generischen klassenbasierten Views von Django, etwa DetailView und ListView, sind wiederverwendbar, ohne dass Sie viel Code schreiben müssen. Nutzen Sie sie, anstatt das Rad neu zu erfinden, um Ihre Arbeit effizienter zu gestalten. Die Dokumentation zu generischen Views ist eine hervorragende Ressource, um ein besseres Verständnis für diese Funktionen zu erlangen.
Eignung funktionsbasierter Views für simple Anwendungsfälle
Bei einfachen Views wie für das Bereitstellen von APIs ist eine Funktion möglicherweise effektiver als eine Klasse. Nutzen Sie komplexe klassenbasierte Views nur für ausgeklügelte UI-Abläufe. Die Dokumentation zur Entwicklung von Views bietet hilfreiche Beispiele.
Saubere Strukturierung von Routen und URLs
Organisieren Sie Routen und View-Handler, indem Sie diese nach Funktionalität in Apps gruppieren. Das erleichtert das Auffinden und Navigieren im Quellcode. In der Django-URL-Dispatcher-Dokumentation finden Sie Best Practices für die Strukturierung Ihrer URL-Konfigurationen.
Nächste Schritte
Da Sie nun die Grundlagen zu Views in Django kennen, sollten Sie sich intensiver mit dem Framework und den nächsten Schritten beschäftigen.
- Frischen Sie Ihre Django-Kenntnisse mit unserem Blogbeitrag So lernt man Django auf, der ideal für Anfänger*innen oder alle geeignet ist, die ihre Kenntnisse auf Vordermann bringen möchten.
- Entdecken Sie mit unserem Tutorial zur Erstellung einer einfachen To-do-Anwendung, wie Sie Ihr erstes Django-Projekt in PyCharm erstellen und ausführen, oder erkunden Sie unsere vollständige Liste von Django-Projektideen für noch mehr Inspiration.
- Erfahren Sie mehr über den aktuellen Stand von Django, um sich über die neuesten Trends im Bereich der Django-Entwicklung zu informieren und weitere Anregungen zu sammeln.
- Falls Sie noch nicht wissen, welches Python-Framework Sie verwenden sollen, könnten Ihnen unsere Vergleichsleitfäden Django vs. Flask und Django vs. FastAPI weiterhelfen.
Django-Unterstützung in PyCharm
PyCharm Professional ist die beste IDE für die Entwicklung mit Django. Dank Django-spezifischer Codehilfe, projektweiter Navigation und Refactoring sowie vollständiger Unterstützung für Django Templates können Sie schneller programmieren. Ein einziger Klick genügt, um sich mit Ihrer Datenbank zu verbinden und mit TypeScript, JavaScript und Frontend-Frameworks zu arbeiten. PyCharm unterstützt auch Flask und FastAPI von Haus aus.
Erstellen Sie bessere Anwendungen und rationalisieren Sie Ihren Code. Starten Sie jetzt mit PyCharm durch für eine reibungslose Erfahrung bei der Entwicklung mit Django.
Autorin des ursprünglichen Blogposts
Subscribe to PyCharm Blog updates
