Cadrul web Django are o arhitectură model-view-template (MVT), ceea ce îl face singurul cadru de care veți avea nevoie pentru a crea un site web complet sau o aplicație web. Acest cadru Python vă permite să creați modele care generează baze de date și redă șabloane HTML dinamice în interfața de utilizare folosind vizualizări.

Puterea lui Django nu este un secret; este rapid, fiabil, scalabil și sigur. Fiabilitatea, precum și scalabilitatea acestui software se bazează pe arhitectura sa MVT. Și în acest articol, veți afla exact cum funcționează arhitectura MVT a lui Django.

Care este modelul lui Django?

Modelul din arhitectura MVT a lui Django definește structura și comportamentul datelor pe care doriți să le stocați prin site-ul dvs. Fiecare model Django pe care îl creați generează un tabel de bază de date corespunzător, în care fiecare atribut al modelului devine un câmp în tabel.

Continuând cu configurarea de la nostru articol introductiv despre Django, puteți crea un model pentru vânzători. Un vânzător poate avea un model de vânzător care are informații personale, cum ar fi un nume și detalii de contact și un model asociat pentru articolele pe care le vinde fiecare vânzător.

Exemplu existent de structură a fișierelor de proiect Django

site-ul meu/
 site-ul meu/
 _pycache_
 _init_.py
 asgi.py
 setări.py
 urls.py
 wsgi.py
 vanzatori/
 migrație
 _init_.py
 admin.py
 apps.py
 modele.py
 test.py
 vederi.py
 db.sqlite3
 gestionează.py

Crearea modelelor Django

Dacă te uiți în secțiunea aplicației vânzătorilor din structura fișierului de mai sus, vei vedea un fișier numit modele.py. Aici veți crea toate modelele Django pentru secțiunea de vânzători a site-ului dvs. web. Fiecare model pe care îl creați va fi o subclasă Modelul API al lui Django, motiv pentru care fiecare Django-generat modele.py fișierul are un import implicit de modele.

Fișierul models.py

Din modelele de import django.db
# Creați-vă modelele aici.
clasa Vânzător (modele. Model):
prenume = modele. CharField (lungime_max=30)
prenume = modele. CharField (lungime_max=30)
contact_number = modele. CharField (lungime_max=30)
clasa Produs (modele. Model):
vânzător = modele. ForeignKey (Vânzător, on_delete=modele. CASCADĂ)
item_name = modele. CharField (lungime_max.=100)
item_qantity = modele. IntegerField()
item_price = modele. DecimalField (max_digits=9, decimal_places=2)
item_description = modele. TextField()

Codul de mai sus este o copie a conținutului actualizat al fișierului model.py fişier. Fișierul creează acum două modele — Vânzător și Produs. Aceste modele împărtășesc o relație unu-la-mulți, în care un vânzător poate avea multe produse la vânzare. Deci, modelul de produs are un cheie externă de la vânzător și an on_delete atribut setat la modele. CASCADĂ, ceea ce înseamnă că atunci când ștergeți un vânzător, veți șterge automat fiecare produs care are acesta cheia principala ca cheie externă.

Legate de: Învață Python și Django astăzi cu aceste cursuri uimitoare De asemenea, puteți observa că fiecare dintre modelele din codul de mai sus nu are o cheie primară. Acest lucru se datorează faptului că Django va genera automat un cheia principala dacă nu creați unul în mod explicit.

Înainte de a putea folosi orice model pe care îl creați, va trebui să spuneți lui Django unde să-l găsească. Pentru a face acest lucru, va trebui să navigați la setări.py fișier și introduceți numele modulului care conține fișierul modele.py fișier, în INSTALLED_APP secțiune.

În exemplul de proiect pentru acest articol, modele.py fișierul se află în modulul vânzătorilor. Prin urmare, actualizat INSTALLED_APP secțiunea se va citi după cum urmează:

INSTALLED_APPS = [
„django.contrib.admin”,
„django.contrib.auth”,
„django.contrib.contenttypes”,
„django.contrib.sessions”,
„django.contrib.messages”,
„django.contrib.staticfiles”,
"vanzatori",
]

Cu codul de mai sus, modelele din aplicația vânzătorilor sunt acum vizibile pe site-ul web Django, iar acum puteți trece la migrare.

Efectuarea migrărilor este importantă deoarece acest proces este o modalitate de a răspândi modificările pe care le faceți în modelele dvs. la schema de bază de date corespunzătoare. Deci, de fiecare dată când modificați modelul dvs., va trebui să efectuați procesul de migrare, care implică doi pași.

Pasul unu este să faceți migrații, care este o comandă care creează migrari pe baza modificărilor detectate în modele.py fişier. Pentru a începe procesul de migrare, va trebui să deschideți terminalul, să navigați la directorul care conține proiectul dvs. Django și să lansați serverul utilizând următoarea comandă:

python manage.py runserver

Cu serverul rulând într-un terminal, deschideți un nou terminal și introduceți următoarea comandă:

python manage.py makemigrations

După execuție, terminalul va produce următoarea ieșire:

Migrații pentru „vânzători”:
sellers\migrations\0001_initial.py
- Creați model Vânzător
- Creați model de produs

Rezultatul de mai sus arată clar că acum aveți migrații pentru două modele — vânzătorul și produsul. Acum, dacă navigați la folderul de migrare din modulul vânzătorilor, veți vedea că acum are un fișier nou numit 0001_initial.py. În acest fișier, veți găsi migrațiile pe care tocmai le-ați creat.

Fișierul 0001_initial.py

