Erstellen von Views im Django-Webanwendungs-Framework

Preslav Dobrev2022-09-22 · 7 min read

Erstellen von Views im Django-Webanwendungs-Framework

Django ist ein leistungsstarkes, Open-Source-, Python-basiertes Web-Framework, das den Prozess der Erstellung und Verwaltung von Websites und Web-Apps rationalisiert. Django-Anwendungen sind skalierbar, leistungsstark und sicher. Es verfügt außerdem über eine wirklich gute Dokumentation zu jedem einzelnen Teil des Frameworks.

In unserer Serie über Django, haben wir Django untersucht, indem wir eine Beispiel-Website mit grundlegenden Blogging-Funktionen implementiert haben. In dieser Anleitung gehen wir die Schritte zur Erstellung einer Beispiel-View für unsere Django-App durch.

Voraussetzungen

Um dieser Anleitung zu folgen, benötigen Sie die folgenden Komponenten.

Einen Ubuntu-Server mit den richtigen Konfigurationen. Erfahren Sie mehr über die Einrichtung eines Ubuntu-Servers.
Eine ordnungsgemäß konfigurierte Python-Entwicklungsumgebung.
Einen Datenbankserver, zum Beispiel MySQL. Diese Anleitung beschreibt ausführlich das Installieren und Konfigurieren von MySQL auf einem Ubuntu-Server.

Diese Anleitung ist eine Fortsetzung unserer Serie über Django. Zunächst ist es nützlich, sich die vorherigen Anleitungen zur Einrichtung von Django, Herstellung der Django-Datenbankverbindung, Erstellung von Modellen und Aktivierung des Django-Admin-Interfaces anzusehen.

In dieser Anleitung zeigen wir Ihnen, wie Sie Django-Views erstellen, die es der Web-App ermöglichen, Web-Anfragen ordnungsgemäß zu verarbeiten und die entsprechende Antwort zurückzugeben. Wie in der offiziellen Django-Dokumentation beschrieben, kann eine Web-Antwort HTML-Inhalt einer Webseite, eine Weiterleitung oder ein HTTP-Fehler sein. Es gibt keinen festen Ort für die Speicherung der View-Funktionen, solange sie sich innerhalb der Python-Pfade befinden. Es gibt jedoch beliebte Konventionen für die Benennung und Platzierung der Dateien. Diese Anleitung wird diesen Konventionen folgen.

Schritt 1. Aktivieren der virtuellen Umgebung

Django wird am besten innerhalb einer virtuellen Python-Umgebung betrieben. Unsere Django-App sample_app ist in einer dedizierten virtuellen Umgebung eingerichtet. Aktivieren Sie zuerst die virtuelle Umgebung:

cd sample_app/

. sample_app_env/bin/activate

cd sample_app/

. sample_app_env/bin/activate

Schritt 2. Erstellen von View-Funktionen

Navigieren Sie zu unserem Verzeichnis random_app das die Modelle für unsere Blog-Website hostet:

cd random_app/

1	cd random_app/

Hier wird die Datei views.py den für die Erstellung unserer Views erforderlichen Code enthalten. Öffnen Sie sie in einem Texteditor:

nano views.py

1	nano views.py

Views in Django 1

Wir benötigen die Funktion render() aus der Bibliothek django.shortcuts , daher bleibt die erste Zeile gleich. Die Funktion render() Funktion hilft dabei, sowohl ein Template als auch einen Kontext zu kombinieren, um als das entsprechende HttpResponse -Objekt zurückgegeben zu werden.

Die erste View wird Benutzer begrüßen, die auf der Index-Seite landen. Wir müssen die Funktion HttpResponse() aus der Django-Bibliothek http:

from django.shortcuts import render
from django.http import HttpResponse

