W Pythonie funkcja super() służy do odwoływania się do klasy nadrzędnej lub nadklasy. Umożliwia wywoływanie metod zdefiniowanych w nadklasie z podklasy, umożliwiając rozszerzenie i dostosowanie funkcjonalności odziedziczonej z klasy nadrzędnej.
Składnia super() w Pythonie
Składnia: Super()
wydrukuj z JavyPowrót : Zwraca obiekt proxy reprezentujący klasę rodzica.
funkcja super() w przykładzie Pythona
W podanym przykładzie The Emp klasa ma __gorący__ metoda inicjująca ID , I nazwa I Dodaje atrybuty. The Wolny zawód klasa dziedziczy z Emp class i dodaje dodatkowy atrybut o nazwie E-maile. Wywołuje metodę __init__ klasy nadrzędnej super() w celu zainicjowania odziedziczonego atrybutu.
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)> |
>
>
Wyjście :
The ID is: 103 The Name is: Suraj kr gupta The Address is: Noida The Emails is: KKK@gmails>
Do czego służy metoda super()?
Metodę z klasy nadrzędnej można wywołać w Pythonie za pomocą funkcji super(). To typowa praktyka w programowanie obiektowe do wywoływania metod nadklasy i umożliwiania przesłaniania i dziedziczenia metod. Nawet jeśli bieżąca klasa zastąpiła te metody własną implementacją, wywołanie super() umożliwia dostęp do metod klasy nadrzędnej i korzystanie z nich. Robiąc to, możesz ulepszyć i zmodyfikować zachowanie klasy nadrzędnej, jednocześnie czerpiąc z tego korzyści.
Korzyści z superfunkcji
- Nie trzeba pamiętać ani podawać nazwy klasy nadrzędnej, aby uzyskać dostęp do jej metod. Funkcji tej można używać zarówno w przypadku dziedziczenia pojedynczego, jak i wielokrotnego.
- Implementuje to modułowość (izolowanie zmian) i możliwość ponownego użycia kodu, ponieważ nie ma potrzeby przepisywania całej funkcji.
- Super funkcja w Pythonie jest wywoływana dynamicznie, ponieważ Python jest językiem dynamicznym, w przeciwieństwie do innych języków.
Jak działa dziedziczenie bez super Pythona?
W podanym przykładzie występuje problem z metodą __init__ klasy Emp. Klasa Emp jest dziedziczona z klasy Person, ale w swojej metodzie __init__ nie wywołuje metody __init__ klasy nadrzędnej w celu zainicjowania atrybutów name i id.
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> |
>
>
Wyjście :
--------------------------------------------------------------------------- AttributeError Traceback (most recent call last) in 24 25 # calling parent class function --->26 Emp_details.name_, Emp_details.name AttributeError: Obiekt 'Emp' nie ma atrybutu 'name'>
Naprawienie powyższego problemu za pomocą Super w Pythonie
W dostarczonym kodzie klasa Emp poprawnie dziedziczy po klasie Person, a metoda __init__ klasy Emp poprawnie wywołuje teraz metodę __init__ klasy nadrzędnej za pomocą super() w Pythonie.
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)> |
>
>
Wyjście :
Mayank Mayank>
Zrozumienie Pythona super() z metodami __init__().
Python ma zastrzeżoną metodę o nazwie __init__. W programowaniu obiektowym nazywa się to konstruktorem. Wywołanie tej metody umożliwia klasie inicjalizację atrybutów klasy. W dziedziczonej podklasie do klasy nadrzędnej można odwołać się za pomocą funkcji super(). Funkcja super zwraca tymczasowy obiekt nadklasy, który umożliwia dostęp do wszystkich jej metod w klasie podrzędnej.
Notatka: Aby uzyskać więcej informacji, zobacz Dziedziczenie w Pythonie .
Super funkcja z pojedynczym dziedziczeniem
Weźmy przykład zwierząt. Psy, koty i krowy są częścią zwierząt. Mają także wspólne cechy, takie jak –
- Są ssakami.
- Mają ogon i cztery nogi.
- Są zwierzętami domowymi.
Zatem klasy psy, koty i konie stanowią podklasę klasy zwierząt. Jest to przykład pojedynczego dziedziczenia, ponieważ wiele podklas jest dziedziczonych z klasy z jednym rodzicem.
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()> |
>
>
Wyjście :
It is a mammal. Has legs and tail>
Super z wielokrotnym dziedziczeniem
Weźmy inny przykład superfunkcji , Załóżmy, że mamy klasę umie latać I potrafi pływać dziedziczą po klasie ssaków, a klasy te są dziedziczone przez klasę zwierząt. Zatem klasa zwierzęca dziedziczy po wielu klasach bazowych. Zobaczmy użycie Pyton super z argumentami w tym przypadku.
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'>)> |
>
>
Wyjście :
Klasa Animal dziedziczy z klas dwóch rodziców – canFly i canSwim. Zatem instancja podklasy Carol może uzyskać dostęp do obu konstruktorów klas nadrzędnych.
Dog cannot fly Dog cannot swim Dog Is a mammal>
Super z dziedziczeniem wielopoziomowym
Weźmy inny przykład superfunkcji , załóżmy, że klasa potrafi pływać jest dziedziczona przez canFly, canFly z klasy ssaków. Zatem klasa ssaków dziedziczy z dziedziczenia wielopoziomowego. Zobaczmy użycie Pyton super z argumentami w tym przypadku.
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'>)> |
>
>
Wyjście :
wyrażenia lambda w Javie
Dog cannot swim Dog cannot fly Dog Is a mammal>
Dziedziczenie wielokrotne w Pythonie i MRO
W podanym przykładzie klasa C dziedziczy po klasach A i B i zastępuje metodę age(). Jednakże w metodzie age() klasy C linia super(C, self).age() wywołuje metodę age() z następnej klasy w MRO. W tym przypadku wywoła metodę age() z klasy A, ponieważ występuje ona przed klasą B w 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())> |
>
>
Wyjście :
(, , , ) [, , , ]>