Django-nettrammeverket har en modell-visning-mal-arkitektur (MVT), som gjør det til det eneste rammeverket du trenger for å lage et komplett nettsted eller nettapplikasjon. Dette Python-rammeverket lar deg lage modeller som genererer databaser og gjengir dynamiske HTML-maler til brukergrensesnittet ved hjelp av visninger.

Kraften til Django er ingen hemmelighet; det er raskt, pålitelig, skalerbart og sikkert. Påliteligheten, så vel som skalerbarheten til denne programvaren, er avhengig av MVT-arkitekturen. Og i denne artikkelen vil du lære nøyaktig hvordan Djangos MVT-arkitektur fungerer.

Hva er Djangos modell?

Modellen i Djangos MVT-arkitektur definerer strukturen og oppførselen til dataene du ønsker å lagre gjennom nettstedet ditt. Hver Django-modell du oppretter genererer en tilsvarende databasetabell, hvor hvert attributt til modellen blir et felt i tabellen.

Fortsetter med oppsettet fra vår introduksjonsartikkel om Django, kan du lage en modell for selgerne. En selger kan ha en selgermodell som har personlig informasjon, for eksempel navn og kontaktinformasjon, og en relatert modell for varene hver selger selger.

Eksisterende eksempel på Django-prosjektfilstrukturen

min side/
 min side/
 _pycache_
 _init_.py
 asgi.py
 settings.py
 urls.py
 wsgi.py
 selgere/
 migrasjon
 _init_.py
 admin.py
 apps.py
 models.py
 test.py
 views.py
 db.sqlite3
 manage.py

Opprette Django-modeller

Hvis du ser under selgerens app-seksjon i filstrukturen ovenfor, vil du se en fil som heter models.py. Det er her du skal lage alle Django-modellene dine for selgers delen av nettstedet ditt. Hver modell du lager vil være en underklasse av Djangos modell API, som er grunnen til at hver Django-generert models.py filen har en standard import av modeller.

Models.py-filen

Fra django.db importmodeller
# Lag modellene dine her.
klasse Selger (modeller. Modell):
fornavn = modeller. CharField (max_length=30)
etternavn = modeller. CharField (max_length=30)
kontaktnummer = modeller. CharField (max_length=30)
klasse Produkt (modeller. Modell):
selger = modeller. ForeignKey (selger, on_delete=modeller. CASCADE)
item_name = modeller. CharField (max_length=100)
item_quantity = modeller. IntegerField()
item_price = modeller. Desimalfelt (max_digits=9, desimal_places=2)
item_description = modeller. Tekstfelt()

Koden ovenfor er en kopi av det oppdaterte innholdet i model.py fil. Filen oppretter nå to modeller – selger og produkt. Disse modellene deler et en-til-mange forhold, hvor én selger kan ha mange produkter på salg. Så produktmodellen har en fremmednøkkel fra selger og en on_delete attributt satt til modeller. CASCADE, som betyr at når du sletter en selger, vil du automatisk slette hvert produkt som har det primærnøkkel som en fremmednøkkel.

I slekt: Lær Python og Django i dag med disse fantastiske kursene Du kan også legge merke til at hver av modellene i koden ovenfor ikke har en primærnøkkel. Dette er fordi Django automatisk genererer en primærnøkkel hvis du ikke eksplisitt oppretter en.

Før du kan bruke en modell du lager, må du fortelle Django hvor den skal finne den. For å gjøre dette, må du navigere til settings.py fil og sett inn navnet på modulen som inneholder models.py fil, inn i INSTALLERT_APP seksjon.

I eksempelprosjektet for denne artikkelen er models.py filen er i selgerens modul. Derfor er den oppdaterte INSTALLERT_APP avsnittet 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',
'selgere',
]

Med koden ovenfor er modellene i selgerens app nå synlige for Django-nettstedet, og nå kan du gå videre til migreringer.

Det er viktig å gjennomføre migreringer fordi denne prosessen er en måte å spre endringene du gjør i modellene dine til det tilsvarende databaseskjemaet. Så hver gang du gjør endringer i modellen din, må du gjennomføre migreringsprosessen – som involverer to trinn.

Trinn én er å foreta migreringer, som er en kommando som oppretter migreringer basert på endringene som er oppdaget i models.py fil. For å starte migreringsprosessen, må du åpne terminalen din, navigere til katalogen som har Django-prosjektet ditt, og starte serveren ved å bruke følgende kommando:

python manage.py runserver

Med serveren som kjører i en terminal, åpne en ny terminal og skriv inn følgende kommando:

python manage.py makemigrations

Etter utførelse vil terminalen produsere følgende utgang:

Migreringer for 'selgere':
selgere\migrasjoner\0001_initial.py
- Lag modell Selger
- Lag modellprodukt

Utdataene ovenfor viser tydelig at du nå har migreringer for to modeller – selgeren og produktet. Hvis du nå navigerer til migreringsmappen i selgermodulen din, vil du se at den nå har en ny fil kalt 0001_initial.py. I denne filen finner du migreringene du nettopp opprettet.

