Entmystifizierung von Djangos Magie

Laut offizieller Dokumentation

Django ist ein High-Level-Python-Web-Framework, das eine schnelle Entwicklung und ein sauberes, pragmatisches Design fördert. Es wurde von erfahrenen Entwicklern erstellt und nimmt Ihnen einen Großteil der Webentwicklung ab, sodass Sie sich auf das Schreiben Ihrer App konzentrieren können, ohne das Rad neu erfinden zu müssen. Es ist kostenlos und Open Source.

— DjangoProject.com

Es ist eines der beliebtesten Frameworks von Python zum Erstellen von Webanwendungen und wird aufgrund seiner Skalierbarkeit beim Erstellen einer Boilerplate mit festgelegten Konfigurationen und Dateien am meisten bevorzugt. Damit ist das ganze Ziel von Django für Entwickler abgeschlossen;

„... eine großartige Anwendung in kurzer Zeit zu erstellen und sich weniger Gedanken über die Grundeinstellungen zu machen.“

Es gibt grundlegende Konfigurationen, Dateien und Stile, die sich über alle Webanwendungen erstrecken, egal was Sie erstellen. Wenn Sie Django verwenden, werden diese automatisch für Sie generiert, wenn Sie bestimmte Befehle zu verschiedenen Zeitpunkten im Entwicklungszyklus Ihrer Anwendung ausführen. Damit haben Sie genügend Zeit, sich auf den Kernaspekt Ihrer Anwendungsentwicklung zu konzentrieren, während Django die anderen für Sie erledigt.

Das bedeutet, dass unter der Haube viel passiert. Für jemanden, der die beweglichen Teile nicht vollständig versteht, kann dies überwältigend sein. In diesem Artikel werden wir Folgendes lernen:

• Installation von Django
• Die Befehle startproject und startapp
• Django-Konfigurationsdateien, die Folgendes enthalten:
• settings.py
• urls.py
• manage.py
• Modelle-Layout
• Routing

Wir werden lernen, wie diese alle zusammenpassen und welche Rolle sie spielen. Es ist wichtig zu wissen, dass es nicht möglich sein wird, einen Blick auf alles zu werfen, was innerhalb von Django passiert. Für Fälle, die nicht Gegenstand dieses Tutorials sind, gibt es Links, die Sie auf Ressourcen verweisen, die Ihnen dabei helfen.

Zu Lernzwecken werden wir eine E-Commerce-Plattform aufbauen. Dies ist keine vollständige E-Commerce-Site, unsere Anwendung wird nur zwei grundlegende Funktionen haben; Erstellen von Produkten und Aufgeben von Bestellungen aus der Sicht des Administrators.

Dieser Artikel führt Sie durch das Verständnis der vorgefertigten Befehle, Dateien und Grundlagen von Django. Es richtet sich an Entwickler, die Django verwendet haben oder beabsichtigen, es zu verwenden, und wissen möchten, was unter der Haube passiert. Es ist zwar nicht zwingend erforderlich, dass Sie Django verwendet haben, aber Erfahrung mit den Grundlagen von Django, bevor Sie mit diesem Artikel fortfahren, wird Ihnen einen Vorteil verschaffen. Sie müssen über praktische Python-Kenntnisse verfügen, um vollständig zu verstehen, was in diesem Stück behandelt wird.

Django installieren

Wenn Sie Django noch nicht installiert haben, gehen Sie wie folgt vor.

Erstellen Sie zunächst eine virtuelle Umgebung mit dem Namen djangodev . Sie benötigen dies, um Ihren Django-Arbeitsbereich und seine abhängigen Pakete zu isolieren.

 python3 -m venv ~/.virtualenvs/djangodev

Um nun in Ihre virtuelle Umgebung zu gelangen, müssen Sie sie aktivieren;

 source ~/.virtualenvs/djangodev/bin/activate

Wenn Sie einen Fehler erhalten, der mit source ausgeführt wird, können Sie diesen alternativen Befehl verwenden,

 . ~/.virtualenvs/djangodev/bin/activate

