Cos'è l'ereditarietà del modello in Django?

L'ereditarietà del modello è una funzionalità ORM di Django che consente agli sviluppatori di creare relazioni gerarchiche tra i modelli di database. Consente il riutilizzo del codice, l'estensibilità e una base di codice più chiara sfruttando i principi della programmazione orientata agli oggetti.

Che tu stia creando un'applicazione Web complessa o lavorando a un progetto più piccolo, l'ereditarietà del modello può offrire vantaggi significativi, come la riduzione della ridondanza e la garanzia di un comportamento coerente.

Tipi di ereditarietà del modello in Django

Django offre supporto per tre tipi di ereditarietà del modello:

1. Classi di base astratte.
2. Ereditarietà multi-tabella.
3. Modelli delegati.

Ciascuno di questi tipi di ereditarietà del modello ha dei vantaggi e li utilizzerai per scopi specifici.

Classi di base astratte

Le classi di base astratte forniscono un modo per definire campi e metodi comuni che più modelli possono ereditare. Ad esempio, se hai due modelli che condividono campi simili, puoi utilizzare una classe base astratta per definire i campi simili. Dai un'occhiata a questo esempio:

classeCliente(Modelli. Modello):
 nome = modelli. CharField (lunghezza_max=50)
 e-mail = modelli. campo e-mail()
 customer_id = modelli. InteroCampo() 
classeVenditore(Modelli. Modello):
 nome = modelli. CharField (lunghezza_max=50)
 e-mail = modelli. campo e-mail()
 seller_id = modelli. InteroCampo()

Lo snippet di codice sopra definisce due modelli Django: Cliente E Venditore. Questi modelli condividono due campi comuni, vale a dire nome E e-mail. Per evitare questa ridondanza, è possibile creare un modello separato per contenere i campi comuni nel file Cliente E Venditore modelli e renderlo astratto.

classeInformazioni utente(Modelli. Modello):
 nome = modelli. CharField (lunghezza_max=50)
 e-mail = modelli. campo e-mail()
classeMeta:
 astratto = VERO

Il frammento di codice precedente definisce un nuovo modello e imposta il file astratto attribuire a VERO. Ciò significa che il modello sarà astratto e Django non creerà una tabella nel database.

Puoi riscrivere il file Cliente E Venditore modelli come questo:

classeCliente(Informazioni utente):
 customer_id = modelli. InteroCampo() 
classeVenditore(Informazioni utente):
 seller_id = modelli. InteroCampo()

Nello snippet di codice sopra, il file Cliente E Venditori i modelli ereditano dal Informazioni utente modello invece di Modelli. Modello.

Puoi visualizzare i tuoi modelli nel pannello di amministrazione registrandoli nel tuo admin.py file come questo:

da .Modelli importare Cliente, Venditore
admin.site.register (Cliente)
admin.site.register (Venditore)

Migra le tue modalità e avvia il tuo server di sviluppo eseguendo quanto segue su a riga di comando:

python manage.py makemigrations \
 && python manage.py migrare \
 && python manage.py esegue il server

Vai al tuo sito di amministrazione e accedi con i tuoi dettagli di superutente. Dovresti vedere tutti e tre i campi per ogni modello.

In questo esempio, Django ha creato una tabella per il file Cliente E Venditore Modelli. Puoi vedere che il Informazioni utente il modello non ha tabella poiché è astratto.

Ereditarietà multi-tabella

È possibile utilizzare l'ereditarietà multi-tabella quando anche il modello padre deve esistere come tabella nel database accanto al modello figlio.

A differenza dell'ereditarietà della classe di base astratta, in cui il modello padre non sarà una tabella nel database, l'ereditarietà multi-tabella crea una tabella per il modello padre.

Nell'ereditarietà multi-tabella, il modello figlio eredita tutti i campi e i metodi dal modello padre e aggiunge i suoi campi specifici. Chiavi esterne aiutare a stabilire il relazione modello tra modelli padre e figlio.

Ecco un esempio di ereditarietà multi-tabella:

classePersona(Modelli. Modello):
 first_name = modelli. CharField (lunghezza_max=100)
 cognome = modelli. CharField (lunghezza_max=100)
defget_name(se stesso):
ritornoF"{self.first_name}{self.cognome}"
classeMeta:
 astratto = VERO
