Súper Argumentos en Python

1. Súper Argumentos en Python
2. Concepto de herencia de súper usos
3. Uso preciso de superargumentos en Python
4. Use Super para pasar argumentos a constructores en la herencia múltiple de Python

El tema de este artículo es usar correctamente los argumentos super de Python. También aprenderemos sobre el concepto de súper y herencia, ejemplos apropiados de código usando argumentos súper y el concepto de clases base.

Súper Argumentos en Python

En Python, super invoca un método en otra clase. Se llama clase principal, clase base o superclase cuando una clase hereda de otra clase.

Es bastante sencillo usar super porque va directamente a la clase principal y llama a sus métodos.

Los argumentos se pueden pasar a super. Toma dos argumentos, una clase y una instancia de clase.

Código de ejemplo:

class A:
    def roo(self):
        return "roo() from A"


class B(A):
    def roo(self):
        print("roo() from B")
        return super().roo()


class C(A):
    def roo(self):
        print("roo() from C")
        return super().roo()


class D(B, C):
    def roo(self):
        print("roo() from D")
        return super(C, self).roo()


a = A()
b = B()
c = C()
d = D()
print(a.roo())
print(b.roo())
print(c.roo())
print(d.roo())

Producción :

roo() from A
roo() from B
roo() from A
roo() from C
roo() from A
roo() from D
roo() from A

Concepto de herencia de súper usos

La herencia puede parecer desconocida si no está familiarizado con los conceptos de programación orientada a objetos. En la programación orientada a objetos, la herencia se refiere a la capacidad de una clase para derivar (o heredar) atributos y comportamientos de otra clase sin implementarlos nuevamente.

La forma conveniente de entender estos conceptos es mirar un código, así que vamos a crear algunas clases para describir algunas formas.

Código de ejemplo:

class Rectangle_Shape:
    def __init__(self, len, wid):
        self.length = len
        self.width = wid

    def area(self):
        return self.length * self.width

    def perimeters(self):
        return 2 * self.length + 2 * self.width


class Square_Shape:
    def __init__(self, len):
        self.length = len

    def area(self):
        return self.length * self.length

    def perimeters(self):
        return 4 * self.length


s = Square_Shape(4)
print(s.area())
r = Rectangle_Shape(3, 5)
print(r.area())

Esta clase tiene dos clases correspondientes: Rectangle_Shape y Square_Shape.

Producción :

16
15

El ejemplo muestra dos formas que están relacionadas entre sí: un cuadrado es un tipo de rectángulo. El código no refleja esa relación, lo que da como resultado un código esencialmente repetido.

Al usar la herencia, puede reducir la cantidad de código que escribe y, al mismo tiempo, reflejar la relación del mundo real entre rectángulos y cuadrados.

Código de ejemplo:

class Rectangle_Shape:
    def __init__(self, length, width):
        self.length = length
        self.width = width

    def area(self):
        return self.length * self.width

    def perimeters(self):
        return 2 * self.length + 2 * self.width


# Making the Square_Shape class that initiates the Rectangle_Shape class
class Square_Shape(Rectangle_Shape):
    def __init__(self, len):
        super().__init__(len, len)


s = Square_Shape(4)
print(s.area())

En este caso, super() llama a init() de la clase Rectangle_Shape, que luego se usa en la clase Square_Shape sin tener que reescribir el código.

Producción :

16

Como se muestra en el ejemplo, Rectangle_Shape es la clase principal y Square_Shape es la clase secundaria.

Uso preciso de superargumentos en Python

El código para las clases M, N y O se encuentra a continuación.

class M:
    def __init__(self):
        print("M initiated successfully")


class N(M):
    def __init__(self):
        super().__init__()
        print("N initiated successfully")


class O(N):
    def __init__(self):
        super(O, self).__init__()
        print("O initiated successfully")


o = O()

Como supone el código anterior, todas las clases sobrecargan el método init() de sus padres directos. super() no necesita ningún atributo, por lo que es suficiente usarlo sin argumentos.

Producción :

M initiated successfully
N initiated successfully
O initiated successfully

Supongamos que queremos que la clase M2 salte el método init() de N pero ejecute el método init() de M en su lugar. El método init() debe heredarse de M, no de N, a pesar de que el padre directo de nuestra clase sea N.

Aquí viene la clase M2. Echemos un vistazo a su ejecución.

class M:
    def __init__(self):
        print("M initiated successfully")


class N(M):
    def __init__(self):
        super().__init__()
        print("N initiated successfully")


class O(N):
    def __init__(self):
        super(O, self).__init__()
        print("O initiated successfully")


class M2(N):
    def __init__(self):
        super(N, self).__init__()
        print("other O initiated successfully")


m2 = M2()

Se puede suponer del código anterior que pasamos atributos al método super() para seleccionar la superclase correcta esta vez. Como resultado de ejecutar m2 = M2(), obtenemos el siguiente resultado.

M initiated successfully
other O initiated successfully

En lugar de llamar al método padre directo __init__(), invocamos el método Python init() de M en su lugar.

Para búsquedas implícitas que utilizan estas declaraciones u operadores como super()[nombre], super() no está definido.

Además, super() no se limita a usar métodos internos además de la forma de argumento cero. El uso de la forma de dos argumentos identifica los argumentos exactamente y hace las referencias apropiadas.

En una definición de clase, los argumentos cero solo funcionan porque el compilador completa los detalles necesarios para recuperar la clase y la instancia.

Use Super para pasar argumentos a constructores en la herencia múltiple de Python

Una clase base debe diseñarse para múltiples herencias si trata con varias herencias en general.

Hay momentos en que dos clases tienen nombres de parámetros similares. Cuando eso sucede, no puede eliminar pares clave-valor de **kwargs ni eliminarlos de *args.

Es posible definir una clase Base, que, a diferencia de un objeto, absorbe/ignora argumentos.

Código de ejemplo:

class Base(object):
    def __init__(self, *args, **kwargs):
        pass


class P(Base):
    def __init__(self, *args, **kwargs):
        print("P")
        super(P, self).__init__(*args, **kwargs)


class Q(Base):
    def __init__(self, *args, **kwargs):
        print("Q")
        super(Q, self).__init__(*args, **kwargs)


class R(P):
    def __init__(self, arg, *args, **kwargs):
        print("R", "arguments=", arg)
        super(R, self).__init__(arg, *args, **kwargs)


class S(Q):
    def __init__(self, arg, *args, **kwargs):
        print("S", "arguments=", arg)
        super(S, self).__init__(arg, *args, **kwargs)


class T(R, S):
    def __init__(self, arg, *args, **kwargs):
        print("T", "arguments=", arg)
        super(T, self).__init__(arg, *args, **kwargs)
        print("MRO---", [x.__name__ for x in T.__mro__])


t = T(10)

Producción :

T arguments= 10
R arguments= 10
P
S arguments= 10
Q
MRO--- ['T', 'R', 'P', 'S', 'Q', 'Base', 'object']

Es importante tener en cuenta que Base debe ser la penúltima clase en el MRO para que esto funcione.

El lenguaje de programación Python proporciona una amplia gama de funciones para la programación orientada a objetos. En ese conjunto, los argumentos de la función super juegan un papel importante, especialmente cuando se usan correctamente.

Con suerte, este artículo te ha ayudado a comprender mejor cómo usar los argumentos de la función super en Python.