Verwenden Sie für Windows-Benutzer stattdessen dies,

 ...\> %HOMEPATH%\.virtualenvs\djangodev\Scripts\activate.bat

Hinweis: Sie müssen die virtuelle Umgebung jedes Mal aktivieren, wenn Sie Django verwenden möchten.

Jetzt, da Sie sich in Ihrer virtuellen Umgebung befinden, installieren Sie Django:

 python -m pip install Django

Um zu überprüfen, ob Django richtig installiert wurde, führen Sie Folgendes aus:

 python -m django --version

Shakaboom! Jetzt bist du bereit für etwas Magie, halte deine Zauberstäbe bereit!

Die Methode zum Erstellen von Dateien und Ordnern unterwegs kann einfach und unkompliziert sein. Es ist jedoch nicht ideal, wenn Sie ein mittleres oder großes Projekt erstellen und eine Frist einhalten müssen. Wir haben immer eine Frist zu schlagen, auch für persönliche Projekte.

Wenn Sie dieser Methode folgen, müssen Sie beim Erstellen eines neuen großen Projekts mehrere Dateien und Ordner erstellen und mehrere Einstellungen vornehmen, was zu vermeidbaren Fehlern und viel Zeitverschwendung führen kann. Die Befehle startproject und startapp , die uns über Django zur Verfügung stehen, zielen darauf ab, dieses Problem zu lösen. Diese beiden Befehle erstellen Dateien, Ordner und nehmen viele Konfigurationen für Sie vor.

Beginnen wir mit dem Generieren einer neuen Anwendung mit dem Befehl startproject .

Gerüstbau Eine Anwendung

Wir generieren unsere Anwendung und sehen uns die generierten Dateien sowie einige Befehle an, die wir verwenden werden. Führen Sie diesen Befehl in Ihrem Terminal aus, um loszulegen.

 django-admin startproject ecommerce_site

Bei der Installation von Django wird django-admin zu Ihrem Pfad hinzugefügt, um ihm Zugriff zum Ausführen seiner Aktionen zu gewähren. Es ist das Befehlszeilendienstprogramm von Django für administrative Aufgaben. Erfahren Sie hier mehr über die Verwendung von django-admin ; es würde den Rahmen dieses Artikels ein wenig sprengen.

startproject ist ein Django-Befehl, der beim Generieren des Projekts hilft. Hier übergeben wir den Namen unseres Projekts ecommerce_site . Anschließend wird das Projekt in einem Verzeichnis namens ecommerce_site erstellt. Das Verzeichnis sollte so aussehen,

Wir müssen in das neu erstellte Verzeichnis navigieren und den Befehl ausführen, um die App zu generieren .

 cd ecommerce_site python manage.py startapp trading

startapp ist ein Befehl, der von manage.py im Projektverzeichnis ausgeführt wird, er erstellt mehrere Dateien und einen Ordner, der nach dem im Befehl angegebenen Namen benannt ist, in diesem Fall ist das, was angegeben ist trading . Der App-Ordner besteht aus einfachen Dateien, die zum Erstellen von Funktionen einer Anwendung benötigt werden. Jetzt sollte Ihr Verzeichnis so aussehen:

Wenn Sie sich fragen, was der Unterschied zwischen einem Projekt und einer App ist. Ein Projekt ist eine Django-Webanwendung, die aus einer oder mehreren Apps bestehen kann. Es ist der Ordner, der manage.py und das andere Modul enthält, das die settings.py und andere Dateien enthält. Eine App ist ein Python-Paket, das eine bestimmte Funktion ausführt, Dateien wie models.py , das Migrationsverzeichnis und mehr enthält. Weitere Informationen finden Sie in dieser Antwort auf Stack Overflow.

Das startproject erstellt das Hauptprojektverzeichnis, während die startapp das App-Verzeichnis erstellt. Beiden wird auch ein Name übergeben, der bei der Generierung verwendet werden soll. Das startproject ist der erste Befehl, der beim Erstellen eines neuen Projekts ausgeführt wird, während die startapp innerhalb des neuen Projektverzeichnisses ausgeführt wird.

