A Python, la funció super() s'utilitza per referir-se a la classe o superclasse pare. Us permet cridar mètodes definits a la superclasse des de la subclasse, la qual cosa us permet ampliar i personalitzar la funcionalitat heretada de la classe pare.
Sintaxi de super() a Python
Sintaxi: super()
Tornada: Retorna un objecte proxy que representa la classe dels pares.
funció super() a Python Exemple
En l'exemple donat, The Emp la classe té un __calent__ mètode que inicialitza el id , i nom i Afegeix atributs. El Autònom classe hereta de la Emp class i afegeix un atribut addicional anomenat Correus electrònics. Crida al mètode __init__ super() de la classe pare per inicialitzar l'atribut heretat.
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)> |
>
>
Sortida:
The ID is: 103 The Name is: Suraj kr gupta The Address is: Noida The Emails is: KKK@gmails>
Per a què serveix el mètode súper ()?
Un mètode d'una classe pare es pot cridar a Python mitjançant la funció super(). És una pràctica típica a programació orientada a objectes per cridar els mètodes de la superclasse i habilitar la substitució i l'herència de mètodes. Fins i tot si la classe actual ha substituït aquests mètodes per la seva pròpia implementació, cridar a super() us permet accedir i utilitzar els mètodes de la classe pare. D'aquesta manera, podeu millorar i modificar el comportament de la classe pare mentre continueu guanyant-ne.
Beneficis de Super Function
- No cal recordar ni especificar el nom de la classe pare per accedir als seus mètodes. Aquesta funció es pot utilitzar tant en herències simples com múltiples.
- Això implementa la modularitat (aïllant els canvis) i la reutilització del codi, ja que no cal reescriure tota la funció.
- La superfunció de Python s'anomena dinàmicament perquè Python és un llenguatge dinàmic, a diferència d'altres llenguatges.
Com funciona l'herència sense Python super?
A l'exemple donat, hi ha un problema amb el mètode __init__ de la classe Emp. La classe Emp s'hereta de la classe Person, però en el seu mètode __init__, no crida al mètode __init__ de la classe pare per inicialitzar els atributs name i id.
Python 3
bucle del programa java
# 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> |
>
>
Sortida:
--------------------------------------------------------------------------- AttributeError Traceback (most recent call last) in 24 25 # calling parent class function --->26 Emp_details.name_, Emp_details.name AttributeError: L'objecte 'Emp' no té cap atribut 'name'>
Solucionant el problema anterior amb Super a Python
Al codi proporcionat, la classe Emp hereta correctament de la classe Person, i el mètode __init__ de la classe Emp està cridant correctament el mètode __init__ de la classe pare mitjançant super() a Python.
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)> |
>
>
Sortida:
Mayank Mayank>
Comprensió de Python super() amb mètodes __init__().
Python té un mètode reservat anomenat __init__. A la programació orientada a objectes, es coneix com a constructor. Quan s'anomena aquest mètode, permet a la classe inicialitzar els atributs de la classe. En una subclasse heretada, es pot fer referència a una classe pare amb l'ús de la funció super(). La superfunció retorna un objecte temporal de la superclasse que permet l'accés a tots els seus mètodes a la seva classe fill.
Nota: Per a més informació, consulteu Herència en Python .
Super funció amb herència única
Prenguem l'exemple dels animals. Els gossos, els gats i les vaques formen part dels animals. També comparteixen característiques comunes com:
- Són mamífers.
- Tenen cua i quatre potes.
- Són animals domèstics.
Per tant, les classes gossos, gats i cavalls són una subclasse de la classe animal. Aquest és un exemple d'herència única perquè moltes subclasses s'hereten d'una classe monoparental.
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()> |
>
>
Sortida:
It is a mammal. Has legs and tail>
Super amb múltiples herències
Agafem-ne un altre exemple de superfunció , Suposem una classe Poder volar i pot nedar hereten d'una classe de mamífers i aquestes classes són heretades per la classe animal. Així, la classe animal hereta de les múltiples classes base. Vegem l'ús de Python super amb arguments en aquest cas.
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'>)> |
>
>
Sortida:
La classe Animal hereta de classes biparentals: canFly i canSwim. Per tant, la instància de subclasse Carol pot accedir als dos constructors de classe pare.
Dog cannot fly Dog cannot swim Dog Is a mammal>
Super amb herència multinivell
Agafem-ne un altre exemple de superfunció , suposem que una classe pot nedar és heretada per canFly, canFly de la classe de mamífers. Així, la classe de mamífers hereta de l'herència multinivell. Vegem l'ús de Python super amb arguments en aquest cas.
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'>)> |
>
>
Sortida:
Dog cannot swim Dog cannot fly Dog Is a mammal>
Herència múltiple de Python i MRO
En l'exemple donat, la classe C hereta de les classes A i B, i anul·la el mètode age(). Tanmateix, en el mètode age() de la classe C, la línia super(C, self).age() invoca el mètode age() de la classe següent a l'MRO. En aquest cas, invocarà el mètode age() de la classe A ja que apareix abans de la classe B a l'MRO.
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())> |
>
>
Sortida:
(, , , ) [, , , ]>