# Generat de Django 3.2.9 pe 2022-02-26 16:06
din django.db import migrații, modele
import django.db.models.deletion
Migrație de clasă (migrații. Migrație):
initial = Adevarat
dependențe = [
]
operațiuni = [
migraţiile. CreateModel(
nume='Vânzător',
câmpuri=[
(„id”, modele. BigAutoField (auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
(„prenume”, modele. CharField (lungime_max=30)),
(„nume”, modele. CharField (lungime_max=30)),
('număr_de_contact', modele. CharField (lungime_max=30)),
],
),
migraţiile. CreateModel(
name='Produs',
câmpuri=[
(„id”, modele. BigAutoField (auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
(„nume_articol”, modele. CharField (lungime_max.=100)),
('item_qantity', modele. IntegerField()),
('preț_articol', modele. DecimalField (decimal_places=2, max_digits=9)),
(„descrierea_articolului”, modele. TextField()),
(„vânzător”, modele. ForeignKey (on_delete=django.db.models.deletion. CASCADE, to='sellers.seller')),
],
),
]

De fiecare dată când faceți o nouă migrare, folderul de migrare generează o nouă versiune a acestui fișier.

Pasul doi al procesului de migrare este migrarea modelelor. Aceasta înseamnă că sincronizați starea bazei de date cu modele.py fișier, folosind migrațiile pe care tocmai le-ați creat în fișierul 0001_initial.py fişier. Puteți finaliza acest proces (în timp ce serverul încă rulează) cu următoarea comandă:

python manage.py migrate

Ce este șablonul lui Django?

Șabloanele sunt o modalitate de a genera în mod dinamic HTML pentru proiectul dvs. Django. Fiecare șablon Django are .html extensie și o combinație de conținut static și dinamic. Șabloanele Django au o sintaxă unică care include noi moduri de a crea variabile și etichete într-un document HTML.

Crearea unui șablon Django

Pentru a introduce șabloane în exemplul de site de comerț electronic pentru acest articol, va trebui să creați un nou director în modulul vânzătorilor. Acest nou director numit „șabloane” va fi principala tuturor documentelor HTML pentru aplicația vânzătorilor, începând cu pagina de pornire.

Fișierul sellers_home.html

Bine ați venit vânzătorilor!

După ce ați creat șabloanele dvs., va trebui să le faceți vizibile pentru Django adăugând directorul șabloanelor dvs. la ȘABLONE sectiunea a setări.py fişier. Actualizat ȘABLONE secțiunea va arăta astfel:

ȘABLONE = [
{
„BACKEND”: „django.template.backends.django. DjangoTemplates',
„DIRS”: [
# cod nou care indică locația șabloanelor
BASE_DIR / 'vânzători' / 'şabloane'
],
„APP_DIRS”: adevărat,
'OPȚIUNI': {
'context_processors': [
„django.template.context_processors.debug”,
„django.template.context_processors.request”,
„django.contrib.auth.context_processors.auth”,
„django.contrib.messages.context_processors.messages”,
],
},
},
]

Acum că Django știe unde să găsească șabloanele pentru site-ul web, puteți continua și le puteți reda în interfața de utilizare folosind vizualizarea.

Care este punctul de vedere al lui Django?

Vizualizarea este al doilea strat al arhitecturii MVT a Django, un șablon este inutil dacă o vizualizare îl redă în interfața de utilizare. Vizualizarea este responsabilă pentru acceptarea cererilor web și pentru returnarea răspunsurilor adecvate (inclusiv șabloane). În forma sa cea mai de bază, vizualizarea este o funcție Python, stocată în view.py fișierul proiectului Django.

Se creează Django View

The view.py fișierul se află în modulul vânzătorilor din exemplul de proiect Django. Când un vânzător vă vizitează site-ul web, veți dori ca acesta să meargă pe pagina de pornire a vânzătorului. Această pagină de pornire o veți crea folosind un șablon HTML, la fel ca cel creat în secțiunea de șabloane de mai sus.

Fișierul view.py

din django.shortcuts import render
index def (cerere):
returnare randare (solicitare, 'sellers_home.html')

Vizualizarea de mai sus preia o solicitare și returnează șablonul HTML al vânzătorilor. Deci, de fiecare dată când un utilizator vizitează (sau solicită) http://127.0.0.1:8000/sellers/ vor vedea pagina de pornire a vânzătorilor. Aceasta se întâmplă după ce creați un urls.py dosar în modulul vânzătorilor.

Fișierul Vânzători urls.py

din calea de import django.urls
din. import vizualizări
urlpatterns = [
cale('', views.index, nume='index'),
]

Și includeți calea către modulul vânzătorilor urls.py dosar în urls.py fișier aflat în directorul principal Django.

Fișierul site-ului urls.py

de la django.contrib import admin
din django.urls import include, path
urlpatterns = [
cale('vânzători/', include('vânzători.urls')),
cale('admin/', admin.site.urls),
]

Acum că vizualizarea este configurată, vă puteți asigura că serverul Django încă rulează și navigați la http://127.0.0.1:8000/sellers/ în browser pentru a vedea pagina de pornire a vânzătorilor.

Pagina de pornire a vânzătorilor

Arhitectura MVT a lui Django vs. Arhitectura MVC

Arhitectura MVT a lui Django este destul de diferită de arhitectura populară MVC.

Secțiunea de șablon a arhitecturii MVT funcționează în același mod ca și vizualizarea din arhitectura MVC, în timp ce vizualizarea din arhitectura MVT afișează calități care sunt similare cu controlerul din MVC arhitectură. Cu toate acestea, modelele din ambele arhitecturi funcționează identic.

O introducere în arhitectura MVC: exemple explicate

Aplicați principiile de proiectare Model-View-Controller propriilor programe pentru rezultate imediate. Iată cum să începeți.

Citiți în continuare

Despre autor