Das aktuelle Layout ist eine großartige Zuordnung, die Sie für jede Anwendung verwenden können, die Sie erstellen. Es ist skalierbar und besteht aus Dateien, die Sie benötigen. Es besteht die Möglichkeit, Dateien innerhalb des Projekts zu erstellen, umzubenennen, zu bearbeiten und zu verschieben.

Djangos Konfiguration

Django bietet verschiedene Einstellungen und Konfigurationen für Sie. Nachdem Sie die beiden Befehle in verschiedenen Dateien ausgeführt haben, lassen Sie uns die generierten Dateien durchgehen, um zu erfahren, was die einzelnen Befehle tun.

settings.py

Die meisten Webanwendungen benötigen Konfigurationen wie; Authentifizierung, um Benutzer zu verifizieren, Berechtigungen, um bestimmte Benutzer mit bestimmten Fähigkeiten zuzulassen und Sicherheitsstandards festzulegen. All dies ist erforderlich, um Ihren Benutzern die bestmögliche Erfahrung zu bieten. Es wird lange dauern, bis Sie als Entwickler damit beginnen, diese für jede Anwendung, an der Sie arbeiten, selbst umzusetzen.

Django bietet Ihnen diese erforderlichen Konfigurationen und mehr – so dass Sie sich für die gewünschten Konfigurationen entscheiden und diese anschließen können. Diese werden in settings.py , es gibt bereits festgelegte Einstellungen, die erstellt wurden, um grundlegende Funktionen für Sie bereitzustellen.

Wenn Django versucht, ein Projekt auszuführen, sucht es nach bestimmten Variablen. Die settings.py ist die Datei, die jene Variablen enthält, die zu anderen Dateien oder Informationen führen. Django wird von der Datei manage.py zu dieser Datei geleitet und nimmt Informationen oder lädt andere Dateien, zu denen es von hier geführt wird.

Diese Konfigurationen umfassen:

• DEBUG
  Die DEBUG -Funktionalität ist auf True gesetzt, um das Lesen von Fehlern und das Debuggen von Code in der Entwicklung zu ermöglichen, sie sollte während der Produktion (dh bei der Bereitstellung) auf False gesetzt werden. Mit dieser Einstellung können Sie Ihren Code mithilfe von Django besser debuggen, wenn es versucht, Ihren Code auszuführen.
• INSTALLED_APPS
  Dies ist eine Liste aller Apps, die eine bestimmte Funktion in Django ausführen. Es enthält einige Standard-Apps wie 'django.contrib.auth' , die für die Benutzerauthentifizierung verwendet werden, django.contrib.admin' für die Admin-Funktionalität und 'django.contrib.messages' die zum Senden von Benachrichtigungen oder Informationen an Benutzer benötigt werden. Jede andere App, die Sie mit dem Befehl startapp erstellen, muss sich hier befinden, bevor sie von Django ausgeführt werden kann.