def index(request):
  return HttpResponse(Sie sind auf der Willkommensseite gelandet')

def individual_post(request):
  return HttpResponse('Einzelne Beiträge werden hier erscheinen')

from django.shortcuts import render

from django.http import HttpResponse

def index(request):

return HttpResponse(Sie sind auf der Willkommensseite gelandet')

def individual_post(request):

return HttpResponse('Einzelne Beiträge werden hier erscheinen')

Views in Django Edited Views

Speichern Sie die Datei und schließen Sie den Editor.

Schritt 3. URLs den Views zuordnen

Im Moment ist diesen Funktionen keine URL zugewiesen, sodass sie nicht zugänglich sind. Wir müssen einen weiteren Block urlpatterns innerhalb der URL-Konfigurationsdatei hinzufügen. In Python wird diese als die URLconf (URL-Konfigurations-)Datei bezeichnet.

Django muss das Root- URLconf-Modul bestimmen, das verwendet werden soll. Dann sucht es in urlpatterns nach allen URL-Mustern in einer Listenstruktur. Django durchläuft dann die Datei, bis es die erste Übereinstimmung findet. Sobald eine Übereinstimmung gefunden wird, sucht Django nach der zugehörigen View. Diese View-Funktion erhält Daten im Zusammenhang mit dem URL-Muster und ein HttpRequest -Objekt. Ein Fehler an irgendeinem Punkt dieses Prozesses leitet zu einer Fehlerbehandlungs-View weiter.

Öffnen Sie die Datei urls.py von random_app in einem Texteditor:

nano urls.py

1	nano urls.py

Geben Sie den folgenden Code ein:

from django.urls import path
from . import views

urlpatterns = [
  path('', views.index, name='index'),
  path('post/', views.individual_post, name='individual_post')
]

from django.urls import path

from . import views

urlpatterns = [

path('', views.index, name='index'),

path('post/', views.individual_post, name='individual_post')

]

Views in Django Urls

Speichern Sie die Datei und schließen Sie den Editor.

Sobald dies erledigt ist, müssen wir auch den Pfad der URL-Datei in der sample_app -Verzeichnis- URLconf einbinden. Andernfalls wird unsere Django-App sie nicht erkennen. Das liegt daran, dass die URLconf von sample_app als ROOT_URLCONF in der Einstellungsdatei festgelegt ist.

Navigieren Sie zum Verzeichnis unserer App sample_app:

cd sample_app/sample_app/sample_app/

1	cd sample_app/sample_app/sample_app/

Öffnen Sie die Datei urls.py in einem Texteditor:

nano urls.py

1	nano urls.py

Sample Urls

Geben Sie den folgenden Code in die Datei ein:

from django.contrib import admin
from django.urls import include, path

urlpatterns = [
  path('admin/', admin.site.urls),
  path('', include('random_app.urls'))
]

from django.contrib import admin

from django.urls import include, path

urlpatterns = [

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

path('', include('random_app.urls'))

]

Sample Urls2

Lassen Sie uns unsere Änderungen testen. Starten Sie den Django-App-Server auf localhost:8000:

python manage.py runserver localhost:8000

1	python manage.py runserver localhost:8000

Views in Django Start Server

Navigieren Sie zur URL:

localhost:8000

1	localhost:8000

Views in Django Wc Page

Überprüfen Sie die URL für den Beitrag:

localhost:8000/posts

1	localhost:8000/posts

Schritt 4. Erstellen eines Blog-Beitrags

Wir haben unsere URL-Muster festgelegt und deren Workflows untersucht. Es ist an der Zeit, einen Beispiel-Blog hinzuzufügen und das Ergebnis zu sehen.

Navigieren Sie im Admin-Bereich zur random_app -Seite:

localhost:8000/admin/random_app/

1	localhost:8000/admin/random_app/

Views in Django Random Admin Page

Klicken Sie auf den Link +Add in der Zeile Posts :

Views in Django Add Post

Auf der neuen Webseite wird ein Formular mit den folgenden Feldern angezeigt.

Titel: Der Titel des Blog-Beitrags.
Slug: Dies bezieht sich auf den Teil der gültigen Webadresse mit menschenlesbaren Schlüsselwörtern. Im Allgemeinen werden Slugs aus dem Titel des Beitrags erstellt.
Inhalt: Hauptteil des Blog-Beitrags.
Autor: Der entsprechende Benutzername.

Klicken Sie auf SAVE , um den Beitrag zu senden:

Save Post

Schritt 5. Anzeigen der Daten in der Datenbank

Im nächsten Abschnitt werden wir mit unserer Datenbank arbeiten. Melden Sie sich bei MySQL als der für Django vorgesehene Benutzer an:

mysql -u sample_app_user -p

1	mysql -u sample_app_user -p

Mysql prompt

Lassen Sie uns überprüfen, ob unser Beitrag erfolgreich in der Datenbank registriert wurde:

USE sample_app_data;

1	USE sample_app_data;

Change DB

SELECT * FROM random_app_post;

1	SELECT * FROM random_app_post;

Select Query

Voila! Der Beitrag wurde erfolgreich registriert! Sie können die MySQL-Shell nun verlassen.

Schritt 6. Zusätzliche Anpassungen der Ansicht (Views)

Es gibt noch ein paar Dinge, die wir mit unseren Ansichten tun können. Öffnen Sie die Datei in einem Texteditor:

nano views.py

1	nano views.py

Der Code sollte wie folgt aussehen:

from django.shortcuts import render
from django.http import HttpResponse
from .models import Post

def index(request):
	return HttpResponse('Hello, welcome to the index page.')

def individual_post(request):
	recent_post = Post.objects.get(id__exact=1)
	return HttpResponse(recent_post.title + ': ' + recent_post.content)

from django.shortcuts import render

from django.http import HttpResponse

from .models import Post

def index(request):

return HttpResponse('Hello, welcome to the index page.')

def individual_post(request):

recent_post = Post.objects.get(id__exact=1)

return HttpResponse(recent_post.title + ': ' + recent_post.content)

Edit Views

Hier haben wir eine zusätzliche import -Anweisung für Post hinzugefügt. Die in Anführungszeichen gesetzte Zeichenkette von HttpResponse wird ebenfalls durch Daten aus unserem Blog-Beitrag ersetzt. Um auf die Daten zu verweisen, verwenden wir die Blog-Beitrag-ID mit dem zugehörigen Objekt. Die ID wird in einer Variablen recent_post gespeichert. Jetzt können wir bestimmte Felder des Objekts extrahieren, indem wir das Feld mit einem Punkt als Trennzeichen anhängen.

Sobald dies geändert wurde, lassen Sie uns die Änderungen überprüfen. Starten Sie den Django-Server:

python manage.py runserver localhost:8000

1	python manage.py runserver localhost:8000

Start Server

Rufen Sie nun die Posts -Seite auf:

localhost:8000/posts

1	localhost:8000/posts

View Post

Es sollte der von uns erstellte Blog-Beitrag angezeigt werden.

Schritt 7. Beenden des Projekts

Um den Django-Server zu beenden, drücken Sie Strg + C im Terminal. Um die virtuelle Python-Umgebung zu deaktivieren, führen Sie folgenden Befehl aus:

deactivate

1	deactivate

Fazit

In dieser Anleitung haben wir erfolgreich das Erstellen von Views, das Zuordnen von URL-Mustern und das Anzeigen von Texten auf einer Webseite aus der Datenbank von random_app in Django.Dies sind grundlegende Konzepte von Django, die man verstehen und beherrschen muss.

Hier sind weitere Ressourcen, die Ihnen helfen, Django-Apps zu erstellen und zu verwalten:

Viel Spaß beim Programmieren!

Preslav Dobrev

Autor · CloudSigma

Preslav Dobrev ist ein kreativer Designer bei CloudSigma und konzentriert sich auf eine konsistente Unternehmensidentität durch traditionelle und innovative Marketingkanäle. Er versteht es meisterhaft, künstlerische Vision mit strategischem Marketing zu verbinden, um wirkungsvolle Markengeschichten zu schaffen.