I Python används super()-funktionen för att referera till den överordnade klassen eller superklassen. Det låter dig anropa metoder definierade i superklassen från underklassen, vilket gör att du kan utöka och anpassa funktionaliteten som ärvts från den överordnade klassen.
Syntax för super() i Python
Syntax: super()
Lämna tillbaka : Returnera ett proxyobjekt som representerar förälderns klass.
super()-funktionen i Python-exempel
I det givna exemplet, The Emp klass har en __varm__ metod som initierar id , och namn och Lägger till attribut. De Frilans klass ärver från Emp klass och lägger till ett extra attribut som kallas E-postmeddelanden. Den anropar föräldraklassens __init__ metod super() för att initiera det ärvda attributet.
Python3
class> Emp():> >def> __init__(>self>,>id>, name, Add):> >self>.>id> => id> >self>.name>=> name> >self>.Add>=> Add> # Class freelancer inherits EMP> class> Freelance(Emp):> >def> __init__(>self>,>id>, name, Add, Emails):> >super>().__init__(>id>, name, Add)> >self>.Emails>=> Emails> Emp_1>=> Freelance(>103>,>'Suraj kr gupta'>,>'Noida'> ,>'KKK@gmails'>)> print>(>'The ID is:'>, Emp_1.>id>)> print>(>'The Name is:'>, Emp_1.name)> print>(>'The Address is:'>, Emp_1.Add)> print>(>'The Emails is:'>, Emp_1.Emails)> |
>
>
Utgång:
The ID is: 103 The Name is: Suraj kr gupta The Address is: Noida The Emails is: KKK@gmails>
Vad används super()-metoden för?
En metod från en överordnad klass kan anropas i Python med hjälp av super()-funktionen. Det är typisk övning i objektorienterad programmering att anropa superklassens metoder och möjliggöra metodöverstyrning och nedärvning. Även om den aktuella klassen har ersatt dessa metoder med sin egen implementering, låter anropet super() dig komma åt och använda den överordnade klassens metoder. Genom att göra detta kan du förbättra och ändra föräldraklassens beteende samtidigt som du får nytta av det.
lista i java
Fördelar med Super Function
- Behöver inte komma ihåg eller ange namnet på den överordnade klassen för att komma åt dess metoder. Denna funktion kan användas både i enstaka och flera arv.
- Detta implementerar modularitet (isolering av ändringar) och kodåteranvändbarhet eftersom det inte finns något behov av att skriva om hela funktionen.
- Superfunktionen i Python kallas dynamiskt eftersom Python är ett dynamiskt språk, till skillnad från andra språk.
Hur fungerar Arv utan Python super?
I det givna exemplet finns det ett problem med Emp-klassens __init__-metod. Emp-klassen ärvs från klassen Person, men i sin __init__-metod anropar den inte föräldraklassens __init__-metod för att initiera namn- och id-attributen.
Python3
# code> class> Person:> ># Constructor> >def> __init__(>self>, name,>id>):> >self>.name>=> name> >self>.>id> => id> ># To check if this person is an employee> >def> Display(>self>):> >print>(>self>.name,>self>.>id>)> > class> Emp(Person):> > >def> __init__(>self>, name,>id>):> >self>.name_>=> name> >def> Print>(>self>):> >print>(>'Emp class called'>)> Emp_details>=> Emp(>'Mayank'>,>103>)> # calling parent class function> Emp_details.name_, Emp_details.name> |
>
>
Utgång:
--------------------------------------------------------------------------- AttributeError Traceback (most recent call last) in 24 25 # calling parent class function --->26 Emp_details.name_, Emp_details.name AttributeError: 'Emp' objekt har inget attribut 'name'>
Fixar ovanstående problem med Super i Python
I den medföljande koden ärver Emp-klassen korrekt från Person-klassen, och Emp-klassens __init__-metod anropar nu förälderklassens __init__-metod med super() i Python .
karta i maskinskriven
Python3
# code> # A Python program to demonstrate inheritance> class> Person:> ># Constructor> >def> __init__(>self>, name,>id>):> >self>.name>=> name> >self>.>id> => id> ># To check if this person is an employee> >def> Display(>self>):> >print>(>self>.name,>self>.>id>)> > class> Emp(Person):> > >def> __init__(>self>, name,>id>):> >self>.name_>=> name> >super>().__init__(name,>id>)> >def> Print>(>self>):> >print>(>'Emp class called'>)> Emp_details>=> Emp(>'Mayank'>,>103>)> # calling parent class function> print>(Emp_details.name_, Emp_details.name)> |
>
>
Utgång:
Mayank Mayank>
Förstå Python super() med __init__() metoder
Python har en reserverad metod som heter __init__. I objektorienterad programmering kallas det för en konstruktör. När denna metod kallas låter den klassen initialisera klassens attribut. I en ärvd underklass kan en överordnad klass refereras till med hjälp av super()-funktionen. Superfunktionen returnerar ett temporärt objekt av superklassen som tillåter åtkomst till alla dess metoder till dess underordnade klass.
Notera: För mer information, se Arv i Python .
Superfunktion med Single Inheritance
Låt oss ta exemplet med djur. Hundar, katter och kor är en del av djur. De delar också gemensamma egenskaper som -
- De är däggdjur.
- De har en svans och fyra ben.
- De är husdjur.
Så klasserna hundar, katter och hästar är en underklass av djurklass. Detta är ett exempel på enstaka arv eftersom många underklasser ärvs från en ensamstående klass.
Python3
array vs arraylist
# Python program to demonstrate> # super function> class> Animals:> ># Initializing constructor> >def> __init__(>self>):> >self>.legs>=> 4> >self>.domestic>=> True> >self>.tail>=> True> >self>.mammals>=> True> >def> isMammal(>self>):> >if> self>.mammals:> >print>(>'It is a mammal.'>)> >def> isDomestic(>self>):> >if> self>.domestic:> >print>(>'It is a domestic animal.'>)> class> Dogs(Animals):> >def> __init__(>self>):> >super>().__init__()> >def> isMammal(>self>):> >super>().isMammal()> class> Horses(Animals):> >def> __init__(>self>):> >super>().__init__()> >def> hasTailandLegs(>self>):> >if> self>.tail>and> self>.legs>=>=> 4>:> >print>(>'Has legs and tail'>)> # Driver code> Tom>=> Dogs()> Tom.isMammal()> Bruno>=> Horses()> Bruno.hasTailandLegs()> |
>
>
Utgång:
It is a mammal. Has legs and tail>
Super med flera arv
Låt oss ta en annan exempel på en superfunktion , Antag en klass kan flyga och kan simma ärver från en däggdjursklass och dessa klasser ärvs av djurklassen. Så djurklassen ärver från de multipla basklasserna. Låt oss se användningen av Pytonorm super med argument I detta fall.
Python3
class> Mammal():> >def> __init__(>self>, name):> >print>(name,>'Is a mammal'>)> class> canFly(Mammal):> >def> __init__(>self>, canFly_name):> >print>(canFly_name,>'cannot fly'>)> ># Calling Parent class> ># Constructor> >super>().__init__(canFly_name)> class> canSwim(Mammal):> >def> __init__(>self>, canSwim_name):> >print>(canSwim_name,>'cannot swim'>)> >super>().__init__(canSwim_name)> class> Animal(canFly, canSwim):> >def> __init__(>self>, name):> >super>().__init__(name)> # Driver Code> Carol>=> Animal(>'Dog'>)> |
indiska skådespelerskan rani mukerji
>
>
Utgång:
Klassen Djur ärver från tvåförälderklasser – canFly och canSwim. Så underklassinstansen Carol kan komma åt båda de överordnade klasskonstruktörerna.
Dog cannot fly Dog cannot swim Dog Is a mammal>
Super med Multi-Level Arv
Låt oss ta en annan exempel på en superfunktion , anta att en klass kan simma ärvs av canFly, canFly från däggdjursklassen. Så däggdjursklassen ärver från arvet på flera nivåer. Låt oss se användningen av Pytonorm super med argument I detta fall.
Python3
class> Mammal():> >def> __init__(>self>, name):> >print>(name,>'Is a mammal'>)> class> canFly(Mammal):> >def> __init__(>self>, canFly_name):> >print>(canFly_name,>'cannot fly'>)> ># Calling Parent class> ># Constructor> >super>().__init__(canFly_name)> class> canSwim(canFly):> >def> __init__(>self>, canSwim_name):> >print>(canSwim_name,>'cannot swim'>)> >super>().__init__(canSwim_name)> class> Animal(canSwim):> >def> __init__(>self>, name):> ># Calling the constructor> ># of both the parent> ># class in the order of> ># their inheritance> >super>().__init__(name)> # Driver Code> Carol>=> Animal(>'Dog'>)> |
>
pd.fusion
>
Utgång:
Dog cannot swim Dog cannot fly Dog Is a mammal>
Python Multiple Inheritance och MRO
I det givna exemplet ärver klass C från klasserna A och B, och den åsidosätter age()-metoden. Men i age()-metoden för klass C, anropar super(C, self).age()-raden metoden age() från nästa klass i MRO. I det här fallet kommer den att anropa age()-metoden från klass A eftersom den visas före klass B i MRO.
Python3
class> A:> >def> age(>self>):> >print>(>'Age is 21'>)> class> B:> >def> age(>self>):> >print>(>'Age is 23'>)> class> C(A, B):> >def> age(>self>):> >super>(C,>self>).age()> > c>=> C()> print>(C.__mro__)> print>(C.mro())> |
>
>
Utgång:
(, , , ) [, , , ]>