Filen 0001_initial.py

# Generert av Django 3.2.9 på 2022-02-26 16:06
fra django.db import migreringer, modeller
import django.db.models.deletion
klasse Migrasjon (migrasjoner. Migrering):
initial = Sant
avhengigheter = [
]
operasjoner = [
migrasjoner. Opprett modell(
name='Selger',
felter=[
('id', modeller. BigAutoField (auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('first_name', modeller. CharField (max_length=30)),
('etternavn', modeller. CharField (max_length=30)),
('kontaktnummer', modeller. CharField (max_length=30)),
],
),
migrasjoner. Opprett modell(
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()),
('vare_pris', modeller. Desimalfelt (desimalplasser=2, maks_siffer=9)),
('item_description', modeller. Tekstfelt()),
('selger', modeller. ForeignKey (on_delete=django.db.models.deletion. CASCADE, til='sellers.seller')),
],
),
]

Hver gang du foretar en ny migrering, genererer migreringsmappen en ny versjon av denne filen.

Trinn to i migreringsprosessen er å til slutt migrere modellene. Dette betyr at du synkroniserer databasetilstanden med models.py fil, ved å bruke migreringene du nettopp opprettet i 0001_initial.py fil. Du kan fullføre denne prosessen (mens serveren fortsatt kjører) med følgende kommando:

python manage.py migrere

Hva er Djangos mal?

Maler er en måte å dynamisk generere HTML for ditt Django-prosjekt. Hver Django-mal har .html utvidelse og en kombinasjon av statisk og dynamisk innhold. Django-maler har en unik syntaks som inkluderer nye måter å lage variabler og tagger på i et HTML-dokument.

Opprette en Django-mal

For å introdusere maler i eksempelnettstedet for e-handel for denne artikkelen, må du opprette en ny katalog i selgermodulen. Denne nye katalogen kalt "maler" vil være hjemmet til alle HTML-dokumenter for selgerens app – fra startsiden.

sellers_home.html-filen

Velkommen selgere!

Etter at du har laget malene dine, må du gjøre dem synlige for Django ved å legge til malenes katalog i MALER delen av settings.py fil. Den oppdaterte MALER delen vil se slik ut:

MALER = [
{
'BACKEND': 'django.template.backends.django. DjangoTemplates',
'DIRS': [
# ny kode som peker til plasseringen av malene
BASE_DIR / 'selgere' / 'maler'
],
'APP_DIRS': Sant,
'ALTERNATIVER': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
]

Nå som Django vet hvor du finner malene for nettstedet, kan du gå videre og gjengi dem til brukergrensesnittet ved å bruke visningen.

Hva er Djangos syn?

Visningen er det andre laget av Djangos MVT-arkitektur, en mal er ubrukelig med mindre en visning gjengir den til brukergrensesnittet. Visningen er ansvarlig for å akseptere nettforespørsler og returnere passende svar (inkludert maler). I sin mest grunnleggende form er visningen en Python-funksjon, lagret i view.py filen til Django-prosjektet ditt.

Opprette Django View

De view.py filen er i selgermodulen til Django-eksemplet. Når en selger besøker nettstedet ditt, vil du at de skal gå til en selgers hjemmeside. Denne hjemmesiden oppretter du ved å bruke en HTML-mal, omtrent som den som ble opprettet i maldelen ovenfor.

View.py-filen

fra django.shortcuts import render
def indeks (forespørsel):
returnere gjengivelse (forespørsel, 'sellers_home.html')

Visningen ovenfor tar en forespørsel og returnerer selgerens HTML-mal. Så hver gang en bruker besøker (eller ber om) http://127.0.0.1:8000/sellers/ de vil se selgernes hjemmeside. Dette er etter at du har opprettet en urls.py fil i selgermodulen.

Sellers urls.py-filen

fra django.urls importbane
fra. importere visninger
urlpatterns = [
path('', views.index, name='index'),
]

Og ta med banen til selgerens modul urls.py fil i urls.py filen som ligger i hovedkatalogen til Django.

Nettstedets urls.py-fil

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

Nå som visningen er satt opp, kan du sikre at Django-serveren fortsatt kjører og navigere til http://127.0.0.1:8000/sellers/ i nettleseren din for å se selgernes hjemmeside.

Selgers hjemmeside

Djangos MVT-arkitektur vs. MVC arkitektur

Djangos MVT-arkitektur er ganske forskjellig fra den populære MVC-arkitekturen.

Maldelen av MVT-arkitekturen fungerer omtrent på samme måte som visningen i MVC-arkitekturen, mens visningen i MVT-arkitekturen viser kvaliteter som ligner på kontrolleren i MVC arkitektur. Imidlertid fungerer modellene i begge arkitekturene identisk.

En introduksjon til MVC-arkitektur: eksempler forklart

Bruk Model-View-Controller-designprinsipper på dine egne programmer for umiddelbare resultater. Slik kommer du i gang.

Les Neste

Om forfatteren