Siamo alla nostra ultima mini-conferenza
sui punti di vista, ed è una grande.
Si tratta di viste generiche.
È una lezione davvero grande in modo da
finire con piccole visualizzazioni con una riga di codice.
Quindi ho costruito opinioni e
abbiamo parlato di ereditarietà con i modelli,
e ora parleremo di ereditarietà e viste.
E abbiamo ereditato tutto insieme con le viste.
Quindi eccoci qui nel views.py.
Tutta questa cosa, questi particolari tipi di viste,
li definiamo in views.py,
ma sono molto informati dal contenuto di model.py, il
che significa che le viste vengono costruite
automaticamente solo guardando i dati nel models.py.
Quindi è di nuovo una sorta di logica di non ripeterti.
Se hai una cosa in models.py,
hai definito esattamente quali
sono i campi e cose come
il testo della guida per questo campo e
qual è la descrizione per il campo.
Questo non ha nulla a che fare con il database,
ma può informare le viste.
Vedrai come tutto si adatta bene,
ma a volte usiamo queste tecniche super fantastiche,
finiamo con un po 'di codice ed
è davvero importante
capire profondamente quel piccolo pezzo di codice
perché puoi semplicemente svanire e non
capire cosa sta succedendo perché questo codice
riutilizza così abilmente una tonnellata di altro codice e
estrae cose da altri posti.
Quindi, se si torna indietro a quando abbiamo parlato di SQL,
le quattro operazioni di base sono mettere i dati in un database,
ottenere i dati da un database,
eliminare quei dati o aggiornare tali dati. CRUD,
creare, leggere, aggiornare ed eliminare.
E costruiremo un mucchio di cose,
che siano cose pubblicitarie,
o cose automatiche, dove dobbiamo inserire un'auto,
aggiornare un'auto, cancellare un'auto,
elencare tutte le auto,
inserire un gatto, eliminare un gatto,
elencare tutti i gatti, aggiornare un gatto, giusto?
E così abbiamo un sacco di interfacce utente
che stiamo andando a costruire più e più volte.
E mentre costruisci i tuoi progetti,
probabilmente avrai quattro o cinque tabelle e
poi piccole interfacce utente CRUD per ciascuna delle tabelle.
E a volte li rendi un po 'diversi e ci sono
cose belle su di loro e sono personalizzate.
Ma sorprendentemente spesso, queste
cose sembrano uguali e finiamo per ripeterci,
che è qualcosa che non vogliamo
fare come sviluppatori di software.
Quindi ecco una semplice applicazione CRUD.
Questo qui è solo letto e dettagli.
Quindi abbiamo una lista di gatti e poi si fa clic sulla
lista dei gatti e poi si vedono
i dati per un particolare gatto
e poi un link di nuovo alla lista.
Quindi questa è come una pagina di dettaglio.
Ma faremo molto di più, ma
voglio solo mostrarti come funzionano queste viste generiche
mantenendo le cose molto, molto semplici.
Quindi stiamo andando a parlare di
una vista generica nella lista e
il dettaglio, che sono due di diverse viste generiche.
Quindi questa è la nostra applicazione gview,
ed ecco il urls.py.
In questo gview, ha una lista di gatti, un singolo gatto,
una lista di cani, un singolo cane.
E così vedete questo tipo di ripetizione.
E sto mettendo così tanti di
questi qui perché ho intenzione di mostrarti una sorta di
approcci diversi per implementarli
usando sempre più dettagli
e meno di più ereditarietà.
Quindi sono tutti uguali.
Io do loro un nome,
alcuni hanno chiavi primarie intere, e via te ne vai.
E così ecco la lista dei gatti,
ho intenzione di iniziare con un modello.
Quindi ci
aspetteremo nel modello di elenco dei gatti che ci
sia una variabile di contesto chiamata cat_list,
e che è un elenco di oggetti gatto.
E poi andremo a
scorrere la lista dei gatti, per quanto ci siano molti gatti,
all'interno di una lista, e generare
un tag li, e quindi creare un URL di collegamento,
e quindi estrarre il nome del gatto.
Quindi il gatto ha un nome e il gatto ha una chiave primaria.
E così stiamo andando a generare un collegamento con il gatto Sophie,
e sotto quel link c'è
il collegamento alla barra di gatto 12,
qualunque sia quel numero.
E se la lista dei gatti è vuota,
diremo che non ci sono gatti nel database.
Ora, abbiamo in realtà uno script che
usi per precaricare tutti questi dati.
Quindi ci sono istruzioni
nel codice di esempio su come precaricare quei dati.
Dai un'occhiata al readme per questo.
E quindi se siamo nella pagina dei dettagli,
passeremo un oggetto gatto in, e che ha un nome,
e poi vogliamo un link per tornare alla lista dei gatti.
E così di nuovo, stiamo usando qualcosa
dalla lezione precedente immediata
in cui stiamo usando la macro url,
passando il nome di una vista all'interno di un'applicazione.
Quindi questa è le applicazioni gview, la vista cat,
e quindi per un href,
che rende un collegamento valido con la stringa tornare
alla lista per essere la cosa che fa.
Quindi stiamo andando a costruire tutta questa roba,
e questa è l'idea di base che il modello e l'HTML,
è così che stiamo andando a farlo.
Ma vedremo come funzionano i punti di vista.
E ancora, questo è un promemoria
del principio DRY, il principio di non ripetere te stesso.
Ancora una volta, a volte questo principio DRY ci mette nei guai
perché l'idea
è che un po 'di logica sia posto in un posto
e riutilizzato il maggior numero possibile di posti perché
non ripeterti
sarebbe probabilmente descritto chiamando riutilizzo,
riutilizzo, riutilizzo. Fallo una volta
e poi riutilizzalo il maggior numero di volte possibile, in
modo che se devi risolverlo e hai un bug in esso,
non devi trovare i 49 posti in
cui metti tutto questo codice.
E poiché facciamo la stessa cosa più e più volte,
gatti, cani, cavalli, lo facciamo più e più volte, automobili,
l'idea che tu abbia una vista elenco,
una vista di dettaglio, una vista di modifica, ecc.,
È una cosa comune e
davvero se hai intenzione di fare queste cose,
perché non farlo sembrano coerenti e funzionano in modo coerente?
Se hai uno sviluppatore
costruisci l'interfaccia di editing dei gatti e
un'altra persona sviluppa l'
interfaccia di editing dei cani e lasciano
andare lo stesso, vanno a modo loro e hanno un design groovy
ma è diverso, sai, chi se ne frega, giusto?
E' incoerente.
Vuoi ancora un bel design,
ma vuoi che i dati dei gatti e
i dati dei cani abbiano un senso con quel design coerente,
in modo che entrambi possano avere un bel design.
Quindi abbiamo dei modelli.
I modelli si aspettano variabili, come
la lista si aspetta una cosa chiamata cat_list o dog_list
o qualsiasi altra cosa, e quindi
il dettaglio del gatto ha solo una variabile cat in esso,
e poi lo chiamiamo.
Quindi se ci
dimenticassimo di tutte le cose che stiamo per imparare
e abbiamo appena scritto una vista,
sembrerebbe questa prima, questa CatListView qui.
E così avremmo ereditato da View.
Andremo al database,
abbiamo importato il modello di gatto, Cat.Objects.
Questo è il modo per interrogare
tutti gli oggetti cat e ottenere un elenco di
oggetti cat e metterlo nella roba variabile.
Ecco cosa fa Cat.Objects.All.
Ora, l'abbiamo fatto prima, come nella shell,
ma ora lo stiamo facendo nel
codice Python reale nelle viste.
Come ho detto, le viste sono dove accadono tutte le cose.
Quindi questo dice di fare una chiamata al database,
caricare tutti i record del gatto,
trasformarli in oggetti
e darmi una lista di quegli oggetti.
E poi passerò nel
contesto nel modello, il gview/cat_list.html,
passerò un intero elenco.
E se torni indietro e guardi, c'era un anello
nel modello che ha stampato Sophie,
Frankie, e ha fatto dei link sotto di
loro nella pagina dei dettagli, ok?
Quindi questo è il modo in cui
lo faremmo se non volessimo ripeterci.
Va bene? Ora, questo prossimo modo di farlo
per i cani, lo faremo in un altro modo.
E quindi quello che faremo
è che sembra che sia più lavoro, ma è più riutilizzabile,
quindi le cose che stiamo facendo qui.
Quindi quello che stiamo facendo è ora abbiamo
un DoglistView, che è solo una classe, e
stiamo andando a creare
una variabile attributo in questo oggetto chiamato modello.
E stiamo solo per dire che
questo modello per questo particolare è Cane.
Quindi l'idea ora è in questo metodo get,
prendiamo questo codice proprio qui e ovunque abbiamo detto cat,
renderlo generico e farlo
guidare da questa variabile.
Va bene? Ora la parte difficile che rende questo un
po 'complicato è che a volte
stiamo solo usando il modello, e poi altre
volte
lo trasformeremo effettivamente in una stringa di testo.
Quindi, se diamo un'occhiata a questo,
abbiamo questo modello di variabile e nella richiesta get,
self.model è il modo per riferirsi
alla particolare istanza in cui ci troviamo, quella
variabile del modello. E così questo
meta.verbose_name.title in minuscolo,
potresti capirlo da solo
andando a Stack Overflow alla fine,
è così che l'ho capito.
Volevo ottenere una versione minuscola del nome del modello.
Quindi il nome del modello è una stringa
D-o-g, che non è la stessa del modello Dog, ok?
E così che è solo un modo,
il nome del modello sarà un cane minuscolo. Ma se
il modello è Cat, il
nome del modello sarà cat minuscolo in questo bit.
Quindi sto cercando di rendere il codice riutilizzabile.
Quindi sì, il codice riutilizzabile sembra un po
'più complesso perché è generico.
Ma noterai che sto creando una variabile chiamata
elenco di sottolineatura modelname, perché
lo sto solo concatenando insieme.
Quindi è il nome del modello e
sarà un elenco di sottolineatura del cane,
quindi questo è quello che succederà.
Parlerò con
il modello e recupererò tutti gli oggetti.
Va bene, non devo cambiarlo in una stringa, il
modello self dot è
Dog dot object dot dot all,
quindi ho intenzione di ottenere un elenco di
tutti gli oggetti in roba e
lo metterò nel contesto e poi andrò a
prendermi un modello dalla
cartella gview con il elenco di sottolineatura modelname
in modo che quello che era cat_list qui è ora l'elenco di sottolineatura del cane,
lo sto concatenando insieme e ho
passato il contesto in. E così quando succede,
allora ottieni una lista di cani e una
lista di cani e vai via.
Quindi quello che ho fatto è stato generalizzato questo codice e
metterlo qui e poi ho passato
in un certo senso all'oggetto
che è stato creato dalla classe DoglistView
il modello reale su cui volevo che operasse, ok?
Quindi lo faccio per darvi un'idea di come funziona.
Puoi fare la stessa cosa per i cavalli facendo questo.
E cioè, si importa
il generico django.views proprio qui e si dice,
ho intenzione di creare una classe chiamata HorseListView.
Ho intenzione di estendere non solo View, ma Generic.ListView.
Quindi questa è una classe generica,
puoi andare a guardare la documentazione di Django per questo.
È una classe generica che fa
una vista elenco in generale. E la regola per
la classe è che devi aggiungere una riga qui per
dire su quale modello funziona, e basta.
E questo perché il codice get è già in questo modello.
Stiamo estendendo quel modello.
Stiamo ereditando tutto questo codice, non da
DoglistView ma invece da Generic.ListView.
Quindi abbiamo preso qualcosa che era cinque righe,
un po' più generalizzato, è come otto righe,
e ora è una riga.
E così è così che funziona l'estensione, ma
devi fidarti e devi andare a
leggere la documentazione per ListView per
sapere
come è che lo informi su quale modello dovresti usare.
Quindi voglio mostrarti
un po 'di come sta accadendo
facendo uno di questi ListViews che è mio,
non è bello come il vero Django
Listview, solo per darti
un'idea di cosa sta succedendo dietro
le quinte in Django ListView.
Quindi ho intenzione di fare una nuova classe
DJ4eListView, e poi ho
intenzione di estendere View e poi ho intenzione di avere
un metodo get e sarà tutto questo codice.
Sta cercando una variabile
chiamata modello e noterai che non sta
definendo il modello qui perché è inteso che
questa è una classe che verrà riutilizzata.
Quindi sto per dire, oh, beh,
qualunque sia il modello che è stato impostato qui
dalla classe che viene creata mentre lo stiamo
estendendo, vai
a prenderlo, convertirlo in un testo,
ottieni il titolo di esso e poi convertirlo in minuscolo,
fai quel nome del modello.
Qualunque sia il modello,
recupera tutti i suoi oggetti e mettilo
in roba e poi metti l'
elenco di sottolineatura del nomemodello, in questo caso l'
elenco di sottolineatura dell'auto, quindi passa quell'elenco nel
modello e quindi
esegui il rendering del contesto dell'elenco di sottolineatura dell'auto di gview, ok?
Quindi questo non sta facendo nulla di per sé.
DJ4eListView sta creando una classe
che estenderò in seguito,
e ho intenzione di estendere quelle due righe più tardi.
Sto facendo un CarlistView che estende
DJ4eListView e l'unica cosa che devo
fare per ottenere tutto questo codice qui è
estenderlo e quindi ho bisogno di aggiungere il modello uguale a Car.
Quindi noterai che
CarlistView ha la stessa sintassi esatta di HorseListView, giusto?
HorseListView, fondamentalmente dici che
Generic.ListView dice
su quale modello lavorare e quindi generic.ListView fa affatto.
E se guardi CarlistView, dice,
usa questo ListView generico che ho appena
inventato per mostrarti il codice sorgente di ciò
che è, questo è il codice sorgente dietro le quinte.
Come ho detto, è molto più complesso
e sofisticato di quello che ho fatto.
Questa è la versione più cruda e più semplice
di un ListView generico estensibile.
Ma quando tutto è detto e fatto,
non si scrive nessuna di quelle versioni.
Fai letteralmente una vista elenco e dici quale modello è.
Fai una vista gatto e gli
dici che modello è. E
riusi semplicemente ListView più e più e più volte.
Quindi, il fatto che ti dia
quattro modi diversi per farlo,
forse cinque, quattro o cinque modi diversi per farlo,
il vero modo di farlo è un modo,
ma quando guardi il codice in questo modo,
sei come HorselistView
estendendo Generic.ListView e il modello è Horse.
Mi fido molto. E la risposta e' si',
ci si abitua. E ora il codice
che devi scrivere è solo due righe di
codice. E devi ancora scrivere il modello,
perché chiamerà i tuoi modelli, ma conosce
il nome del modello guardando quel cavallo, giusto?
Sa, oh sì, dettaglio di sottolineatura del cavallo, giusto?
o lista di sottolineatura cavallo, e quindi questa è
la pagina di dettaglio effettiva
che mostra il cavallo e torna alla lista, ecc, ecc, ecc
Quindi, utilizzando queste viste generiche,
è possibile rendere le cose davvero brevi
e davvero succinto e davvero semplice.
Quindi, le viste generiche sono eccellenti,
ci permettono di produrre molte
pagine simili senza ripeterci,
mantengono il tuo codice coerente.
Ripetere te stesso facendo la stessa cosa
più e più volte anche se sembra veloce tagliare,
incollare, cambiare, tagliare, incollare,
cambiare, tagliare, incollare, cambiare.
Se vuoi davvero creare codice e codice affidabili
che siano migliaia e migliaia
di righe con centinaia di funzionalità,
non vuoi incollare la stessa cosa più e
più volte. E quindi meno righe di codice significa meno errori.
Quindi, questa è la fine del nostro discorso sui punti di vista.
E' proprio dove
inizieremo a fare la maggior parte del lavoro.
Gli URL, i modelli,
non ottengono il tipo di attività.
Anche se parleremo imminente di moduli,
che toccano le visualizzazioni e
toccano i modelli e toccano i modelli.
Quindi i moduli sono una delle cose che ci permettono di
prendere la nostra esperienza utente e
davvero su di essa. Allora, ci vediamo presto.
[ MUSIC]