Python-arv

Python är ett objektorienterat programmeringsspråk. På ett objektorienterat programmeringsspråk skapar vi klasserna och utför den avsedda funktionaliteten. Arv är det grundläggande inslaget i objektorienterade programmeringsspråk. Arv kan definieras som förmågan hos en klass att ärva alla funktioner och egenskaper hos en annan klass. Arv gör det i princip möjligt att utvidga egenskaperna hos en befintlig klass. Arv utnyttjas med de två huvudkoncepten:

Föräldraklass eller basklass
Barnklass eller härledd klass

Föräldraklassen är den klass som gör att andra klasser kan ärvas från. Det kallas också basklassen. Barnklassen eller den härledda klassen är den klassen som ärver alla egenskaper och funktioner i en annan klass. Arv främjar flera fördelar, dvs.e., det är representationen av det verkliga världsarvsfenomenet. Det uppmuntrar återanvändbarhet av kod. Om en funktion definieras i en klass kan den andra klassen ärva den här klassen och använda alla befintliga funktioner. Det finns inget behov av att skriva samma kod om och om igen för att utföra liknande uppgifter. Arv tillämpas på flera nivåer. Till exempel, om klass B ärvs från A och klass C ärvs från klass B, har klass C alla egenskaper hos klass B och liksom klass A. Syntaxen för arv är som följer:

KlassförälderKlass:
Implementeringsinformation för föräldraklassen
klass ChildClass:
Implementeringsinformation för barnklassen

Även om barnklassen har tillgång till alla funktioner och funktioner i föräldraklassen kan den också lägga till sina nya funktioner och funktioner.

Den här artikeln beskriver och täcker alla aspekter av Python-arv.

Arv implementering i Python

Arv kan tillämpas i många situationer. Låt oss anta att du bygger ett mjukvarusystem för ett universitet. Den kan bestå av flera intressenter som studenter, lärare, personal, etc. Så varje person har ett namn, ålder, e-postadress och andra vanliga egenskaper. Det är inte nödvändigt att deklarera alla fastigheter i varje klass separat. Vi kan skapa en personklass, och alla intressentklasser kan ärva alla vanliga egenskaper och funktioner från personklassen. I det här fallet finns det inget behov av att skriva de gemensamma egenskaperna i varje klass om och om igen. På samma sätt kan vi överväga en djurklass. Det finns hundratals typer av djur i denna värld. Alla djur äter, sover och har också vissa arter. Detta koncept kan också implementeras med arv.

Låt oss betrakta djuret som en superklass och genomföra arvet. I exemplet nedan har vi skapat en djurklass. Djurklassen är föräldraklassen. Dessutom har vi skapat hund- och kattklasserna som ärver djurklassens egenskaper och funktioner. Passordnyckelordet används i barnklassen när vi inte behöver implementera någon utökad funktionalitet i barnklassen.

# skapar föräldraklass
klass Djur:
#initialiseringsfunktion
#initilisering djurets namn och typ av typ
def __init __ (själv, namn, specifik_typ):
själv.namn = namn
själv.specie_type = specie_type
# en funktion för att skriva ut djurets namn
def trycknamn (själv):
tryck ("Namnet på djuret är:", själv.namn)
# en funktion för att skriva ut djurartstypen
def printspecie (själv):
tryck ("Typen av specie är:", själv.specie_type)
# skapar hundklassen som barnklass i djurklassen
klass Hund (djur):
# ingen förlängning eller modifiering
passera
# nu har hundklassen tillgång till alla funktioner och egenskaper hos djurklassen
# skapa hundklassobjektet
dogObj = Hund ("Hund", "köttätare")
hundObj.Skriv namn()
hundObj.utskriftsart ()
# skapar kattklassen som barnklass i djurklassen
klass Katt (djur):
# initiliseringsfunktionen för kattklassen
def __init __ (själv):
#kalla och använda djurklassinitieringsfunktionen
Djur.__init __ (själv, "katt", "köttätande däggdjur")
#now cat class har tillgång till alla funktioner och egenskaper hos djurklassen
#creating the cat class object
catObj = Cat ()
catObj.Skriv namn()
catObj.utskriftsart ()

Produktion

De "Djur.__init __ (själv, "katt", "köttätande däggdjur") " samtal är initialiseringsfunktionen för djurklassen.

