Sobrecarga do Operador Python
Sobrecarga do Operador Python
Você pode alterar o significado de um operador em Python dependendo dos operandos usados. Neste tutorial, você aprenderá como usar a sobrecarga de operadores na Programação Orientada a Objetos Python.
Sobrecarga do Operador Python
Os operadores Python funcionam para classes internas. Mas o mesmo operador se comporta de maneira diferente com tipos diferentes. Por exemplo, o
+ operador realizará adição aritmética em dois números, mesclará duas listas ou concatenará duas strings. Esse recurso em Python que permite que um mesmo operador tenha significados diferentes de acordo com o contexto é chamado de sobrecarga de operadores.
Então, o que acontece quando os usamos com objetos de uma classe definida pelo usuário? Consideremos a seguinte classe, que tenta simular um ponto no sistema de coordenadas 2-D.
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' Aqui, podemos ver que um
TypeError foi gerado, pois o Python não sabia como adicionar dois Point objetos juntos. No entanto, podemos realizar essa tarefa em Python por meio da sobrecarga de operadores. Mas primeiro, vamos ter uma noção sobre funções especiais.
Funções especiais do Python
Funções de classe que começam com sublinhado duplo
__ são chamadas de funções especiais em Python. Essas funções não são as funções típicas que definimos para uma classe. O
__init__() função que definimos acima é uma delas. Ele é chamado toda vez que criamos um novo objeto dessa classe. Existem inúmeras outras funções especiais em Python. Visite as Funções Especiais do Python para saber mais sobre elas.
Usando funções especiais, podemos tornar nossa classe compatível com funções internas.
>>> p1 = Point(2,3)
>>> print(p1)
<__main__.Point object at 0x00000000031F8CC0> Suponha que queremos o
print() função para imprimir as coordenadas do Point objeto em vez do que temos. Podemos definir um __str__() método em nossa classe que controla como o objeto é impresso. Vejamos como podemos conseguir isso:
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 vamos tentar o
print() funcionar novamente.
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)
p1 = Point(2, 3)
print(p1) Saída
(2, 3)
Isso é melhor. Acontece que esse mesmo método é invocado quando usamos a função interna
str() ou format() .
>>> str(p1)
'(2,3)'
>>> format(p1)
'(2,3)' Então, quando você usa
str(p1) ou format(p1) , o Python chama internamente o p1.__str__() método. Daí o nome, funções especiais. Agora vamos voltar à sobrecarga de operadores.
Sobrecarregando o operador +
Para sobrecarregar o
+ operador, precisaremos implementar __add__() função na classe. Com grandes poderes vem grandes responsabilidades. Podemos fazer o que quisermos, dentro desta função. Mas é mais sensato retornar um Point objeto da soma coordenada.
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):
x = self.x + other.x
y = self.y + other.y
return Point(x, y) Agora vamos tentar a operação de adição novamente:
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):
x = self.x + other.x
y = self.y + other.y
return Point(x, y)
p1 = Point(1, 2)
p2 = Point(2, 3)
print(p1+p2) Saída
(3,5)
O que realmente acontece é que, quando você usa
p1 + p2 , Python chama p1.__add__(p2) que por sua vez é Point.__add__(p1,p2) . Depois disso, a operação de adição é realizada da maneira que especificamos. Da mesma forma, também podemos sobrecarregar outros operadores. A função especial que precisamos implementar é tabulada abaixo.
| Operador | Expressão | Internamente |
|---|---|---|
| Adição | p1 + p2 | p1.__add__(p2) |
| Subtração | p1 - p2 | p1.__sub__(p2) |
| Multiplicação | p1 * p2 | p1.__mul__(p2) |
| Poder | p1 ** p2 | p1.__pow__(p2) |
| Divisão | p1 / p2 | p1.__truediv__(p2) |
| Divisão de Piso | p1 // p2 | p1.__floordiv__(p2) |
| Restante (módulo) | p1 % p2 | p1.__mod__(p2) |
| Deslocamento à esquerda bit a bit | p1 << p2 | p1.__lshift__(p2) |
| Deslocamento à direita bit a bit | p1 >> p2 | p1.__rshift__(p2) |
| Bit a bit E | p1 & p2 | p1.__and__(p2) |
| OU bit a bit | p1 | p2 | p1.__or__(p2) |
| XOR bit a bit | p1 ^ p2 | p1.__xor__(p2) |
| NÃO bit a bit | ~p1 | p1.__invert__() |
Sobrecarregando operadores de comparação
O Python não limita a sobrecarga de operadores apenas a operadores aritméticos. Também podemos sobrecarregar os operadores de comparação.
Suponha que queiramos implementar o símbolo menor que
< símbolo em nosso Point classe. Vamos comparar a magnitude desses pontos desde a origem e retornar o resultado para este propósito. Ele pode ser implementado da seguinte forma.
# overloading the less than operator
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
p1 = Point(1,1)
p2 = Point(-2,-3)
p3 = Point(1,-1)
# use less than
print(p1<p2)
print(p2<p3)
print(p1<p3) Saída
True False False
Da mesma forma, as funções especiais que precisamos implementar para sobrecarregar outros operadores de comparação são tabuladas abaixo.
| Operador | Expressão | Internamente |
|---|---|---|
| Menor que | p1 < p2 | p1.__lt__(p2) |
| Menor ou igual a | p1 <= p2 | p1.__le__(p2) |
| Igual a | p1 == p2 | p1.__eq__(p2) |
| Diferente de | p1 != p2 | p1.__ne__(p2) |
| Maior que | p1 > p2 | p1.__gt__(p2) |
| Maior ou igual a | p1 >= p2 | p1.__ge__(p2) |
python