En Python, la función super() se utiliza para hacer referencia a la clase principal o superclase. Le permite llamar a métodos definidos en la superclase desde la subclase, lo que le permite ampliar y personalizar la funcionalidad heredada de la clase principal.
Sintaxis de super() en Python
Sintaxis: súper()
Devolver : Devuelve un objeto proxy que representa la clase principal.
Función super() en el ejemplo de Python
En el ejemplo dado, el Empezar la clase tiene un __caliente__ método que inicializa el identificación , y nombre y Agrega atributos. El Lanza libre la clase hereda de la Empezar clase y agrega un atributo adicional llamado Correos electrónicos. Llama al método __init__ super() de la clase principal para inicializar el atributo heredado.
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)> |
>
>
Producción :
The ID is: 103 The Name is: Suraj kr gupta The Address is: Noida The Emails is: KKK@gmails>
¿Para qué se utiliza el método super()?
Se puede llamar a un método de una clase principal en Python usando la función super(). Es una práctica típica en programación orientada a objetos para llamar a los métodos de la superclase y habilitar la anulación y herencia de métodos. Incluso si la clase actual ha reemplazado esos métodos con su propia implementación, llamar a super() le permite acceder y utilizar los métodos de la clase principal. Al hacer esto, puede mejorar y modificar el comportamiento de la clase principal y al mismo tiempo beneficiarse de ello.
Beneficios de la súper función
- No es necesario recordar ni especificar el nombre de la clase principal para acceder a sus métodos. Esta función se puede utilizar tanto en herencias únicas como múltiples.
- Esto implementa modularidad (aislar cambios) y reutilización del código, ya que no es necesario reescribir la función completa.
- La superfunción en Python se llama dinámicamente porque Python es un lenguaje dinámico, a diferencia de otros lenguajes.
¿Cómo funciona la herencia sin Python super?
En el ejemplo dado, hay un problema con el método __init__ de la clase Emp. La clase Emp se hereda de la clase Person, pero en su método __init__, no llama al método __init__ de la clase principal para inicializar los atributos de nombre e identificación.
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> |
>
>
Producción :
--------------------------------------------------------------------------- AttributeError Traceback (most recent call last) in 24 25 # calling parent class function --->26 Emp_details.name_, Emp_details.name AttributeError: el objeto 'Emp' no tiene atributo 'name'>
Solucionando el problema anterior con Super en Python
En el código proporcionado, la clase Emp hereda correctamente de la clase Person, y el método __init__ de la clase Emp ahora llama correctamente al método __init__ de la clase principal usando super() en 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)> |
>
>
Producción :
Mayank Mayank>
Comprender Python super() con métodos __init__()
Python tiene un método reservado llamado __init__. En programación orientada a objetos, se le conoce como constructor. Cuando se llama a este método, permite que la clase inicialice los atributos de la clase. En una subclase heredada, se puede hacer referencia a una clase principal mediante el uso de la función super(). La superfunción devuelve un objeto temporal de la superclase que permite el acceso a todos sus métodos a su clase hija.
Nota: Para obtener más información, consulte Herencia en Python .
Súper función con herencia única
Tomemos el ejemplo de los animales. Los perros, gatos y vacas son parte de los animales. También comparten características comunes como:
- Son mamíferos.
- Tienen cola y cuatro patas.
- Son animales domésticos.
Entonces, las clases perros, gatos y caballos son una subclase de la clase animal. Este es un ejemplo de herencia única porque muchas subclases se heredan de una clase monoparental.
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()> |
>
>
Producción :
¿Qué tan grande es mi monitor?
It is a mammal. Has legs and tail>
Súper con múltiples herencias
tomemos otro ejemplo de una superfunción , Supongamos una clase puede volar y puede nadar heredan de una clase de mamíferos y estas clases son heredadas por la clase animal. Entonces la clase animal hereda de las múltiples clases base. Veamos el uso de Pitón super con argumentos en este caso.
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'>)> |
>
>
Producción :
La clase Animal hereda de clases biparentales: canFly y canSwim. Entonces, la instancia de la subclase Carol puede acceder a ambos constructores de la clase principal.
Dog cannot fly Dog cannot swim Dog Is a mammal>
Super con herencia multinivel
tomemos otro ejemplo de una superfunción , supongamos que canFly hereda una clase que puede nadar y canFly de la clase mamífero. Entonces la clase de mamíferos hereda de la herencia multinivel. Veamos el uso de Pitón super con argumentos en este caso.
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'>)> |
>
>
Producción :
Dog cannot swim Dog cannot fly Dog Is a mammal>
Herencia múltiple de Python y MRO
En el ejemplo dado, la clase C hereda de las clases A y B y anula el método age(). Sin embargo, en el método age() de la clase C, la línea super(C, self).age() invoca el método age() de la siguiente clase en el MRO. En este caso, invocará el método age() de la clase A ya que aparece antes de la clase B en el 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())> |
>
>
Producción :
(, , , ) [, , , ]>