Django-webframeworket har en model-view-template (MVT)-arkitektur, hvilket gør det til det eneste framework, du skal bruge for at oprette en komplet hjemmeside eller webapplikation. Denne Python-ramme giver dig mulighed for at oprette modeller, der genererer databaser og gengiver dynamiske HTML-skabeloner til brugergrænsefladen ved hjælp af visninger.

Djangos kraft er ingen hemmelighed; det er hurtigt, pålideligt, skalerbart og sikkert. Pålideligheden, såvel som skalerbarheden af ​​denne software, er afhængig af dens MVT-arkitektur. Og i denne artikel lærer du præcis, hvordan Djangos MVT-arkitektur fungerer.

Hvad er Djangos model?

Modellen i Djangos MVT-arkitektur definerer strukturen og adfærden af ​​de data, du ønsker at gemme gennem din hjemmeside. Hver Django-model, du opretter, genererer en tilsvarende databasetabel, hvor hver egenskab i modellen bliver et felt i tabellen.

Fortsætter med opsætningen fra vores indledende artikel om Django, kan du oprette en model til sælgerne. En sælger kan have en sælgermodel, der har personlige oplysninger, såsom navn og kontaktoplysninger, og en relateret model for de varer, hver sælger sælger.

Den eksisterende eksempel på Django-projektfilstruktur

mit websted/
 mit websted/
 _pycache_
 _init_.py
 asgi.py
 settings.py
 urls.py
 wsgi.py
 sælgere/
 migration
 _init_.py
 admin.py
 apps.py
 models.py
 test.py
 views.py
 db.sqlite3
 manage.py

Oprettelse af Django-modeller

Hvis du ser under sælgernes app-sektion i filstrukturen ovenfor, vil du se en fil kaldet models.py. Det er her, du vil oprette alle dine Django-modeller til sælgersektionen på dit websted. Hver model, du opretter, vil være en underklasse af Django's Model API, hvilket er grunden til, at hver Django-genereret models.py filen har en standard model import.

Filen models.py

Fra django.db import modeller
# Opret dine modeller her.
klasse Sælger (modeller. Model):
fornavn = modeller. CharField (max_length=30)
efternavn = modeller. CharField (max_length=30)
kontaktnummer = modeller. CharField (max_length=30)
klasse produkt (modeller. Model):
sælger = modeller. ForeignKey (Sælger, on_delete=models. CASCADE)
item_name = modeller. CharField (max_length=100)
item_quantity = modeller. IntegerField()
item_price = modeller. Decimalfelt (max_digits=9, decimal_places=2)
item_description = modeller. Tekstfelt()

Koden ovenfor er en kopi af det opdaterede indhold af model.py fil. Filen opretter nu to modeller - Sælger og Produkt. Disse modeller deler et en-til-mange forhold, hvor én sælger kan have mange produkter på udsalg. Så produktmodellen har en fremmed nøgle fra sælger og en on_delete attribut sat til modeller. CASCADE, hvilket betyder, at når du sletter en sælger, sletter du automatisk hvert produkt, der har det primærnøgle som en fremmed nøgle.

Relaterede: Lær Python og Django i dag med disse fantastiske kurser Du bemærker måske også, at hver af modellerne i koden ovenfor ikke har en primær nøgle. Dette skyldes, at Django automatisk genererer en primærnøgle hvis du ikke udtrykkeligt opretter en.

Før du kan bruge en model, du opretter, skal du fortælle Django, hvor den kan finde den. For at gøre dette skal du navigere til settings.py fil og indsæt navnet på det modul, der indeholder models.py fil, ind i INSTALLERET_APP afsnit.

I prøveprojektet til denne artikel, models.py fil er i sælgers modul. Derfor er den opdaterede INSTALLERET_APP afsnit vil lyde som følger:

INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'sælgere',
]

Med koden ovenfor er modellerne i sælgers app nu synlige på Django-webstedet, og nu kan du gå videre til migreringer.

Det er vigtigt at udføre migreringer, fordi denne proces er en måde at sprede de ændringer, du foretager i dine modeller, til det tilsvarende databaseskema. Så hver gang du foretager ændringer i din model, skal du udføre migreringsprocessen – som involverer to trin.

Trin et er at lave migreringer, som er en kommando, der opretter migreringer baseret på de ændringer, der er registreret i models.py fil. For at starte migreringsprocessen skal du åbne din terminal, navigere til den mappe, der har dit Django-projekt, og starte serveren ved hjælp af følgende kommando:

python manage.py runserver

Med serveren kørende i en terminal skal du åbne en ny terminal og indtaste følgende kommando:

python manage.py makemigrationer

Efter udførelse vil terminalen producere følgende output:

Migrationer for 'sælgere':
sælgere\migrationer\0001_initial.py
- Opret model Sælger
- Opret modelprodukt

Outputtet ovenfor angiver tydeligt, at du nu har migreringer for to modeller - sælgeren og produktet. Hvis du nu navigerer til migreringsmappen i dit sælgers modul, vil du se, at den nu har en ny fil kaldet 0001_initial.py. I denne fil finder du de migreringer, du lige har oprettet.

Filen 0001_initial.py

