I Python bruges super()-funktionen til at henvise til den overordnede klasse eller superklasse. Det giver dig mulighed for at kalde metoder defineret i superklassen fra underklassen, hvilket gør det muligt for dig at udvide og tilpasse den funktionalitet, der er arvet fra den overordnede klasse.
Syntaks for super() i Python
Syntaks: super()
Vend tilbage : Returner et proxy-objekt, som repræsenterer overordnets klasse.
super() funktion i Python Eksempel
I det givne eksempel er The Emp klasse har en __hed__ metode, der initialiserer id , og navn og Tilføjer egenskaber. Det Freelance klasse arver fra Emp klasse og tilføjer en ekstra attribut kaldet E-mails. Den kalder forældreklassens __init__ metode super() for at initialisere den nedarvede attribut.
Python3
mylive cricket
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)> |
>
>
Output:
The ID is: 103 The Name is: Suraj kr gupta The Address is: Noida The Emails is: KKK@gmails>
Hvad bruges super() metoden til?
En metode fra en overordnet klasse kan kaldes i Python ved hjælp af super()-funktionen. Det er typisk praksis i objektorienteret programmering at kalde superklassens metoder og muliggøre metodeoverstyring og nedarvning. Selvom den nuværende klasse har erstattet disse metoder med sin egen implementering, giver kald af super() dig mulighed for at få adgang til og bruge den overordnede klasses metoder. Ved at gøre dette kan du forbedre og ændre forældreklassens adfærd, mens du stadig får noget ud af det.
Fordele ved Super Function
- Behøver ikke at huske eller angive det overordnede klassenavn for at få adgang til dens metoder. Denne funktion kan bruges både i enkelt- og multiple arv.
- Dette implementerer modularitet (isolering af ændringer) og kodegenanvendelighed, da der ikke er behov for at omskrive hele funktionen.
- Superfunktionen i Python kaldes dynamisk, fordi Python er et dynamisk sprog i modsætning til andre sprog.
Hvordan fungerer arv uden Python super?
I det givne eksempel er der et problem med Emp-klassens __init__-metode. Emp-klassen er nedarvet fra Person-klassen, men i dens __init__-metode kalder den ikke moderklassens __init__-metode for at initialisere navn og id-attributter.
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> |
>
>
Output:
--------------------------------------------------------------------------- AttributeError Traceback (most recent call last) in 24 25 # calling parent class function --->26 Emp_details.name_, Emp_details.name AttributeError: 'Emp' objekt har ingen attribut 'name'>
Løsning af ovenstående problem med Super i Python
I den medfølgende kode arver Emp-klassen korrekt fra Person-klassen, og Emp-klassens __init__-metode kalder nu forælderklassens __init__-metode korrekt ved hjælp af super() i Python.
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)> |
>
>
Output:
Mayank Mayank>
Forstå Python super() med __init__() metoder
Python har en reserveret metode kaldet __init__. I objektorienteret programmering omtales det som en konstruktør. Når denne metode kaldes, tillader den klassen at initialisere klassens attributter. I en nedarvet underklasse kan en overordnet klasse henvises til ved brug af super()-funktionen. Superfunktionen returnerer et midlertidigt objekt af superklassen, der giver adgang til alle dens metoder til dens underklasse.
Bemærk: For mere information, se Arv i Python .
Super funktion med Single Inheritance
Lad os tage eksemplet med dyr. Hunde, katte og køer er en del af dyr. De deler også fælles egenskaber som -
okse vs tyr
- De er pattedyr.
- De har en hale og fire ben.
- De er husdyr.
Så klasserne hunde, katte og heste er en underklasse af dyreklassen. Dette er et eksempel på enkeltarv, fordi mange underklasser er nedarvet fra en enkeltforælderklasse.
Python3
# 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()> |
>
>
Output:
It is a mammal. Has legs and tail>
Super med flere arv
Lad os tage en anden eksempel på en super funktion , Antag en klasse kan flyve og kan svømme arver fra en pattedyrklasse, og disse klasser nedarves af dyreklassen. Så dyreklassen arver fra de flere basisklasser. Lad os se brugen af Python super med argumenter I dette tilfælde.
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'>)> |
sort arraylist java
>
>
Output:
Klassen Dyr arver fra to-forældre klasser – canFly og canSwim. Så underklasseinstansen Carol kan få adgang til begge de overordnede klassekonstruktører.
Dog cannot fly Dog cannot swim Dog Is a mammal>
Super med Multi-Level Arv
Lad os tage en anden eksempel på en super funktion , antag at en klasse kan svømme er arvet af canFly, canFly fra pattedyrsklassen. Så pattedyrklassen arver fra Multi-Level-arven. Lad os se brugen af Python super med argumenter I dette tilfælde.
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'>)> |
>
>
Output:
Dog cannot swim Dog cannot fly Dog Is a mammal>
Python Multiple Inheritance og MRO
I det givne eksempel arver klasse C fra klasse A og B, og den tilsidesætter age()-metoden. I age()-metoden i klasse C, kalder super(C, self).age()-linjen dog age()-metoden fra den næste klasse i MRO. I dette tilfælde vil det påkalde age()-metoden fra klasse A, da den vises før klasse 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())> |
>
>
Output:
(, , , ) [, , , ]>