Spletni okvir Django ima arhitekturo model-pogled-predloga (MVT), zaradi česar je edini okvir, ki ga boste potrebovali za ustvarjanje popolnega spletnega mesta ali spletne aplikacije. Ta okvir Python vam omogoča ustvarjanje modelov, ki ustvarjajo baze podatkov in upodabljajo dinamične predloge HTML v uporabniški vmesnik z uporabo pogledov.

Moč Djanga ni skrivnost; je hiter, zanesljiv, razširljiv in varen. Zanesljivost, pa tudi razširljivost te programske opreme, sta odvisna od njene arhitekture MVT. V tem članku se boste naučili natančno, kako deluje Djangov MVT arhitektura.

Kaj je Djangov model?

Model v arhitekturi Django MVT definira strukturo in obnašanje podatkov, ki jih želite shraniti na svojem spletnem mestu. Vsak model Django, ki ga ustvarite, ustvari ustrezno tabelo baze podatkov, kjer vsak atribut modela postane polje v tabeli.

Nadaljujemo z nastavitvijo iz naše uvodni članek o Djangu, lahko ustvarite model za prodajalce. Prodajalec ima lahko model prodajalca, ki vsebuje osebne podatke, kot so ime in kontaktni podatki, ter sorodni model za predmete, ki jih prodaja vsak prodajalec.

Obstoječa vzorčna struktura datoteke projekta Django

moja stran/
 moja stran/
 _pycache_
 _init_.py
 asgi.py
 settings.py
 urls.py
 wsgi.py
 prodajalci/
 migracije
 _init_.py
 admin.py
 apps.py
 modeli.py
 test.py
 views.py
 db.sqlite3
 manage.py

Ustvarjanje Django modelov

Če pogledate pod razdelek z aplikacijami prodajalcev v zgornji strukturi datotek, boste videli datoteko z imenom modeli.py. Tukaj boste ustvarili vse svoje modele Django za razdelek prodajalcev na vašem spletnem mestu. Vsak model, ki ga ustvarite, bo podrazred Djangov model API, zato je vsak Django ustvarjen modeli.py ima privzeti uvoz modelov.

Datoteka models.py

Iz uvoznih modelov django.db
# Ustvarite svoje modele tukaj.
razred Prodajalec (modeli. model):
ime = modeli. CharField (max_length=30)
priimek = modeli. CharField (max_length=30)
kontaktna številka = modeli. CharField (max_length=30)
razred Izdelek (modeli. model):
prodajalec = modeli. ForeignKey (prodajalec, on_delete=modeli. CASCADE)
ime_ artikla = modeli. CharField (maks._length=100)
količina_ artikla = modeli. IntegerField()
artikl_cena = modeli. DecimalField (največ_številk=9, decimalnih_mesti=2)
item_description = modeli. Besedilno polje()

Zgornja koda je kopija posodobljene vsebine model.py mapa. Datoteka zdaj ustvari dva modela – prodajalec in izdelek. Ti modeli imajo skupno razmerje ena proti več, kjer ima lahko en prodajalec veliko izdelkov v prodaji. Torej ima model izdelka a tuji ključ od prodajalca in an on_delete atribut nastavljen na modeli. KASKADA, kar pomeni, da ko izbrišete prodajalca, boste samodejno izbrisali vse izdelke, ki jih imajo primarni ključ kot tuji ključ.

Povezano: Naučite se Python in Django danes s temi neverjetnimi tečaji Morda boste opazili tudi, da vsak od modelov v zgornji kodi nima primarnega ključa. To je zato, ker bo Django samodejno ustvaril a primarni ključ če ga izrecno ne ustvarite.

Preden lahko uporabite kateri koli model, ki ga ustvarite, boste morali Djangu povedati, kje ga najde. Če želite to narediti, se boste morali pomakniti do settings.py in vstavite ime modula, ki vsebuje modeli.py datoteko, v INSTALLED_APP oddelek.

V vzorčnem projektu za ta članek je modeli.py datoteka je v modulu prodajalcev. Zato posodobljeno INSTALLED_APP razdelek bo glasil takole:

INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'prodajalci',
]

Z zgornjo kodo so modeli v aplikaciji prodajalcev zdaj vidni na spletnem mestu Django, zdaj pa lahko preidete na migracije.

Izvajanje migracij je pomembno, ker je ta postopek način širjenja sprememb, ki jih naredite v svojih modelih, na ustrezno shemo baze podatkov. Torej, vsakič, ko spremenite svoj model, boste morali izvesti postopek selitve, ki vključuje dva koraka.

Prvi korak je izdelava selitev, ki je ukaz, ki ustvari selitve na podlagi sprememb, odkritih v datoteki modeli.py mapa. Če želite začeti postopek selitve, boste morali odpreti terminal, se pomakniti do imenika, v katerem je vaš projekt Django, in zagnati strežnik z naslednjim ukazom:

python manage.py runserver

Ko se strežnik izvaja v enem terminalu, odprite nov terminal in vnesite naslednji ukaz:

python manage.py makemigrations

Po izvedbi bo terminal proizvedel naslednji izhod:

Migracije za 'prodajalce':
sellers\migrations\0001_initial.py
- Ustvarite model prodajalca
- Ustvari model izdelka

Zgornji rezultat jasno navaja, da imate zdaj migracije za dva modela – prodajalca in izdelek. Zdaj, če se pomaknete do mape za selitev v modulu vašega prodajalca, boste videli, da ima zdaj novo datoteko, imenovano 0001_initial.py. V tej datoteki boste našli selitve, ki ste jih pravkar ustvarili.

Datoteka 0001_initial.py

