In Python wordt de functie super() gebruikt om naar de bovenliggende klasse of superklasse te verwijzen. Hiermee kunt u methoden die in de superklasse zijn gedefinieerd vanuit de subklasse aanroepen, waardoor u de functionaliteit die u van de bovenliggende klasse hebt overgenomen, kunt uitbreiden en aanpassen.
Syntaxis van super() in Python
Syntaxis: super()
Opbrengst : Retourneert een proxy-object dat de klasse van de ouder vertegenwoordigt.
super() functie in Python-voorbeeld
In het gegeven voorbeeld is The Emp klas heeft een __heet__ methode die de ID kaart , En naam En Voegt toe attributen. De Freelancer klasse erft van de Emp class en voegt een extra attribuut toe genaamd E-mails. Het roept de __init__-methode super() van de bovenliggende klasse aan om het overgenomen attribuut te initialiseren.
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)> |
>
>
Uitgang:
javapunt java
The ID is: 103 The Name is: Suraj kr gupta The Address is: Noida The Emails is: KKK@gmails>
Waar wordt de super()-methode voor gebruikt?
Een methode uit een bovenliggende klasse kan in Python worden aangeroepen met behulp van de functie super(). Het is een typische praktijk in object georiënteerd programmeren om de methoden van de superklasse aan te roepen en het overschrijven en overerven van methoden mogelijk te maken. Zelfs als de huidige klasse deze methoden heeft vervangen door een eigen implementatie, kun je door het aanroepen van super() toegang krijgen tot de methoden van de bovenliggende klasse en deze gebruiken. Door dit te doen, kunt u het gedrag van de ouderklasse verbeteren en wijzigen, terwijl u er nog steeds voordeel uit haalt.
Voordelen van superfunctie
- U hoeft de naam van de bovenliggende klasse niet te onthouden of op te geven om toegang te krijgen tot de methoden ervan. Deze functie kan zowel bij enkele als bij meervoudige overervingen worden gebruikt.
- Dit implementeert modulariteit (het isoleren van wijzigingen) en herbruikbaarheid van code, aangezien het niet nodig is om de hele functie te herschrijven.
- De superfunctie in Python wordt dynamisch aangeroepen omdat Python een dynamische taal is, in tegenstelling tot andere talen.
Hoe werkt Overerving zonder Python super?
In het gegeven voorbeeld is er een probleem met de __init__-methode van de klasse Emp. De klasse Emp wordt overgenomen van de klasse Person, maar roept in zijn methode __init__ niet de methode __init__ van de bovenliggende klasse aan om de attributen name en id te initialiseren.
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> |
>
>
Uitgang:
Madhuri zei: kom op
--------------------------------------------------------------------------- AttributeError Traceback (most recent call last) in 24 25 # calling parent class function --->26 Emp_details.name_, Emp_details.name AttributeError: 'Emp' object heeft geen attribuut 'name'>
Het bovenstaande probleem oplossen met Super in Python
In de geleverde code erft de klasse Emp correct van de klasse Person, en de __init__-methode van de Emp-klasse roept nu op de juiste manier de __init__-methode van de bovenliggende klasse aan met behulp van super() in 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)> |
>
>
Uitgang:
Mayank Mayank>
Python super() begrijpen met __init__() methoden
Python heeft een gereserveerde methode genaamd __init__. Bij objectgeoriënteerd programmeren wordt dit een constructor genoemd. Wanneer deze methode wordt aangeroepen, kan de klasse de attributen van de klasse initialiseren. In een overgeërfde subklasse kan naar een bovenliggende klasse worden verwezen met behulp van de functie super(). De superfunctie retourneert een tijdelijk object van de superklasse dat toegang geeft tot alle methoden van de onderliggende klasse.
Opmerking: Voor meer informatie, zie Overerving in Python .
Superfunctie met enkelvoudige erfenis
Laten we het voorbeeld van dieren nemen. Honden, katten en koeien maken deel uit van dieren. Ze delen ook gemeenschappelijke kenmerken zoals –
- Het zijn zoogdieren.
- Ze hebben een staart en vier poten.
- Het zijn huisdieren.
De klassen honden, katten en paarden zijn dus een subklasse van de dierenklasse. Dit is een voorbeeld van enkelvoudige overerving, omdat veel subklassen worden geërfd van een klasse met één ouder.
Python3
tring naar int
# 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()> |
>
>
Uitgang:
It is a mammal. Has legs and tail>
Super met meerdere erfenissen
Laten we er nog een nemen voorbeeld van een superfunctie , Stel dat het een klas is kan vliegen En kan zwemmen erven van een zoogdierklasse en deze klassen worden geërfd door de dierenklasse. De dierenklasse erft dus van de meerdere basisklassen. Laten we eens kijken naar het gebruik van Python super met argumenten in dit geval.
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'>)> |
eenvoudig Python-programma
>
>
Uitgang:
De klasse Animal erft van klassen met twee ouders: canFly en canSwim. De subklasse-instantie Carol heeft dus toegang tot beide constructors van de bovenliggende klasse.
Dog cannot fly Dog cannot swim Dog Is a mammal>
Super met overerving op meerdere niveaus
Laten we er nog een nemen voorbeeld van een superfunctie Stel dat een klasse kan zwemmen wordt geërfd door canFly, canFly van de zoogdierklasse. Dus de zoogdierklasse erft van de Multi-Level-overerving. Laten we eens kijken naar het gebruik van Python super met argumenten in dit geval.
Python3
lijst Java
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'>)> |
>
>
Uitgang:
Dog cannot swim Dog cannot fly Dog Is a mammal>
Python meervoudige overerving en MRO
In het gegeven voorbeeld erft klasse C van de klassen A en B, en overschrijft deze de methode age(). In de age()-methode van klasse C roept de lijn super(C, self).age() echter de age()-methode aan uit de volgende klasse in de MRO. In dit geval zal het de methode age() uit klasse A aanroepen, aangezien deze vóór klasse B in de MRO verschijnt.
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())> |
>
>
Uitgang:
(, , , ) [, , , ]>