classeDipendente(Persona):
 employee_id = modelli. CharField (lunghezza_max=20)
 dipartimento = modelli. CharField (lunghezza_max=100)
 stipendio = modelli. Campo mobile()
 dob = modelli. campodata()
classeManager(Dipendente):
 titolo = modelli. CharField (lunghezza_max=100)

Questo frammento di codice definisce tre modelli. Il primo modello, chiamato Persona, è astratto. Definisce solo il nome e il cognome di una persona.

Il secondo modello, chiamato Dipendente, eredita i campi di Persona ma definisce campi aggiuntivi. IL Dipendente model non è astratto, quindi avrà la sua tabella nel database.

Il modello finale, chiamato Manager, eredita i campi di Dipendente model e aggiunge un campo chiamato titolo.

Il rapporto tra il Dipendente E Manager modelli è chiamato Ereditarietà multi-tabella. Migra i tuoi modelli, registrali admin.py, avvia il tuo server e vai al pannello di amministrazione. Dovresti vedere due tabelle create da Django.

Quando provi ad aggiungere un nuovo manager, noterai che ha tutti i campi del file Dipendente model così come il proprio campo personalizzato.

Modelli delegati

Un modello proxy ti aiuta a creare un nuovo modello che si estende da un modello esistente senza creare una nuova tabella di database. In questo tipo di ereditarietà del modello, il proxy e il modello originale condivideranno la stessa tabella. Utilizzando i modelli proxy, puoi fare cose come creare modelli personalizzati e modificare i gestori predefiniti.

È possibile creare un modello proxy aggiungendo proxy=Vero nel Meta classe. Ecco un esempio:

classeProxyModel(Modello base):
classeMeta:
 delegato = VERO

L'utilizzo tipico di un modello proxy è appropriato quando esiste un modello di base ed è necessario crearne una versione specializzata con funzionalità aggiuntive. Ecco un esempio di base:

classeInviare(Modelli. Modello):
 titolo = modelli. CharField (lunghezza_max=30)
 autore = modelli. CharField (lunghezza_max=30)
def__str__(se stesso):
ritorno auto.titolo
classeProxyPost(Inviare):
classeMeta:
 delegato = VERO

Questo frammento di codice definisce due modelli: Inviare E Il mio post. IL Inviare model definisce due campi per titolo e autore. IL ProxyPost modello eredita dal Inviare modello.

Migrare i modelli precedenti e aggiungere un nuovo post alla tabella creata per il Inviare modello.

Dopo aver aggiunto il post, apri il file Messaggi di delega tavolo. Dovresti trovare il post che hai aggiunto al file Inviare tavolo in esso.

Le modifiche apportate ai post nel file Messaggi di delega tabella influenzerà il post corrispondente nel file Inviare tavolo e viceversa. Ciò dimostra che condividono veramente lo stesso tavolo.

Puoi modificare il file str() metodo del modello proxy:

classeProxyPost(Inviare):
classeMeta:
 delegato = VERO
 ordinamento = ["titolo"]
def__str__(se stesso):
ritorno self.autore

Con questa modifica, a ProxyPost la rappresentazione di stringa sarà il suo autore, non il titolo. Anche l'ordinamento del modello proxy avverrà in base al titolo anziché al campo ID predefinito.

Quando utilizzi i modelli proxy, tieni presente che non puoi aggiungere campi personalizzati al tuo modello proxy. Il caso d'uso principale dei modelli proxy è quando si desidera che un modello supporti più comportamenti.

I modelli proxy consentono di modificare il comportamento di un modello esistente senza modificarne i campi o la struttura della tabella del database sottostante.

Utilizzare l'ereditarietà del modello per la riusabilità del codice e la struttura organizzativa

Utilizzando le diverse tecniche di ereditarietà del modello, puoi facilmente creare codice riutilizzabile e organizzato per il tuo progetto.

L'ereditarietà del modello evita il codice ridondante e migliora la manutenibilità e la scalabilità del codice. Inoltre, semplifica la navigazione nel codice, favorendo così una collaborazione efficiente tra i team di sviluppo.

Oltre all'ereditarietà del modello, Django offre l'ereditarietà del modello, che è un ottimo modo per gestire e organizzare i modelli per i tuoi progetti.