Operador de sobrecarga en Python

1. Operadores de sobrecarga en Python
2. Sobrecargar el operador + en Python
3. Sobrecargar el operador > en Python
4. Sobrecargue el operador == en Python

La sobrecarga de operadores significa cambiar la forma en que los operadores se comportan en diferentes situaciones. Es un tipo de polimorfismo.

Con la sobrecarga de operadores, podemos agregar significado o funcionalidad adicional a un operador para realizar más de una operación.

Por ejemplo, el operador + realiza sumas con operandos enteros. Pero cuando se usa con operandos de cadena, realiza la concatenación porque el operador + está sobrecargado.

Operadores de sobrecarga en Python

Python proporciona una forma de sobrecargar a los operadores con tipos de datos definidos por el usuario a través de los métodos mágicos. Estos son métodos especiales que se invocan automáticamente cuando usamos el operador asociado a ellos.

También se conocen como métodos de Dunder porque comienzan y terminan con un doble guión bajo.

Por ejemplo, cuando escribimos el operador +, el método mágico __add__() se llama automáticamente en el backend. Por lo tanto, si queremos realizar una sobrecarga de operadores con ciertos operadores, solo tenemos que cambiar el código de sus métodos mágicos.

Sobrecargar el operador + en Python

En el siguiente código, tenemos una clase definida por el usuario en la que hemos implementado el método mágico __add__() para sobrecargar el operador +.

Cuando escribimos int1 + int2, en realidad en el back-end, el método mágico __add()__ se llama int1.__add__(int2). El mismo funcionamiento se aplica a las cuerdas también.

Cuando escribimos str1 + str2, internamente el método mágico se llama str1.__add__(str2).

Código de ejemplo:

# Python 3.x
class MyAddion:
    def __init__(self, a):
        self.a = a

    def __add__(self, b):
        return self.a + b.a


int1 = MyAddion(2)
int2 = MyAddion(2)
str1 = MyAddion("Delft")
str2 = MyAddion("Stack")
print(int1 + int2)
print(str1 + str2)

Producción :

#Python 3.x
4
DelftStack

Sobrecargar el operador > en Python

Aquí, hemos sobrecargado el operador > en la clase MyComp. Cuando escribimos el operador >, se invoca internamente el método mágico __gt__().

Entonces, cuando escribimos int1 > int2, el método mágico __gt__() se llama int1.__gt__(int2). Este método devuelve true si la condición es verdadera; de lo contrario, devuelve false.

Código de ejemplo:

# Python 3.x
class MyComp:
    def __init__(self, a):
        self.a = a

    def __gt__(self, b):
        if self.a > b.a:
            return True
        else:
            return False


int1 = MyComp(5)
int2 = MyComp(3)
if int1 > int2:
    print(int1.a, "is greater than", int2.a)
else:
    print(int2.a, "is greater than", int1.a)

Producción :

#Python 3.x
5 is greater than 3

Sobrecargue el operador == en Python

Aquí, hemos sobrecargado el operador de igualdad == en nuestra clase MyEquality. Cuando escribimos int1 == int2, internamente se invocará el método mágico __eq__() como int1.__eq__(int2).

Si ambos operandos son iguales, devolverá Igual; de lo contrario, devolverá No es igual.

Código de ejemplo:

# Python 3.x
class MyEquality:
    def __init__(self, a):
        self.a = a

    def __eq__(self, b):
        if self.a == b.a:
            return "Equal"
        else:
            return "Not equal"


int1 = MyEquality(3)
int2 = MyEquality(3)
print(int1 == int2)

Producción :

#Python 3.x
Equal

Vale la pena señalar que no podemos cambiar la cantidad de operandos para un operador en caso de sobrecarga del operador. No podemos sobrecargar un operador unario como un operador binario y viceversa.

Por ejemplo, no podemos sobrecargar el operador invertido ~ (un operador unario) como un operador binario.