• MIDDLEWARE ist ein leichtgewichtiges Framework für die Verarbeitung von Eingaben und Ausgaben, die Django-Anforderungen und -Antworten durchlaufen. Jede Middleware führt eine bestimmte Funktion mit einer App aus, so wie die 'django.contrib.auth.middleware.AuthenticationMiddleware' mit 'django.contrib.sessions' , um Benutzer Anfragen zuzuordnen. Sie sollten sich weitere Funktionen jeder Middleware in der Dokumentation ansehen.
• ROOT_URLCONF ist eine Variable zu einem Pfad, in dem Django nach Ihren urlpatterns sucht, wenn eine Anfrage an Ihre Django-Anwendung übergeben wird. Immer wenn eine Anfrage in einer Django-Anwendung gestellt wird, durchsucht Django diese Variable und lädt die führende Datei und durchläuft die URL- urlpatterns auf der Suche nach dem passenden Pfad.
• TEMPLATES ist eine Einstellung, die das Rendern von HTML-Dateien zur Darstellung einer Ansicht ermöglicht. Es kommuniziert mit den Request-, Authentifizierungs- und Nachrichten-Apps. Der Wert 'BACKEND' und die 'APP_DIRS' auf „ True “ ermöglichen es Django, im Ordner „ /templates “ nach HTML-Dateien zu suchen. Die 'context_processors' in den OPTIONS sind Callables , die die Anfrage als Argument aufnehmen und mit dem Kontext zusammenführen, wenn eine Vorlage gerendert wird, diese Callables helfen beim Debuggen, Authentifizieren und Bearbeiten von Anfragen im Allgemeinen.
• WSGI_APPLICATION ist ein Pfad, der zu der application in der Datei wsgi.py .
• DATABASE ist ein Wörterbuch, das Zugriff auf eine externe Datenbank (oder interne wie im Fall des Standard-SQLite) wie PostgresSQL, MySQL und MongoDB enthält. Hier ist ein Beispiel für eine Postgres-Datenbank, die ich für unser Beispiel verwenden werde:

 DATABASES = { 'default': { 'ENGINE': 'django.db.backends.postgresql_psycopg2', 'NAME': 'db_name', 'USER': 'db_user', 'PASSWORD': 'db_password', 'HOST': 'localhost', 'PORT': '', } }

Sie können sich entscheiden, die standardmäßige SQLite-Datenbank zu verwenden, dies funktioniert nicht gut für die Produktion. Sie können eine Postgres-Datenbank wie oben einrichten, Sie müssen zuerst die Datenbank erstellen und den Benutzer, das Passwort mit Schreibberechtigung an die Datenbank übergeben.

Hinweis : Für die Zwecke dieses Lernprogramms können Sie bereits den standardmäßigen SQLite-Datenbanksatz verwenden. Das Obige ist eine Demonstration, wie Sie eine SQL- und NO-SQL-Datenbankverbindung in Django einrichten können.

• AUTH_PASSWORD_VALIDATORS Dies sind Funktionen, die für Passwortvalidierungen aufgerufen werden. Sie werden beim Erstellen von Datensätzen für Benutzer (und auch Administratoren), beim Zurücksetzen und Ändern von Passwörtern aufgerufen. Sie können mehr darüber in der offiziellen Dokumentation erfahren.

Weitere Dokumentation zu den Einstellungen finden Sie hier.

manage.py

Die meisten Webprojekte benötigen einen Einstiegspunkt, an dem Befehle beginnen. Ein Einstiegspunkt, der als Gateway in die Anwendung fungiert. In jedem Django-Projekt ist dies normalerweise die Datei manage.py .

Diese Datei wird als Ausgangspunkt in Ihrer Anwendung benötigt. Von hier aus werden alle Befehle ausgeführt und alles beginnt hier.

manage.py hat dieselbe Funktion wie django-admin. Es teilt Django auch den Speicherort für die Konfigurationen mit, die Sie in Ihrer Anwendung haben. Dies ist standardmäßig eingestellt und muss nicht geändert werden.

Es verwendet die Funktion def main() , um das Standardeinstellungsmodul für unsere Datei settings.py zu handhaben. Es versucht, die Ausführungsfunktion zu importieren, und wenn ein Fehler auftritt, wird der ImportError . Andernfalls übernimmt es das Argument, das von sys.argv von der Befehlszeile übergeben wird, und wird ausgeführt.

sys.argv ist eine Liste, die den über das Terminal übergebenen Befehl aufnimmt. Wenn wir python manage.py runserver in der Befehlszeile ausführen, wird sys.argv auf ["manage.py", "runserver"] und dies wird an die execute execute() Funktion übergeben.

Argumente wie python manage.py startapp trading oder python manage.py makemigrations werden zur Ausführung jeweils auf [ "manage.py", "startapp", "trading"] und ["manage.py", "makemigrations"] .

