Sobrecarga do operador significa dar significado estendido além de seu significado operacional predefinido. Por exemplo, operador + é usado para adicionar dois inteiros, bem como juntar duas strings e mesclar duas listas. É possível porque o operador '+' está sobrecarregado pela classe int e pela classe str. Você deve ter notado que o mesmo operador ou função embutida mostra comportamento diferente para objetos de classes diferentes, isso é chamado de sobrecarga de operador . 
 

print(1 + 2) 
print("Geeks"+"For")  
print(3 * 4) 
print("Geeks"*4) 

Resultado: 
 

3
GeeksFor
12
GeeksGeeksGeeksGeeks

Como sobrecarregar os operadores em Python?  
Considere que temos dois objetos que são uma representação física de uma classe (tipo de dados definido pelo usuário) e temos que adicionar dois objetos com o operador binário '+' que gera um erro, porque o compilador não sabe como adicionar dois objetos . Portanto, definimos um método para um operador e esse processo é chamado de sobrecarga de operador. Podemos sobrecarregar todos os operadores existentes, mas não podemos criar um novo operador. Para realizar a sobrecarga do operador, o Python fornece alguma função especial ou função mágica que é automaticamente invocada quando associada a esse operador específico. Por exemplo, quando usamos o operador +, o método mágico __add__ é automaticamente invocado, no qual a operação do operador + é definida.
Sobrecarregando operador binário + em Python: 
Quando usamos um operador em tipos de dados definidos pelo usuário, automaticamente uma função especial ou função mágica associada a esse operador é chamada. Mudar o comportamento do operador é tão simples quanto mudar o comportamento do método ou função. Você define métodos em sua classe e os operadores funcionam de acordo com o comportamento definido nos métodos. Quando usamos o operador +, o método mágico __add__ é automaticamente invocado, no qual a operação do operador + é definida. Ao alterar o código desse método mágico, podemos dar um significado extra ao operador +. 
Código 1: 
 

class A: 
    def __init__(self, a): 
        self.a = a 
  
    
    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) 

Resultado : 
 

3
GeeksFor

Código 2: 
 

class complex: 
    def __init__(self, a, b): 
        self.a = a 
        self.b = b 
  
     
    def __add__(self, other): 
        return self.a + other.a, self.b + other.b 
  
    def __str__(self): 
        return self.a, self.b 
  
Ob1 = complex(1, 2) 
Ob2 = complex(2, 3) 
Ob3 = Ob1 + Ob2 
print(Ob3) 

Resultado : 
 

(3, 5)

Sobrecarregando operadores de comparação em Python: 
 

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") 

Resultado : 
 

ob2 é maior que ob1

Sobrecarregando a igualdade e menos que os operadores: 
 

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) 

Resultado : 
 

ob1 é menor que ob2
Não igual

Métodos mágicos Python ou funções especiais para sobrecarga de operador

Operadores binários :

Operadores de comparação:

Operadores de atribuição:

Operadores unários: