Dominando Sobrecarga de Operadores em Python: Guia Prático
Sobrecarga de Operadores em Python
Descubra como redefinir comportamento de operadores em Python usando métodos especiais como __add__, __lt__ e mais, aprimorando seus designs OOP.
Sobrecarga de Operadores em Python
Operadores built-in do Python funcionam diferentemente dependendo dos tipos de operandos. O operador +, por exemplo, soma números, concatena strings ou mescla lists. Essa flexibilidade é alcançada através de sobrecarga de operadores — recurso que permite atribuir significados contextuais a operadores para suas próprias classes.
Considere classe simples Point representando coordenada em plano 2D. Sem métodos especiais, tentar somar dois pontos levantará TypeError:
class Point:
def __init__(self, x=0, y=0):
self.x = x
self.y = y
p1 = Point(1, 2)
p2 = Point(2, 3)
print(p1+p2)
Saída
Traceback (most recent call last): File "<string>", line 9, in <module> print(p1+p2) TypeError: unsupported operand type(s) for +: 'Point' and 'Point'
Como Python não tem conhecimento built-in de como combinar duas instâncias Point, lança exceção. Sobrecarga de operadores nos permite definir esse comportamento.
Métodos Especiais do Python
Métodos cercados por underscores duplos — __init__, __str__, __add__, etc. — são conhecidos como métodos especiais ou "dunder" methods. São invocados implicitamente pelo runtime do Python e são pontos de hook para sobrecarga de operadores, protocolos de container e mais.
Por exemplo, método __str__ controla como objeto é convertido para string legível. Por padrão, imprimir objeto exibe endereço de memória, o que geralmente não é útil. Sobrescrever __str__ torna debugging e logging muito mais claros:
class Point:
def __init__(self, x=0, y=0):
self.x = x
self.y = y
def __str__(self):
return '({0}, {1})'.format(self.x, self.y)
Agora, ao imprimir Point, obtemos:
p1 = Point(2, 3)
print(p1)
Saída
(2, 3)
Mesma representação é usada por str(p1) e format(p1) porque Python internamente chama p1.__str__().
Sobrecarregando Operador +
Para customizar adição para objetos Point, implemente __add__:
class Point:
def __init__(self, x=0, y=0):
self.x = x
self.y = y
def __str__(self):
return '({0}, {1})'.format(self.x, self.y)
def __add__(self, other):
return Point(self.x + other.x, self.y + other.y)
Testando novo comportamento:
p1 = Point(1, 2)
p2 = Point(2, 3)
print(p1 + p2)
Saída
(3, 5)
Sob o capô, Python executa p1.__add__(p2), que retorna novo Point com coordenadas somadas.
Abaixo referência rápida para outros operadores aritméticos e métodos especiais necessários:
| Operador | Expressão | Método Especial |
|---|---|---|
| Adição | p1 + p2 | __add__(self, other) |
| Subtração | p1 - p2 | __sub__(self, other) |
| Multiplicação | p1 * p2 | __mul__(self, other) |
| Potência | p1 ** p2 | __pow__(self, other) |
| Divisão | p1 / p2 | __truediv__(self, other) |
| Divisão Inteira | p1 // p2 | __floordiv__(self, other) |
| Módulo | p1 % p2 | __mod__(self, other) |
| Shift Esquerda | p1 << p2 | __lshift__(self, other) |
| Shift Direita | p1 >> p2 | __rshift__(self, other) |
| Bitwise AND | p1 & p2 | __and__(self, other) |
| Bitwise OR | p1 | p2 | __or__(self, other) |
| Bitwise XOR | p1 ^ p2 | __xor__(self, other) |
| Bitwise NOT | ~p1 | __invert__(self) |
Sobrecarregando Operadores de Comparação
Sobrecarga não se limita a aritmética. Operadores de comparação também podem ser customizados. Por exemplo, para comparar pontos baseados em distância da origem, sobrescreva __lt__:
class Point:
def __init__(self, x=0, y=0):
self.x = x
self.y = y
def __str__(self):
return '({0}, {1})'.format(self.x, self.y)
def __lt__(self, other):
self_mag = self.x**2 + self.y**2
other_mag = other.x**2 + other.y**2
return self_mag < other_mag
Uso:
p1 = Point(1, 1)
p2 = Point(-2, -3)
p3 = Point(1, -1)
print(p1 < p2) # True
print(p2 < p3) # False
print(p1 < p3) # False
Outros métodos de comparação seguem padrão similar:
| Operador | Expressão | Método Especial |
|---|---|---|
| Menor Que | p1 < p2 | __lt__(self, other) |
| Menor ou Igual | p1 <= p2 | __le__(self, other) |
| Igual | p1 == p2 | __eq__(self, other) |
| Diferente | p1 != p2 | __ne__(self, other) |
| Maior Que | p1 > p2 | __gt__(self, other) |
| Maior ou Igual | p1 >= p2 | __ge__(self, other) |
Definindo esses métodos cuidadosamente, você faz objetos customizados participarem naturalmente em contextos aritméticos e de comparação, melhorando legibilidade e manutenibilidade do código.
python
- Dominando Tipos de Dados em Python: Guia Prático
- Dominando Operadores em Python: Guia Completo
- Dominando a Declaração Pass em Python: Guia Prático
- Dominando Argumentos de Funções em Python: Parâmetros Posicionais, Nomeados e Padrão
- Dominando Dicionários em Python: Criação, Manipulação e Técnicas Avançadas
- Dominando Herança em Python: Conceitos, Sintaxe e Exemplos Práticos
- Dominando Iteradores em Python: Como Funcionam e Como Criar os Seus
- Closures em Python Explicados: Como Funções Aninhadas Capturam Variáveis
- Dominando Decorator @property do Python: Getters & Setters Limpos e Compatíveis
- Dominando datetime do Python: Guia Prático de Datas, Horários e Fusos Horários