Funktionen super ()

Python tillhandahåller en inbyggd super () -funktion för att ärva alla egenskaper och funktioner i moderklassen. När vi använder super () -funktionen behöver du inte nämna föräldraklassen som vi gjorde i "Djur.__init __ (själv, "katt", "köttätande däggdjur") " men super () -funktionen pekar automatiskt på föräldraklassen. Låt oss använda superfunktionen.

Produktion

Låt oss nu lägga till några fler funktioner i barnklasserna. Varje klass ärver de vanliga egenskaperna och funktionerna från föräldraklassen, men barnklassen kan ha lite extra klass som är avsedd för just den här klassen. Låt oss nu skapa några extra egenskaper och funktioner i hund- och kattklassen.

# skapar föräldraklass
klass Djur:
#initialiseringsfunktion
#initilisering av djurets namn och typ av typ
def __init __ (själv, namn, specifik_typ):
själv.namn = namn
själv.specie_type = specie_type
# en funktion för att skriva ut djurets namn
def trycknamn (själv):
tryck ("Namnet på djuret är:", själv.namn)
# en funktion för att skriva ut djurartstypen
def printspecie (själv):
tryck ("Typen av specie är:", själv.specie_type)
# skapar hundklassen som barnklass i djurklassen
klass Hund (djur):
# använder super () -funktionen
#pet name är nyligen tillagd funktionalitet
def __init __ (själv, namn, specie_type, pet_name):
super().__init __ (namn, specifik_typ)
själv.pet_name = pet_name
# skapar en ny funktion
def printpetname (själv):
tryck ("Husdjurets namn är:", själv.husdjursnamn)
# nu har hundklassen tillgång till alla funktioner och egenskaper hos djurklassen
# skapa hundklassobjektet
dogObj = Hund ("Hund", "köttätare", "Max")
hundObj.Skriv namn()
hundObj.utskriftsart ()
hundObj.printpetname ()
# skapar kattklassen som barnklass i djurklassen
klass Katt (djur):
# initialiseringsfunktionen för kattklassen
# använder super () -funktionen
#adding food och pet_name egenskaper
def __init __ (själv, namn, specifik_typ, mat, husdjursnamn):
super().__init __ (namn, specifik_typ)
själv.mat = mat
själv.pet_name = pet_name
# ny funktion för att få tillgång till matinfo
def tryckmat (själv):
tryck ("Katten gillar:", själv.mat)
# ny funktion för husdjursnamn
def printpetname (själv):
tryck ("Husdjurets namn är:", själv.husdjursnamn)
#now cat class har tillgång till alla funktioner och egenskaper hos djurklassen
#creating the cat class object
catObj = Cat ("katt", "köttätande däggdjur", "Kex", "Daisy")
catObj.Skriv namn()
catObj.utskriftsart ()

Produktion

Funktionernas åsidosättande

Funktionens åsidosättande är det viktiga begreppet i arv. En funktion kallas en åsidosatt funktion om namnet på funktionen är densamma i föräldra- och barnklasser men funktionens implementering eller funktionalitet är olika i varje klass. Låt oss se exemplet med åsidosatt funktion i djurklassen. I exemplet nedan har vi en ätfunktion i djurklasserna och dess barnklasser (hund och katt) också. Funktionens namn är samma i klasserna men implementeringen är annorlunda.

# skapar föräldraklass
klass Djur:
def eat (själv):
tryck ("Alla djur äter mat")
# skapande objekt
animalObj = Animal ()
#calling-funktion
djurObj.äta()
#creating dog class
klass Hund (djur):
def eat (själv):
tryck ("Hunden äter kött")
# skapande objekt
dogObj = Hund ()
#calling-funktion
hundObj.äta()
klass Katt (djur):
def eat (själv):
tryck ("Katten äter kex och lite specialmat")
# skapande objekt
catObj = Cat ()
#calling-funktion
catObj.äta()

Produktion

Slutsats

Arv är ett av de grundläggande begreppen för objektorienterade programmeringsspråk. Genom att använda arv skapar vi barnklasserna som ärver alla funktioner och egenskaper hos moderklassen. Arv främjar återanvändbarhet av koden. Den här artikeln förklarar arvet i Python med exempel.