TOC

So erstellen Sie Django Views

Einführung

Wenn Sie unsererDjango Development-Serie gefolgt sind, haben Sie erfolgreich eine Django-Anwendung erstellt, mit der Benutzer mit Administratorrechtencomments undposts über das Administrator-Dashboard von Django hinzufügen können. Sie können auch die Datenpersistenz einrichten, indem Sie die objektrelationale Mapping-Lösungmodelsvon MySQL und Django nutzen.

In diesem Tutorial erstellen wir Djangoviews, mit denen unsere Webanwendung Webanforderungen ordnungsgemäß verarbeiten und die erforderlichen Webanwendungen zurückgeben kann. Wie inDjango docs definiert, kann eine Webantwort der HTML-Inhalt einer Webseite, eine Umleitung oder ein HTTP-Fehler sein (z. 404). Der Code für die Ansichtsfunktionen kann technisch überall in Ihrem Projekt vorhanden sein, solange er sich auf Ihrem Python-Pfad befindet. Es gibt jedoch einige gängige Konventionen zum Benennen und Platzieren der Datei, in der diese Ansichtsfunktionen vorhanden sind, und wir werden diese Praktiken befolgen.

Sobald Sie die Schritte dieses Tutorials ausgeführt haben, wird auf Ihrer Django-Blog-Site ein kürzlich veröffentlichter Beitrag in die URL vonyour-IP-or-domain/postabgerufen.

Voraussetzungen

Dieses Tutorial ist Teil derDjango Development-Serie. Um das genaue technische Setup in diesem Lernprogramm abzuschließen, sollten Sie Folgendes ausgeführt haben:

Wenn Sie jedoch bereits über ein Django-Setup verfügen, können Sie dem folgen, um besser zu verstehen, wie Sie Django-Ansichten implementieren.

[[Schritt-1 - Erstellen von Ansichtsfunktionen]] == Schritt 1 - Erstellen von Ansichtsfunktionen

In Ihrem Ubuntu-Server-Terminal müssen Sie zunächst in das entsprechende Verzeichnis wechseln und Ihre virtuelle Python-Umgebung aktivieren: 

cd ~/my_blog_app
. env/bin/activate

Nachdem Ihre virtuelle Umgebung aktiviert wurde, navigieren wir zum Verzeichnisblogsite, in dem wir eine Python-Datei öffnen und unsere erste Ansichtfunction erstellen. 

cd ~/my_blog_app/blog/blogsite

Öffnen Sie die Ansichtsdatei zum Bearbeiten mit nano oder dem Texteditor Ihrer Wahl. 

nano views.py

Beim Öffnen der Datei sollte folgender Code angezeigt werden:

/my_blog_app/blog/blogsite/views.py

from django.shortcuts import render

# Create your views here.

Wir behalten dieimport statement bei, die dierender()-Funktion aus derdjango.shortcuts-Bibliothek importieren. Mitrender() function können wir sowohl eine Vorlage als auch einen Kontext kombinieren, um das entsprechendeHttpResponse-Objekt zurückzugeben. Denken Sie daran, denn bei jeder Ansicht, die wir schreiben, sind wir dafür verantwortlich,HttpResponse zu instanziieren, zu füllen und zurückzugeben.

Als Nächstes fügen wir unsere erste Ansicht hinzu, mit der Benutzer zur Indexseite eingeladen werden. Wir importieren die FunktionHttpResponse()aus der Bibliothek von Djangohttp. Mit dieser Funktion übergeben wir Text, der angezeigt wird, wenn die Webseite angefordert wird.

~/my_blog_app/blog/blogsite/views.py

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


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

Anschließend fügen wir eine weitere Funktion hinzu, die den einzelnen Beitrag anzeigt, den wir später im Tutorial erstellen werden.

~/my_blog_app/blog/blogsite/views.py

...
def individual_post(request):
    return HttpResponse('Hi, this is where an individual post will be.')

Unsere endgültigeviews.py-Datei sieht folgendermaßen aus.

~/my_blog_app/blog/blogsite/views.py

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


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

def individual_post(request):
    return HttpResponse('Hi, this is where an individual post will be.')

Wenn Sie mit dem Bearbeiten der Datei fertig sind, müssen Sie sie speichern und beenden.

Derzeit gibt es keine festgelegte URL, auf die diese Funktionen verweisen. Daher müssen wir diese zu unseremurlpatterns-Block in unserer URL-Konfigurationsdatei hinzufügen. Fahren Sie mit den hinzugefügten Ansichten fort und ordnen Sie ihnen über diese Konfigurationsdatei URLs zu, damit wir die von uns erstellten Seiten anzeigen können.