# Genereret af Django 3.2.9 den 26-02-2022 16:06
fra django.db import migrationer, modeller
importere django.db.models.deletion
klasse Migration (migrationer. Migration):
initial = Sand
afhængigheder = [
]
operationer = [
migrationer. OpretModel(
name='Sælger',
felter=[
('id', modeller. BigAutoField (auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('fornavn', modeller. CharField (max_length=30)),
('efternavn', modeller. CharField (max_length=30)),
('kontaktnummer', modeller. CharField (max_length=30)),
],
),
migrationer. OpretModel(
name='Produkt',
felter=[
('id', modeller. BigAutoField (auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('varenavn', modeller. CharField (max_length=100)),
('item_quantity', modeller. IntegerField()),
('varepris', modeller. DecimalField (decimal_pladser=2, max_cifre=9)),
('item_description', modeller. Tekstfelt()),
('sælger', modeller. ForeignKey (on_delete=django.db.models.deletion. CASCADE, til='sellers.seller')),
],
),
]

Hver gang du foretager en ny migrering, genererer migreringsmappen en ny version af denne fil.

Trin to i migreringsprocessen er endelig at migrere modellerne. Det betyder, at du synkroniserer databasetilstanden med models.py fil ved hjælp af de migreringer, du lige har oprettet i 0001_initial.py fil. Du kan fuldføre denne proces (mens serveren stadig kører) med følgende kommando:

python manage.py migrere

Hvad er Djangos skabelon?

Skabeloner er en måde til dynamisk at generere HTML til dit Django-projekt. Hver Django-skabelon har .html udvidelse og en kombination af statisk og dynamisk indhold. Django-skabeloner har en unik syntaks, der inkluderer nye måder at skabe variabler og tags på i et HTML-dokument.

Oprettelse af en Django skabelon

For at introducere skabeloner i eksemplet på e-handelswebstedet for denne artikel, skal du oprette en ny mappe i sælgermodulet. Denne nye mappe kaldet "skabeloner" vil være hjemmet for alle HTML-dokumenter til sælgerens app – startende med startsiden.

sellers_home.html-filen

Velkommen sælgere!

Når du har oprettet dine skabeloner, skal du gøre dem synlige for Django ved at tilføje dine skabeloners bibliotek til Skabeloner afsnit af settings.py fil. Den opdaterede Skabeloner afsnit vil se ud som følgende:

Skabeloner = [
{
'BACKEND': 'django.template.backends.django. DjangoTemplates',
'DIRS': [
# ny kode, der peger på placeringen af ​​skabelonerne
BASE_DIR / 'sellers' / 'templates'
],
'APP_DIRS': Sandt,
'MULIGHEDER': {
'kontekstbehandlere': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
]

Nu hvor Django ved, hvor man kan finde skabelonerne til webstedet, kan du fortsætte med at gengive dem til brugergrænsefladen ved hjælp af visningen.

Hvad er Djangos syn?

Visningen er det andet lag af Djangos MVT-arkitektur, en skabelon er ubrugelig, medmindre en visning gengiver den til brugergrænsefladen. Visningen er ansvarlig for at acceptere webanmodninger og returnere passende svar (inklusive skabeloner). I sin mest grundlæggende form er visningen en Python-funktion, gemt i view.py fil af dit Django-projekt.

Oprettelse af Django View

Det view.py filen er i sælgers modul af Django-eksemplet. Når en sælger besøger dit websted, vil du have, at de går til en sælgers hjemmeside. Denne startside vil du oprette ved hjælp af en HTML-skabelon, meget som den, der er oprettet i skabelonafsnittet ovenfor.

View.py-filen

fra django.shortcuts import render
def indeks (anmodning):
returnere gengivelse (request, 'sellers_home.html')

Visningen ovenfor tager en anmodning og returnerer sælgerens HTML-skabelon. Så hver gang en bruger besøger (eller anmoder) http://127.0.0.1:8000/sellers/ de vil se sælgernes hjemmeside. Dette er efter du har oprettet en urls.py fil i sælgers modul.

Filen Sellers urls.py

fra django.urls importsti
fra. importere visninger
urlpatterns = [
sti('', views.index, navn='indeks'),
]

Og medtag stien til sælgerens modul urls.py fil i urls.py fil placeret i hovedbiblioteket til Django.

Webstedets urls.py-fil

fra django.contrib import admin
fra django.urls import inkluderer, sti
urlpatterns = [
path('sellers/', include('sellers.urls')),
sti('admin/', admin.site.urls),
]

Nu hvor visningen er sat op, kan du sikre dig, at Django-serveren stadig kører og navigere til http://127.0.0.1:8000/sellers/ i din browser for at se sælgernes hjemmeside.

Sælgers hjemmeside

Djangos MVT-arkitektur vs. MVC arkitektur

Djangos MVT-arkitektur er ret anderledes end den populære MVC-arkitektur.

Skabelonafsnittet i MVT-arkitekturen fungerer stort set på samme måde som visningen i MVC-arkitekturen, mens visningen i MVT-arkitekturen viser kvaliteter, der ligner controlleren i MVC'en arkitektur. Imidlertid fungerer modellerne i begge arkitekturer identisk.

En introduktion til MVC-arkitektur: Eksempler forklaret

Anvend Model-View-Controller-designprincipper på dine egne programmer for øjeblikkelige resultater. Sådan kommer du i gang.

Læs Næste

Om forfatteren