Die if-Anweisung wird ausgeführt, wenn der angegebene Befehl auf manage.py .

Abgesehen von der Ausführung von django-admin Funktionen werden Sie es zum Ausführen von Servern verwenden, Migrationen handhaben und andere Befehle verwenden, die Ihr Projekt verwenden wird. Sie benötigen es auch beim Bereitstellen, Testen und Debuggen Ihrer Projekte.

Modelllayout

Django stellt Ihnen ein einfaches Modellierungslayout zur Verfügung. Sie konfigurieren Ihre Modelle in der Datei models.py im trading . Ihre Klassen (oder Modelle) sind Layouts, denen Ihre Datenbanktabellen folgen werden.

Sie definieren Ihre Klassen basierend auf den Datentypen, die Sie vom Benutzer (oder dem Administrator) für jede Tabelle erhalten möchten. Unsere Modelle erstellen eine Migrationsdatei, die mit der DATABASE -Variablen in der settings.py funktioniert.

Lassen Sie uns zwei Modelle erstellen, die wir für Produkte und Bestellungen benötigen:

 from django.db import models class Product(models.Model): name = models.CharField(max_length=50) image = models.ImageField(upload_to='products', default='python.png') price = models.IntegerField() description = models.TextField() def __str__(self): return self.name class Order(models.Model): product = models.ForeignKey(Product, on_delete=models.CASCADE) quantity = models.IntegerField() date = models.DateField(auto_now_add=True) user = models.CharField(max_length=50) def __str__(self): return self.user

Das Produktmodell hat einen Namen, einen Preis, eine Beschreibung und ein Bild (das beim Speichern in einen Produktordner hochgeladen products . Dieser wird erstellt, wenn der Ordner nicht vorhanden ist). Die order hat ein product (verknüpft products der Produkttabelle), die Spalten Menge, Datum und Benutzer.

Mit diesen Informationen erstellt Django ein Datenbankschema für die App. Erstellt außerdem eine Python-Datenbankzugriffs-API für den Zugriff auf Produkt- und Auftragsobjekte. Django verfügt über ein integriertes Migrationstool, sodass Sie keine externen Pakete für Migrationen verwenden müssen.

Der nächste Schritt besteht darin, den Migrationsbefehl auszuführen und zur Datenbank zu migrieren. Aber bevor wir das tun, müssen wir den trading als App in unserem Projektverzeichnis registrieren.

Zunächst müssen wir das Handelsverzeichnis als App in Django konfigurieren. Django erledigt das für Sie in der Datei app.py Diese Datei registriert den trading als App und wird in der Datei settings.py weiterverwendet.

Fügen Sie nun in settings.py den trading in INSTALLED_APP . Es sollte so aussehen:

 INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'trading.apps.TradingConf', ]

Führen Sie auf dem Terminal Folgendes aus:

 $ python manage.py makemigrations trading $ python manage.py migrate

Hinweis: Ihre virtuelle Umgebung muss aktiviert sein und Sie sollten sich im Projektverzeichnis befinden.

python manage.py makemigrations trading nimmt Änderungen im Handelsmodul zur Kenntnis und erstellt eine Datei im migration der Änderungen in models.py und python manage.py migrate und aktualisiert dann die Änderungen.

Sie finden die generierte Migrationsdatei aus dem python manage.py makemigrations trading im migration mit dem Namen 0001_initial.py . Sie können die Klassen und Spalten als Befehle zum Erstellen in der Datei sehen. Je mehr Änderungen in models.py vorgenommen werden, desto mehr Dateien werden hier generiert.

Admin-Funktionen

In unserer aktuellen Anwendung benötigen wir Administratorfunktionen, um die Produkte und Bestellungen zu verwalten, die in der Anwendung erstellt werden. Django stellt uns bereits eine eingebaute Admin-Funktionalität zur Verfügung. Die Admin-App (Funktion) wurde auch in unserer INSTALLED_APP Liste registriert; 'django.contrib.admin' .

