Il framework Web di Django ha un'architettura Model-View-Template (MVT), che lo rende l'unico framework necessario per creare un sito Web completo o un'applicazione Web. Questo framework Python consente di creare modelli che generano database ed eseguono il rendering di modelli HTML dinamici nell'interfaccia utente utilizzando le viste.
Il potere di Django non è un segreto; è veloce, affidabile, scalabile e sicuro. L'affidabilità, così come la scalabilità di questo software, si basa sulla sua architettura MVT. E in questo articolo imparerai esattamente come funziona l'architettura MVT di Django.
Qual è il modello di Django?
Il modello nell'architettura MVT di Django definisce la struttura e il comportamento dei dati che desideri archiviare attraverso il tuo sito web. Ogni modello Django che crei genera una tabella di database corrispondente, in cui ogni attributo del modello diventa un campo nella tabella.
Proseguendo con il setup dal ns articolo introduttivo su Django, puoi creare un modello per i venditori. Un venditore può avere un modello venditore che contiene informazioni personali, come nome e dettagli di contatto, e un modello correlato per gli articoli venduti da ciascun venditore.
La struttura del file di progetto Django di esempio esistente
il mio sito/
il mio sito/
_pycache_
_init_.py
asgi.py
impostazioni.py
urls.py
wsgi.py
venditori/
migrazione
_init_.py
admin.py
app.py
modelli.py
test.py
visualizzazioni.py
db.sqlite3
gestire.py
Creazione di modelli Django
Se guardi sotto la sezione dell'app dei venditori nella struttura del file sopra, vedrai un file chiamato modelli.py. Qui è dove creerai tutti i tuoi modelli Django per la sezione venditori del tuo sito web. Ogni modello che crei sarà una sottoclasse di API modello di Django, ecco perché ogni Django-generato modelli.py il file ha un'importazione di modelli predefinita.
Il file models.py
Da django.db importa i modelli# Crea qui i tuoi modelli.
classe Venditore (modelli. Modello):
nome = modelli. CharField (max_length=30)
cognome = modelli. CharField (max_length=30)
numero_contatto = modelli. CharField (max_length=30)
classe Prodotto (modelli. Modello):
venditore = modelli. ForeignKey (venditore, on_delete=models. CASCATA)
nome_oggetto = modelli. CharField (max_length=100)
item_qantity = modelli. Campo intero()
prezzo_articolo = modelli. DecimalField (max_cifre=9, decimali_posti=2)
item_description = modelli. Campo di testo()
Il codice sopra riportato è una copia del contenuto aggiornato del modello.py file. Il file ora crea due modelli: venditore e prodotto. Questi modelli condividono una relazione uno-a-molti, in cui un venditore può avere molti prodotti in vendita. Quindi, il modello Product ha a chiave esterna dal venditore e un on_elimina attributo impostato su Modelli. CASCATA, il che significa che quando elimini un venditore, elimini automaticamente tutti i prodotti che lo hanno chiave primaria come un chiave esterna.
Imparentato: Impara Python e Django oggi con questi fantastici corsi Potresti anche notare che ciascuno dei modelli nel codice sopra non ha una chiave primaria. Questo perché Django genererà automaticamente a chiave primaria se non ne crei uno esplicitamente.
Prima di poter utilizzare qualsiasi modello che crei, dovrai dire a Django dove trovarlo. Per fare ciò, dovrai accedere a impostazioni.py e inserire il nome del modulo che contiene il file modelli.py file, nel APP_INSTALLATA sezione.
Nel progetto di esempio per questo articolo, il modelli.py il file è nel modulo dei venditori. Pertanto, l'aggiornamento APP_INSTALLATA la sezione si leggerà come segue:
APP_INSTALLATE = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'venditori',
]
Con il codice sopra, i modelli nell'app dei venditori sono ora visibili sul sito Web di Django e ora puoi passare alle migrazioni.
L'esecuzione delle migrazioni è importante perché questo processo è un modo per distribuire le modifiche apportate ai modelli allo schema del database corrispondente. Quindi, ogni volta che apporti modifiche al tuo modello, dovrai condurre il processo di migrazione, che prevede due passaggi.
Il primo passo consiste nell'eseguire migrazioni, che è un comando che crea migrazioni in base alle modifiche rilevate nel file modelli.py file. Per avviare il processo di migrazione, dovrai aprire il tuo terminale, accedere alla directory che contiene il tuo progetto Django e avviare il server utilizzando il seguente comando:
python manage.py runserver
Con il server in esecuzione in un terminale, apri un nuovo terminale e inserisci il seguente comando:
python manage.py migrazioni
Dopo l'esecuzione, il terminale produrrà il seguente output:
Migrazioni per i "venditori":
venditori\migrazioni\0001_initial.py
- Crea modello venditore
- Crea un prodotto modello
L'output sopra indica chiaramente che ora hai migrazioni per due modelli: il venditore e il prodotto. Ora se accedi alla cartella di migrazione nel modulo dei tuoi venditori, vedrai che ora ha un nuovo file chiamato 0001_iniziale.py. All'interno di questo file troverai le migrazioni che hai appena creato.
Il file 0001_initial.py
# Generato da Django 3.2.9 il 26-02-2022 16:06da django.db importa migrazioni, modelli
importa django.db.models.deletion
classe Migrazione (migrazioni. Migrazione):
iniziale = Vero
dipendenze = [
]
operazioni = [
migrazioni. Crea modello(
nome='Venditore',
campi=[
('id', modelli. BigAutoField (auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('first_name', modelli. CharField (max_length=30)),
('cognome', modelli. CharField (max_length=30)),
("contatto_numero", modelli. CharField (max_length=30)),
],
),
migrazioni. Crea modello(
nome='Prodotto',
campi=[
('id', modelli. BigAutoField (auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('nome_oggetto', modelli. CharField (max_length=100)),
('item_qantity', modelli. campo intero()),
("prezzo_articolo", modelli. Campo Decimale (posti_decimali=2, cifre_max=9)),
('item_description', modelli. Campo di testo()),
('venditore', modelli. ForeignKey (on_delete=django.db.models.deletion. CASCADE, to='seller.seller')),
],
),
]
Ogni volta che esegui una nuova migrazione, la cartella di migrazione genera una nuova versione di questo file.
Il secondo passaggio del processo di migrazione consiste nel migrare finalmente i modelli. Ciò significa che sincronizzi lo stato del database con il modelli.py file, utilizzando le migrazioni che hai appena creato nel file 0001_iniziale.py file. Puoi completare questo processo (mentre il server è ancora in esecuzione) con il seguente comando:
python manage.py migra
Qual è il modello di Django?
I modelli sono un modo per generare dinamicamente HTML per il tuo progetto Django. Ogni modello Django ha il .html estensione e una combinazione di contenuto statico e dinamico. I modelli Django hanno una sintassi unica che include nuovi modi di creare variabili e tag in un documento HTML.
Creazione di un modello Django
Per introdurre i modelli nel sito Web di e-commerce di esempio per questo articolo, dovrai creare una nuova directory nel modulo dei venditori. Questa nuova directory chiamata "templates" sarà la home di tutti i documenti HTML per l'app dei venditori, a partire dalla home page.
Il file Seller_home.html
Venditori | Commercio elettronico
Venditori benvenuti!
Dopo aver creato i tuoi modelli, dovrai renderli visibili a Django aggiungendo la directory dei tuoi modelli alla MODELLI sezione del impostazioni.py file. L'aggiornamento MODELLI la sezione sarà simile alla seguente:
MODELLI = [
{
'BACKEND': 'django.template.backends.django. DjangoModelli',
'DIR': [
# nuovo codice che punta alla posizione dei modelli
BASE_DIR / 'venditori' / 'modelli'
],
'APP_DIRS': Vero,
'OPZIONI': {
'processori_contesto': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
]
Ora che Django sa dove trovare i modelli per il sito Web, puoi andare avanti e renderli all'interfaccia utente usando la vista.
Qual è il punto di vista di Django?
La vista è il secondo livello dell'architettura MVT di Django, un modello è inutile a meno che una vista non lo renda all'interfaccia utente. La vista è responsabile dell'accettazione delle richieste Web e della restituzione delle risposte appropriate (inclusi i modelli). Nella sua forma più semplice, la vista è una funzione Python, memorizzata nel file visualizza.py file del tuo progetto Django.
Creazione della vista Django
Il visualizza.py il file è nel modulo dei venditori del progetto Django di esempio. Quando un venditore visita il tuo sito web, vorrai che vada alla home page di un venditore. Questa home page la creerai utilizzando un modello HTML, molto simile a quello creato nella sezione del modello sopra.
Il file view.py
da django.shortcuts import render
def indice (richiesta):
rendering di ritorno (richiesta, 'seller_home.html')
La vista sopra accetta una richiesta e restituisce il modello HTML del venditore. Quindi, ogni volta che un utente visita (o richiede) http://127.0.0.1:8000/sellers/ vedranno la home page dei venditori. Questo è dopo aver creato un urls.py file nel modulo venditori.
Il file urls.py dei venditori
dal percorso di importazione django.urls
da. importare viste
urlpattern = [
percorso('', views.index, nome='indice'),
]
E includi il percorso al modulo dei venditori urls.py file nel urls.py file che si trova nella directory principale di Django.
Il file urls.py del sito web
da django.contrib import admin
da django.urls import include, percorso
urlpattern = [
percorso('seller/', include('seller.urls')),
percorso('admin/', admin.site.urls),
]
Ora che la vista è configurata, puoi assicurarti che il server Django sia ancora in esecuzione e navigare verso http://127.0.0.1:8000/sellers/ nel tuo browser per vedere la home page dei venditori.
La home page dei venditori
Architettura MVT di Django vs. Architettura MVC
L'architettura MVT di Django è molto diversa dalla popolare architettura MVC.
La sezione del modello dell'architettura MVT funziona più o meno allo stesso modo della vista nell'architettura MVC, mentre la vista nell'architettura MVT mostra qualità simili al controller nell'MVC architettura. Tuttavia, i modelli in entrambe le architetture funzionano in modo identico.
Applica i principi di progettazione Model-View-Controller ai tuoi programmi per risultati immediati. Ecco come iniziare.
Leggi Avanti
- Programmazione
- Programmazione
- Pitone
Kadeisha Kean è uno sviluppatore di software full-stack e uno scrittore tecnico/tecnologico. Ha la spiccata capacità di semplificare alcuni dei concetti tecnologici più complessi; produrre materiale che può essere facilmente compreso da qualsiasi principiante della tecnologia. È appassionata di scrittura, sviluppo di software interessanti e viaggi per il mondo (attraverso i documentari).
Iscriviti alla nostra Newsletter
Iscriviti alla nostra newsletter per suggerimenti tecnici, recensioni, ebook gratuiti e offerte esclusive!
Clicca qui per iscriverti