# Ustvaril Django 3.2.9 dne 26.02.2022 16:06
iz django.db uvoznih migracij, modelov
uvoz django.db.models.deletion
razred Migracije (migracije. Migracija):
začetni = res
odvisnosti = [
]
operacije = [
migracije. UstvariModel(
name='Prodajalec',
polja=[
('id', modeli. BigAutoField (auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('first_name', modeli. CharField (max_length=30)),
('priimek', modeli. CharField (max_length=30)),
('contact_number', modeli. CharField (max_length=30)),
],
),
migracije. UstvariModel(
name='Izdelek',
polja=[
('id', modeli. BigAutoField (auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('item_name', modeli. CharField (max_length=100)),
('item_qantity', modeli. IntegerField()),
('item_price', modeli. DecimalField (decimal_places=2, max_digits=9)),
('item_description', modeli. besedilno polje()),
('prodajalec', modeli. ForeignKey (on_delete=django.db.models.deletion. CASCADE, to='sellers.seller')),
],
),
]

Vsakič, ko naredite novo selitev, mapa za selitev ustvari novo različico te datoteke.

Drugi korak postopka selitve je končna selitev modelov. To pomeni, da sinhronizirate stanje baze podatkov z modeli.py datoteko z uporabo migracij, ki ste jih pravkar ustvarili v 0001_initial.py mapa. Ta postopek lahko dokončate (medtem ko strežnik še deluje) z naslednjim ukazom:

python manage.py seli

Kaj je Djangoova predloga?

Predloge so način za dinamično ustvarjanje HTML za vaš projekt Django. Vsaka Django predloga ima .html razširitev in kombinacija statične in dinamične vsebine. Predloge Django imajo edinstveno sintakso, ki vključuje nove načine ustvarjanja spremenljivk in oznak v dokumentu HTML.

Ustvarjanje Django predloge

Če želite predstaviti predloge na vzorčnem spletnem mestu e-trgovine za ta članek, boste morali ustvariti nov imenik v modulu prodajalcev. Ta novi imenik, imenovan »predloge«, bo dom vseh dokumentov HTML za aplikacijo prodajalcev – začenši z domačo stranjo.

Datoteka sellers_home.html

Dobrodošli prodajalci!

Ko ustvarite svoje predloge, jih boste morali narediti vidne Djangu tako, da dodate imenik predlog v PREDLOGE oddelek settings.py mapa. Posodobljeno PREDLOGE razdelek bo izgledal takole:

PREDLOGE = [
{
'BACKEND': 'django.template.backends.django. DjangoTemplates',
'DIRS': [
# nova koda, ki kaže na lokacijo predlog
BASE_DIR / 'prodajalci' / 'predloge'
],
'APP_DIRS': Res je,
'OPCIJE': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
]

Zdaj, ko Django ve, kje najti predloge za spletno mesto, lahko nadaljujete in jih upodabljate v uporabniški vmesnik s pogledom.

Kakšen je Djangov pogled?

Pogled je druga plast Djangove MVT arhitekture, predloga je neuporabna, razen če jo pogled upodobi v uporabniški vmesnik. Pogled je odgovoren za sprejemanje spletnih zahtev in vračanje ustreznih odgovorov (vključno s predlogami). V svoji najbolj osnovni obliki je pogled funkcija Python, shranjena v view.py datoteko vašega projekta Django.

Ustvarjanje pogleda Django

The view.py datoteka je v modulu prodajalcev vzorčnega projekta Django. Ko prodajalec obišče vaše spletno mesto, boste želeli, da obišče domačo stran prodajalca. To domačo stran boste ustvarili s predlogo HTML, podobno kot tista, ustvarjena v zgornjem razdelku s predlogami.

Datoteka view.py

iz django.shortcuts uvozi upodabljanje
def indeks (zahteva):
vrnitev (zahteva, 'sellers_home.html')

Zgornji pogled sprejme zahtevo in vrne predlogo HTML prodajalca. Torej, vsakič, ko uporabnik obišče (ali zahteva) http://127.0.0.1:8000/sellers/ videli bodo domačo stran prodajalcev. To je potem, ko ustvarite a urls.py datoteko v modulu prodajalcev.

Datoteka Sellers urls.py

s poti uvoza django.urls
od uvoz pogledov
vzorci url = [
pot('', views.index, name='index'),
]

In vključite pot do modula prodajalcev urls.py datoteko v urls.py datoteka, ki se nahaja v glavnem imeniku Django.

Datoteka spletnega mesta urls.py

od skrbnika uvoza django.contrib
iz django.url uvoz vključuje, pot
vzorci url = [
path('sellers/', include('sellers.urls')),
pot('admin/', admin.site.urls),
]

Zdaj, ko je pogled nastavljen, lahko zagotovite, da strežnik Django še vedno deluje in se pomaknete do njega http://127.0.0.1:8000/sellers/ v brskalniku, da si ogledate domačo stran prodajalcev.

Domača stran prodajalcev

Django MVT Architecture vs. MVC arhitektura

Djangova arhitektura MVT se precej razlikuje od priljubljene arhitekture MVC.

Razdelek predloge arhitekture MVT deluje na približno enak način kot pogled v arhitekturi MVC, medtem ko pogled v arhitekturi MVT prikazuje lastnosti, ki so podobne krmilniku v MVC arhitekturo. Vendar pa modela v obeh arhitekturah delujeta identično.

Uvod v arhitekturo MVC: razloženi primeri

Za takojšnje rezultate uporabite načela načrtovanja model-pogled-krmilnik za svoje programe. Tukaj je opisano, kako začeti.

Preberite Naprej

O avtorju