Sobrecarga de operadores en Python

La sobrecarga de operadores significa dar un significado más amplio más allá de su significado operativo predefinido. Por ejemplo, el operador + se usa para sumar dos enteros, así como para unir dos strings y fusionar dos listas. Se puede lograr porque el operador ‘+’ está sobrecargado por la clase int y la clase str. Es posible que haya notado que el mismo operador o función integrada muestra un comportamiento diferente para los objetos de diferentes clases, esto se denomina sobrecarga de operadores . 
 

# Python program to show use of
# + operator for different purposes.
  
print(1 + 2)
  
# concatenate two strings
print("Geeks"+"For") 
  
# Product two numbers
print(3 * 4)
  
# Repeat the String
print("Geeks"*4)

3
GeeksFor
12
GeeksGeeksGeeksGeeks

Producción: 
 

3
GeeksFor
12
GeeksGeeksGeeksGeeks

¿Cómo sobrecargar los operadores en Python?  
Considere que tenemos dos objetos que son una representación física de una clase (tipo de datos definido por el usuario) y tenemos que agregar dos objetos con el operador binario ‘+’ arroja un error, porque el compilador no sabe cómo agregar dos objetos . Así que definimos un método para un operador y ese proceso se llama sobrecarga de operadores. Podemos sobrecargar todos los operadores existentes pero no podemos crear un nuevo operador. Para realizar la sobrecarga de operadores, Python proporciona alguna función especial o función mágica que se invoca automáticamente cuando se asocia con ese operador en particular. Por ejemplo, cuando usamos el operador +, se invoca automáticamente el método mágico __add__ en el que se define la operación para el operador +.
Sobrecarga del operador binario + en Python: 
Cuando usamos un operador en tipos de datos definidos por el usuario, automáticamente se invoca una función especial o función mágica asociada con ese operador. Cambiar el comportamiento del operador es tan simple como cambiar el comportamiento del método o función. Usted define los métodos en su clase y los operadores funcionan de acuerdo con el comportamiento definido en los métodos. Cuando usamos el operador +, se invoca automáticamente el método mágico __add__ en el que se define la operación para el operador +. Allí, al cambiar el código de este método mágico, podemos darle un significado adicional al operador +. 
Código 1: 
 

# Python Program illustrate how 
# to overload an binary + operator
  
class A:
    def __init__(self, a):
        self.a = a
  
    # adding two objects 
    def __add__(self, o):
        return self.a + o.a 
ob1 = A(1)
ob2 = A(2)
ob3 = A("Geeks")
ob4 = A("For")
  
print(ob1 + ob2)
print(ob3 + ob4)

3
GeeksFor

Producción : 
 

3
GeeksFor

Código 2: 
 

# Python Program to perform addition 
# of two complex numbers using binary 
# + operator overloading.
  
class complex:
    def __init__(self, a, b):
        self.a = a
        self.b = b
  
     # adding two objects 
    def __add__(self, other):
        return self.a + other.a, self.b + other.b
  
Ob1 = complex(1, 2)
Ob2 = complex(2, 3)
Ob3 = Ob1 + Ob2
print(Ob3)

(3, 5)

Producción : 
 

(3, 5)

Sobrecarga de operadores de comparación en Python: 
 

# Python program to overload
# a comparison operators 
  
class A:
    def __init__(self, a):
        self.a = a
    def __gt__(self, other):
        if(self.a>other.a):
            return True
        else:
            return False
ob1 = A(2)
ob2 = A(3)
if(ob1>ob2):
    print("ob1 is greater than ob2")
else:
    print("ob2 is greater than ob1")

Producción : 
 

ob2 is greater than ob1

Sobrecarga de operadores de igualdad y menos que: 
 

# Python program to overload equality
# and less than operators
  
class A:
    def __init__(self, a):
        self.a = a
    def __lt__(self, other):
        if(self.a<other.a):
            return "ob1 is lessthan ob2"
        else:
            return "ob2 is less than ob1"
    def __eq__(self, other):
        if(self.a == other.a):
            return "Both are equal"
        else:
            return "Not equal"
                  
ob1 = A(2)
ob2 = A(3)
print(ob1 < ob2)
  
ob3 = A(4)
ob4 = A(4)
print(ob1 == ob2)

Producción : 
 

ob1 is lessthan ob2
Not equal

Métodos mágicos de Python o funciones especiales para sobrecarga de operadores

Operadores binarios :

Operadores de comparación :

Operadores de Asignación :

Operadores unarios:

Nota: No es posible cambiar el número de operandos de un operador. por ej. no puede sobrecargar un operador unario como operador binario. El siguiente código generará un error de sintaxis.

# Python program which attempts to
# overload ~ operator as binary operator
  
class A:
    def __init__(self, a):
        self.a = a
  
    # Overloading ~ operator, but with two operands
    def __invert__(self, other):
        return "This is the ~ operator, overloaded as binary operator."
  
  
ob1 = A(2)
ob2 = A(3)
  
print(ob1~ob2)