Vad är modellarv i Django?

Modelheritance är en Django ORM-funktion som gör att utvecklare kan skapa hierarkiska relationer mellan databasmodeller. Det möjliggör återanvändning av kod, utökbarhet och en renare kodbas genom att utnyttja principerna för objektorienterad programmering.

Oavsett om du bygger en komplex webbapplikation eller arbetar med ett mindre projekt, kan modellarv erbjuda betydande fördelar, som att minska redundans och säkerställa konsekvent beteende.

Typer av modellarv i Django

Django erbjuder stöd för tre typer av modellarv:

1. Abstrakta basklasser.
2. Flerbordsarv.
3. Proxy-modeller.

Var och en av dessa typer av modellarv har fördelar och du kommer att använda dem för specifika ändamål.

Abstrakta basklasser

Abstrakta basklasser ger ett sätt att definiera vanliga fält och metoder som flera modeller kan ärva. Till exempel, om du har två modeller som delar liknande fält, kan du använda en abstrakt basklass för att definiera liknande fält. Ta en titt på detta exempel:

klassKund(modeller. Modell):
 namn = modeller. CharField (max_length=50)
 e-post = modeller. EmailField()
 kund_id = modeller. IntegerField() 
klassSäljare(modeller. Modell):
 namn = modeller. CharField (max_length=50)
 e-post = modeller. EmailField()
 säljar-id = modeller. IntegerField()

Kodavsnittet ovan definierar två Django-modeller: Kund och Säljare. Dessa modeller delar två gemensamma områden, nämligen namn och e-post. För att förhindra denna redundans kan du skapa en separat modell för att hålla de gemensamma fälten i Kund och Säljare modeller och göra det abstrakt.

klassAnvändarinformation(modeller. Modell):
 namn = modeller. CharField (max_length=50)
 e-post = modeller. EmailField()
klassMeta:
 abstrakt = Sann

Ovanstående kodavsnitt definierar en ny modell och ställer in abstrakt tillskriva Sann. Detta innebär att modellen kommer att vara abstrakt och Django kommer inte att skapa en tabell i databasen.

Du kan skriva om Kund och Säljare modeller som denna:

klassKund(Användarinformation):
 kund_id = modeller. IntegerField() 
klassSäljare(Användarinformation):
 säljar-id = modeller. IntegerField()

I kodavsnittet ovan visas Kund och Säljare modeller ärver från Användarinformation modell istället för modeller. Modell.

Du kan se dina modeller i adminpanelen genom att registrera dem i din admin.py fil så här:

från .modeller importera Kund, säljare
admin.site.register (kund)
admin.site.register (säljare)

Migrera dina lägen och starta din utvecklingsserver genom att köra följande på en kommandorad:

python manage.py makemigrations \
 && python manage.py migrera \
 && python manage.py runserver

Navigera till din adminwebbplats och logga in med dina superanvändaruppgifter. Du bör se alla tre fälten för varje modell.

I det här exemplet har Django skapat en tabell för Kund och Säljare modeller. Du kan se att Användarinformation modellen har ingen tabell eftersom den är abstrakt.

Flerbordsarv

Du kan använda flertabellsarv när den överordnade modellen också behöver finnas som en tabell i databasen vid sidan av den underordnade modellen.

Till skillnad från abstrakt basklassarv, där den överordnade modellen inte kommer att vara en tabell i databasen, skapar flertabellsarv en tabell för den överordnade modellen.

Vid arv med flera tabeller ärver den underordnade modellen alla fält och metoder från sin överordnade modell och lägger till sina specifika fält. Främmande nycklar hjälpa till att etablera modellförhållande mellan föräldra- och barnmodeller.

Här är ett exempel på flerbordsarv:

klassPerson(modeller. Modell):
 förnamn = modeller. CharField (max_length=100)
 efternamn = modeller. CharField (max_length=100)
defhämta namn(själv):
lämna tillbakaf"{self.first_name}{self.last_name}"
klassMeta:
 abstrakt = Sann