Außerdem wurde die URL für den Administrator auch in der urlpatterns Liste unserer URL-Konfigurationsdatei urls.py ; path('admin/', admin.site.urls), . Die Datei admin.py ermöglicht es Ihnen, Modelle und die CRUD-Aktionen zu registrieren, die an den Modellen ausgeführt werden sollen.

Um den Admin einzurichten, führen Sie dies auf dem Terminal aus:

 $ python manage.py createsuperuser

Sie werden aufgefordert, einen Benutzernamen, eine E-Mail-Adresse und ein Passwort einzugeben. Danach haben Sie erfolgreich einen Administrator erstellt. Führen Sie den Server aus, um mit der Administratorfunktion zu beginnen:

 $ python manage.py runserver

Der Besuch von https://127.0.0.1:8000/admin/ führt zu einer Anmeldesitzung, wenn Sie sich anmelden (mit dem von Ihnen erstellten Benutzernamen und Passwort) werden Sie zum Admin-Dashboard weitergeleitet:

Die Gruppen und Benutzer sind Standardkonfigurationen, die dem Administrator den Zugriff auf die Benutzerverwaltung und -berechtigung ermöglichen. Lassen Sie uns jetzt unsere Modelle registrieren.

Fügen Sie in der admin.py die folgenden Zeilen hinzu:

 from django.contrib import admin # Register your models here. from .models import Product, Order admin.site.register(Product) admin.site.register(Order)

from django.contrib import admin importiert die Admin-Funktionalität aus Django, und dann importierten wir die beiden Klassen aus unserer models.py und registrierten sie, damit ein Administrator CRUD-Aktionen für Produkte ausführen und vom Dashboard aus bestellen kann.

Nach der Registrierung der Modelle sollte Ihr Dashboard so aussehen:

Produkte hinzufügen:

Bestellungen über das Admin-Dashboard tätigen:

Einfaches Routing

Jede Website benötigt Routen oder URLs, die zu bestimmten Seiten mit bestimmten Informationen für den Endbenutzer führen. Auf Sammlungen ähnlicher Informationen oder Anwendungen wird auf einem bestimmten Weg zugegriffen. Es besteht die Notwendigkeit, Routen für die Zugänglichkeit und Kommunikation innerhalb von Dateien zu gruppieren. Django erledigt das für Sie in der Datei urls.py

Die urls.py ist eine Datei, die von der ROOT_CONF Variablen in der settings.py ausgeht. Hier wird unsere Haupt-URL-Konfiguration durchgeführt. Wenn wir Ansichten in verschiedenen Dateien oder Ordnern oder sogar in der Datei urls.py erstellen, müssen sie in der Liste der urlpatterns -Muster konfiguriert werden.

Django erwartet eine Liste namens urlpatterns in der Datei. Sie können die Datei in der ROOT_CONF Variablen in jede andere Datei ändern, die Sie in die URL- urlpatterns .

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

Die Liste besteht aus Objekten, die Instanzen von path oder re-path sind. Jede Instanz hat zwei obligatorische Parameter, das Muster 'admin/' und eine Ansichts- oder URL-Datei, admin.site.urls .

Die Instanzen könnten auch zu einer anderen Datei mit mehr URL-Konfigurationen führen. Dies geschieht aus Gründen der Lesbarkeit.

views.py

Ein wichtiger Bedarf für eine Backend-Anwendung sind die Ansichten, denen jede Route zugeordnet ist. In Django schreiben Sie Ihre funktions- oder klassenbasierten Ansichten für eine App in die Datei views.py . Eine Ansicht ist eine Klasse oder Funktion, die eine Anfrage verarbeitet und eine Antwort an Ihren Benutzer zurücksendet.

Bearbeiten Sie Ihre Datei views.py wie folgt:

 from django.http import HttpResponse def home(request): return HttpResponse("This is a shopping site for products") def order(request): return HttpResponse("Hello, welcome to our store, browse to our products and order!")