[[Schritt 2 - Zuordnen von URLs zu Ansichten] == Schritt 2 - Zuordnen von URLs zu Ansichten

Mit Django können Benutzer relativ bequem eigene URLs für ihre App entwerfen. Dies erfolgt in reinem Python mithilfe einer Datei, die üblicherweise alsURLconf oder "URL-Konfigurationsdatei" bezeichnet wird.

Damit die Webseite angezeigt wird, muss Django zuerst das zu verwendende Root-ModulURLconfbestimmen und dann nachurlpatterns, alist data structure suchen, die alle URL-Muster enthalten. Django durchsucht dann jedes URL-Muster, bis es das erste findet, das passt. Sobald eine Übereinstimmung gefunden wurde, findet Django die zugehörige Ansicht, und diese Ansichtsfunktion empfängt Daten, die sich auf das URL-Muster und einHttpRequest-Objekt beziehen. Wenn während dieses Prozesses zu irgendeinem Zeitpunkt ein Fehler auftritt, wird stattdessen einerror-handling view angezeigt.

Öffnen Sie im Verzeichnis~/my_blog_app/blog/blogsite die Dateiurls.py - auch als URLconf-Datei bezeichnet - zum Bearbeiten. Wir werden hier nano verwenden, um die Datei zu bearbeiten. 

nano urls.py

Ändern Sie die Datei so, dass sie genau so aussieht, mit der Listeurlpatternswie unten gezeigt.

~/my_blog_app/blog/blogsite/urls.py

from django.urls import path
from . import views


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

Wenn Sie mit dem Hinzufügen der obigen Zeilen fertig sind, speichern und schließen Sie die Datei.

Sobald wir die URLconf-Datei des Verzeichnissesblogsiteaktualisiert haben, müssen wir sie jetzt in die URLconf des Verzeichnissesblogaufnehmen, da sie sonst nicht erkannt wird. Wir müssen dies tun, da es in unserer Einstellungsdatei alsROOT_URLCONF festgelegt ist. Dies bedeutet, dass Django die URLconf des Verzeichnissesblogaufurlpatterns überprüft.

Um die URLconf vonblogsitein die URLconf vonblogaufzunehmen, müssen wir zu diesem Verzeichnis navigieren. 

cd ~/my_blog_app/blog/blog

Dort können Sie die URLconf-Datei mit nano oder einem anderen Texteditor Ihrer Wahl öffnen. 

nano urls.py

In dieser Datei fügen wir die folgenden Zeilen hinzu, um die/blogsite/urls.py-Datei einzuschließen, mit der wir gerade gearbeitet haben, die in der zweiten Zeile angegeben ist.

~/my_blog_app/blog/blog/urls.py

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

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

Speichern und schließen Sie die Datei.

Öffnen wir nun einen Webbrowser, um zu den von uns erstellten URLs zu navigieren und zu überprüfen, ob sie den Text enthalten, den wir den Ansichten hinzugefügt haben. Wir müssen in das übergeordnete Verzeichnis wechseln, um auf diemanage.py-Datei zuzugreifen, die die Django-App bedient. 

cd ..

Geben Sie den folgenden Befehl ein und ersetzen Sie Ihre IP-Adresse unten. 

python manage.py runserver your-server-ip:8000

Navigieren Sie in Ihrem Webbrowser zur folgenden URL: 

your-server-ip:8000

Sie sehen eine Webseite, die wie folgt aussieht:

Django Initial Index Page

Navigieren Sie als Nächstes zur folgenden URL: 

your-server-ip:8000/post/

Von hier aus sollte Folgendes angezeigt werden:

Django Initial Post Page

Wir haben jetzt überprüft, ob die zweiurls.py-Dateien funktionieren, und die Daten zeigen uns genau, was wir erwarten würden. Fügen wir mit dieser Funktion einige echte Daten zu unserem Blog hinzu.

[[Schritt-3 - Erstellen eines Blogposts]] == Schritt 3 - Erstellen eines Blogposts

Nachdem Sie sich mit den Grundlagen von URL-Mustern und -Ansichten vertraut gemacht haben, fügen Sie einen Blog-Beitrag hinzu, der auf der Webseite anstelle des Texts angezeigt wird, den wir in die Python-Dateien fest codiert haben.

Wir erstellen einen Beitrag über die von uns erstellte Administrationsseite. Wenn Ihr Server die Django-App bedient, navigieren Sie mit einem Webbrowser zur Seite des AdministratorsBlogsiteunter: 

your-server-ip:8000/admin/blogsite/

Klicken Sie in der Benutzeroberfläche auf den Link+ Add in der ZeilePosts, um die Datenbank mit einem Beispiel-Blogbeitrag zu füllen.

Django Blogsite Admin Page

Wenn Sie auf den Link klicken, wird ein Eingabeformular angezeigt, das wie folgt aussieht:

Django Add Post Form

Wann immer Sie einen Beitrag hinzufügen möchten, rufen Sie diese Seite auf. Alternativ können Sie Beiträge mit dem LinkChangebearbeiten.

In dem Formular werden die folgenden Felder angezeigt:

Feld Inhalt

Title

Fügen Sie hier den gewünschten Titel Ihres Blogposts hinzu, z. B.My First Blog Post.

Slug

Dies bezieht sich auf den Teil einer URL, der ein gültiges Webadresselement mit lesbaren Schlüsselwörtern identifiziert. Dies wird im Allgemeinen vom Titel der Seite abgeleitet, sodass wir in diesem Fallmy-first-blog-post verwenden können.

Content

Dies ist der Hauptteil Ihres Blogposts. Wir werden zum Beispiel nurHello, World! hinzufügen, aber hier können Sie ausführlich sein.

Author

Fügen Sie in dieses Feld Ihren relevanten Namen oder Benutzernamen ein. Wir werdenSammy verwenden.

Füllen Sie das Blog-Post-Formular aus, wie Sie es für Ihre Testzwecke für angebracht halten.

Django Filled Out Blog Post Form

Nachdem Sie der Seite Beispieldaten hinzugefügt haben, klicken Sie auf die SchaltflächeSAVE. Sie erhalten die folgende Bestätigungsseite:

Django Post Submission Successful

Herzliche Glückwünsche! Du hast deinen ersten Blogbeitrag erstellt!

Vergewissern Sie sich als Nächstes, dass eine Zeile mit den Daten hinzugefügt wurde, die wir der MySQL-Datenbank hinzugefügt haben.

[[Schritt 4 - Datenbankdaten anzeigen]] == Schritt 4 - Datenbankdaten anzeigen

Zu diesem Zeitpunkt müssen wir in MySQL wechseln. Stoppen Sie also den aktuellen Serverprozess über das Terminal, indem SieCTRL + C eingeben, und öffnen Sie dann Ihren MySQL-Interpreter: 

mysql -u root

Wechseln Sie in der MySQL-Eingabeaufforderung in dieblog_data-Datenbank: 

use blog_data;

Zeigen Sie dann den Inhalt der Tabelleblogsite_postan. 

select * from blogsite_post;

Sie erhalten eine Ausgabe ähnlich der folgenden, in der die Informationen angezeigt werden sollen, die Sie der Admin-Benutzeroberfläche hinzugefügt haben. 

Output+----+--------------------+--------------------+---------------+----------------------------+--------+
| id | title              | slug               | content       | created_on                 | author |
+----+--------------------+--------------------+---------------+----------------------------+--------+
|  1 | My First Blog Post | my-first-blog-post | Hello, World! | 2018-04-24 17:10:00.139735 | Sammy  |
+----+--------------------+--------------------+---------------+----------------------------+--------+
1 row in set (0.00 sec)

Wie in der Ausgabe gezeigt, gibt es eine Zeile mit den Daten für den Beitrag, den wir hinzugefügt haben. Verweisen wir nun auf diese Daten in der Ansichtsfunktion für Posts. Verwenden SieCTRL + D, um den MySQL-Interpreter zu beenden.

Navigieren Sie zum Speicherort derviews.py-Datei in Ihrerblogsite-App. 

cd ~/my_blog_app/blog/blogsite

Öffnen Sie nun die Datei, damit wir unsere neuen Daten aufnehmen können. 

nano views.py

Bearbeiten Sie die Datei so, dass sie genau wie unten dargestellt aussieht.

~/my_blog_app/blog/blogsite

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)