klassAnställd(Person):
 anställd_id = modeller. CharField (max_length=20)
 avdelning = modeller. CharField (max_length=100)
 lön = modeller. FloatField()
 dob = modeller. DateField()
klassChef(Anställd):
 titel = modeller. CharField (max_length=100)

Det här kodavsnittet definierar tre modeller. Den första modellen, kallad Person, är abstrakt. Den definierar endast för- och efternamn på en person.

Den andra modellen, kallad Anställd, ärver fälten av Person men definierar ytterligare fält. De Anställd modellen är inte abstrakt, så den kommer att ha sin tabell i databasen.

Den slutliga modellen, kallad Chef, ärver fälten av Anställd modell och lägger till ett fält som heter titel.

Förhållandet mellan Anställd och Chef modeller kallas Flerbordsarv. Migrera dina modeller, registrera dem i admin.py, starta din server och navigera till adminpanelen. Du bör se två tabeller skapade av Django.

När du försöker lägga till en ny chef kommer du att märka att den har alla fält från Anställd modell samt sitt eget anpassade fält.

Proxy-modeller

En proxymodell hjälper dig att skapa en ny modell som sträcker sig från en befintlig modell utan att skapa en ny databastabell. I denna typ av modellarv kommer proxy- och originalmodellerna att dela samma tabell. Med hjälp av proxymodeller kan du göra saker som att skapa anpassade modeller och ändra standardhanterare.

Du kan skapa en proxymodell genom att lägga till proxy=Sant i Meta klass. Här är ett exempel:

klassProxyModel(Basmodell):
klassMeta:
 proxy = Sann

Typisk användning av en proxymodell är lämplig när det finns en basmodell och det finns ett behov av att skapa en specialiserad version av den med extra funktionalitet. Här är ett grundläggande exempel:

klassPosta(modeller. Modell):
 titel = modeller. CharField (max_length=30)
 författare = modeller. CharField (max_length=30)
def__str__(själv):
lämna tillbaka själv.titel
klassProxyPost(Posta):
klassMeta:
 proxy = Sann

Det här kodavsnittet definierar två modeller: Posta och Mitt inlägg. De Posta modellen definierar två fält för titel och författare. De ProxyPost modellen ärver från Posta modell.

Migrera ovanstående modeller och lägg till ett nytt inlägg i tabellen som skapats för Posta modell.

När du har lagt till inlägget öppnar du Proxyposter tabell. Du bör hitta inlägget du lagt till i Posta bord i den.

Ändringarna du gör i inlägg i Proxyposter tabellen kommer att påverka motsvarande inlägg i Posta tabell och vice versa. Detta bevisar att de verkligen delar samma bord.

Du kan ändra str() metod för proxymodellen:

klassProxyPost(Posta):
klassMeta:
 proxy = Sann
 beställning = ["titel"]
def__str__(själv):
lämna tillbaka själv.författare

Med denna ändring, a ProxyPosts strängrepresentation kommer att vara dess författare, inte titeln. Ordningen av proxymodellen kommer också att ske efter titeln istället för standard-ID-fältet.

När du använder proxymodeller bör du komma ihåg att du inte kan lägga till anpassade fält till din proxymodell. Det primära användningsfallet för proxymodeller är när du vill att en modell ska stödja flera beteenden.

Proxymodeller hjälper dig att ändra beteendet hos en befintlig modell utan att ändra dess fält eller underliggande databastabellstruktur.

Använd modellarv för kodåteranvändbarhet och organisationsstruktur

Genom att använda de olika teknikerna för modellarv kan du enkelt skapa återanvändbar och organiserad kod för ditt projekt.

Modellärvning undviker redundant kod och förbättrar underhållbarheten och skalbarheten för din kod. Det gör det också enkelt att navigera i din kod, vilket främjar effektivt samarbete mellan utvecklingsteam.

Förutom modellarv erbjuder Django mallarv, vilket är ett utmärkt sätt att hantera och organisera mallar för dina projekt.