Pythonissa super()-funktiota käytetään viittaamaan pääluokkaan tai superluokkaan. Sen avulla voit kutsua superluokassa määriteltyjä menetelmiä alaluokasta, jolloin voit laajentaa ja mukauttaa yläluokasta perittyjä toimintoja.
Super()-syntaksi Pythonissa
Syntaksi: super()
Paluu: Palauta välityspalvelinobjekti, joka edustaa ylätason luokkaa.
super()-funktio Python-esimerkissä
Annetussa esimerkissä The Emp luokassa on __kuuma__ menetelmä, joka alustaa id , ja nimi ja Lisää attribuutteja. The Freelance luokka perii Emp luokka ja lisää ylimääräisen attribuutin nimeltä Sähköpostit. Se kutsuu emoluokan __init__-metodia super() alustaakseen perityn attribuutin.
Python 3
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)> |
>
>
Lähtö:
The ID is: 103 The Name is: Suraj kr gupta The Address is: Noida The Emails is: KKK@gmails>
Mihin super()-menetelmää käytetään?
Pääluokan menetelmää voidaan kutsua Pythonissa super()-funktiolla. Se on tyypillinen käytäntö olio-ohjelmointi kutsua superluokan menetelmiä ja ottaa käyttöön menetelmän ohitus ja periytyminen. Vaikka nykyinen luokka on korvannut nämä menetelmät omalla toteutuksellaan, kutsumalla super() voit päästä käsiksi ja käyttää emoluokan menetelmiä. Tekemällä tämän voit parantaa ja muokata vanhempien luokan käyttäytymistä samalla, kun hyödyt siitä.
Super Functionin edut
- Ei tarvitse muistaa tai määrittää pääluokan nimeä päästäksesi sen menetelmiin. Tätä toimintoa voidaan käyttää sekä yksittäisessä että useassa perinnössä.
- Tämä toteuttaa modulaarisuuden (muutosten eristäminen) ja koodin uudelleenkäytettävyyden, koska koko toimintoa ei tarvitse kirjoittaa uudelleen.
- Pythonin superfunktiota kutsutaan dynaamisesti, koska Python on dynaaminen kieli, toisin kuin muut kielet.
Kuinka perintö toimii ilman Python superia?
Annetussa esimerkissä on ongelma Emp-luokan __init__-metodissa. Emp-luokka on peritty Person-luokasta, mutta sen __init__-metodissa se ei kutsu emoluokan __init__-metodia nimen ja id-attribuuttien alustamiseksi.
Python 3
# 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> |
>
>
Lähtö:
--------------------------------------------------------------------------- AttributeError Traceback (most recent call last) in 24 25 # calling parent class function --->26 Emp_details.name_, Emp_details.name AttributeError: 'Emp' objektilla ei ole attribuuttia 'name'>
Yllä olevan ongelman korjaaminen Pythonin Superilla
Annetussa koodissa Emp-luokka perii oikein Person-luokasta, ja Emp-luokan __init__-metodi kutsuu nyt oikein emoluokan __init__-metodia käyttämällä super()-komentoa Pythonissa.
Python 3
# 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)> |
>
>
Lähtö:
Mayank Mayank>
Python super() ymmärtäminen __init__()-menetelmillä
Pythonilla on varattu menetelmä nimeltä __init__. Olio-ohjelmoinnissa sitä kutsutaan konstruktoriksi. Kun tätä menetelmää kutsutaan, se sallii luokan alustaa luokan attribuutit. Perityssä alaluokassa yläluokkaan voidaan viitata käyttämällä super()-funktiota. Superfunktio palauttaa superluokan väliaikaisen objektin, joka sallii pääsyn kaikkiin sen menetelmiin sen aliluokkaan.
Huomautus: Lisätietoja on kohdassa Perintö Pythonissa .
Supertoiminto kertaperinnöllä
Otetaan esimerkki eläimistä. Koirat, kissat ja lehmät ovat osa eläimiä. Heillä on myös yhteisiä piirteitä, kuten -
- He ovat nisäkkäitä.
- Heillä on häntä ja neljä jalkaa.
- Ne ovat kotieläimiä.
Joten luokat koirat, kissat ja hevoset ovat eläinluokan alaluokka. Tämä on esimerkki yksittäisperinnöstä, koska monet alaluokat peritään yhden ylätason luokasta.
Python 3
# 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()> |
>
>
Lähtö:
It is a mammal. Has legs and tail>
Super useilla perinnöillä
Otetaan toinen esimerkki supertoiminnosta , Oletetaan luokka voi lentää ja osaa uida periytyvät nisäkäsluokasta, ja nämä luokat periytyvät eläinluokasta. Joten eläinluokka perii useista perusluokista. Katsotaanpa käyttöä Python super argumenteilla tässä tapauksessa.
Python 3
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'>)> |
>
>
Lähtö:
Luokka Animal on perinyt kahden vanhemman luokilta – canFly ja canSwim. Joten aliluokkailmentymä Carol voi käyttää molempia yläluokan rakentajia.
Dog cannot fly Dog cannot swim Dog Is a mammal>
Super monitasoisella perinnöllä
Otetaan toinen esimerkki supertoiminnosta , oletetaan, että luokka osaa uida, on canFly perinyt, canFly nisäkäsluokasta. Joten nisäkäsluokka perii monitasoisen perinnön. Katsotaanpa käyttöä Python super argumenteilla tässä tapauksessa.
Python 3
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'>)> |
leksikografisesti
>
>
Lähtö:
Dog cannot swim Dog cannot fly Dog Is a mammal>
Python Multiple Heritance ja MRO
Annetussa esimerkissä luokka C perii luokilta A ja B, ja se ohittaa age()-metodin. Kuitenkin luokan C age()-metodissa super(C, self).age()-rivi kutsuu age()-menetelmän MRO:n seuraavasta luokasta. Tässä tapauksessa se käyttää age()-menetelmää luokasta A, koska se esiintyy ennen luokkaa B MRO:ssa.
Python 3
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())> |
>
>
Lähtö:
(, , , ) [, , , ]>