Im obigen Code haben wir eine zusätzlicheimport-Anweisung fürPost hinzugefügt. Wir haben auch die Zeichenfolge in Anführungszeichen ausHttpResponse entfernt und durch die Daten aus unserem Blog-Beitrag ersetzt. Um auf Daten für ein bestimmtes Objekt zu verweisen, verwenden wir die Blogpost-ID, die dem Objekt zugeordnet ist, das wir anzeigen möchten, und speichern diese ID in einer Variablen namensrecent_post. Wir können dann bestimmte Felder dieses Objekts abrufen, indem wir das Feld mit einem Punkttrennzeichen versehen.

Navigieren Sie nach dem Speichern und Schließen der Datei zum Speicherort dermanage.py-Datei, um die Django-App auszuführen. 

cd ~/my_blog_app/blog
python manage.py runserver your-server-ip:8000/post/

Navigieren Sie in einem Webbrowser zu der folgenden Adresse: 

your-server-ip:8000/post/

Hier sehen wir die Änderungen, die wir vorgenommen haben. Die Seite sieht ähnlich aus und zeigt den Text an, den Sie dem Beitrag hinzugefügt haben.

Django Served Blog Post

Wenn Sie die Seite überprüft haben, drücken SieCTRL + C im Terminal, um den Vorgang zu stoppen.

Um Ihre Programmierumgebung zu deaktivieren, können Sie den Befehldeactivate eingeben und dann den Server beenden.

Fazit

In diesem Tutorial haben wir Ansichten erstellt, URL-Muster zugeordnet und Text auf einer Webseite aus unserer Blogpost-Datenbank angezeigt.

Im nächsten Tutorial erfahren Sie, wie Sie dies mithilfe von HTML zum Erstellen von Djangotemplates tatsächlich ästhetischer gestalten können. Bisher wurden in dieser Serie Django-Modelle und Django-Ansichten behandelt. Vorlagen sind der letzte entscheidende Teil, wenn es um die Grundlage Ihrer Django-Anwendung geht.

Related