Hier haben wir HTTPResponse importiert, um es beim Definieren von zwei Ansichten (Funktionsansichten) zu verwenden, um bei Aufruf einen Satz zurückzugeben. def home sollte aufgerufen werden, wenn Sie die primäre Adresse besuchen, und def order wenn Sie auf die Bestell-URL zugreifen.

Nachdem wir unsere Ansichten erstellt haben, müssen wir sie verschiedenen Routen (oder urlpatterns ) zuweisen. Dies kann auf verschiedene Arten erfolgen, wir können eine URL- urlpatterns in derselben Datei erstellen oder wir könnten trading.views in die Datei ecommerce_site.urls importieren und den Pfad erstellen.

Der bevorzugte Weg, dies zu tun, ist das Erstellen einer Sub-URL-Konfigurationsdatei (innerhalb des trading ) und deren Einbindung in ecommerce_site.urls . Erstellen Sie eine urls.py -Datei im trading . Ihr Verzeichnis sollte folgendermaßen aussehen:

 trading/ __init__.py admin.py apps.py migrations/ __init__.py 0001_initial.py models.py tests.py urls.py views.py

Fügen Sie Ihrer neuen Datei ( urls.py ) den folgenden Code hinzu

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

Lassen Sie uns die trading -URL-Konfigurationsdatei ( urls.py ) in der Projekt-URL-Konfigurationsdatei registrieren,

 from django.contrib import admin from django.urls import include, path urlpatterns = [ path('admin/', admin.site.urls), path('', include('trading.urls')) ]

Um auf die URL-Muster zugreifen zu können, verwenden wir in Zeile 2 die Klasse include aus urlpatterns . django.urls dann ein Muster aus und hängen Sie die Datei urls.py im Handelsverzeichnis an.

Was wir hier getan haben, war, die path von Django und die Datei views.py zu importieren. Dann besteht unsere Liste aus zwei Pfadinstanzen für jede Ansicht. Also wird def home auf https://127.0.0.1:8000/ aufgerufen.

Und def order wird auf https://127.0.0.1:8000/order/ aufgerufen.

Hinweis: Das Ausführen von startproject und startapp ist nicht obligatorisch, wird aber von Django dringend empfohlen. Und Sie können Dateien und Ordner erstellen/verschieben, nachdem Sie jeden Befehl zu Ihrer Arbeitserleichterung ausgeführt haben.

Abhängigkeitsbaum

Hier ist der Prozess, in dem Django Anfragen von eingehenden URLs verarbeitet:

1. Django sucht nach dem Stammverzeichnis (Pfad) für Ihre URLs in der Variable ROOT_CONF .
2. Django lädt die im angegebenen Pfad angegebene Python-Datei. Und sucht die Variable urlpatterns , dies ist eine Liste, die alle Instanzen von django.urls.path() und/oder django.urls.re_path() .
3. In der Liste geht Django der Reihe nach vor und sucht nach einer passenden URL.
4. Python importiert und ruft die Ansicht auf (entweder funktionsbasierte oder klassenbasierte Ansicht). Was mit dem HTTP-Request weitergereicht wird.
5. Die Ansicht verarbeitet die Anforderung und die übergebenen Informationen und gibt entweder eine Nachricht/Vorlage zurück oder leitet zu einer anderen Ansicht weiter.
6. Wenn kein URL-Muster übereinstimmt oder wenn während dieses Prozesses eine Ausnahme ausgelöst wird, ruft Django eine entsprechende Ansicht zur Fehlerbehandlung auf.

Fazit

Wir haben von der Möglichkeit erfahren, Dateien für Django ohne die Kommandozeile zu erstellen. Außerdem haben wir die Vorteile und den Baustein eines Django-Projekts kennengelernt. Django ist ein erstaunliches Tool zum Erstellen von Backend-Projekten mit dem Ziel, Einfachheit zu schaffen.

Sie können sich den Code für dieses Tutorial auf GitHub ansehen.

Ressourcen

• Passwortverwaltung in Django
• Django: Erste Schritte
• Django: Einstellungen
• Leichter Django von O'Reilly