Manufaturação industrial
Internet das coisas industrial | Materiais industriais | Manutenção e reparo de equipamentos | Programação industrial |
home  MfgRobots >> Manufaturação industrial >  >> Industrial programming >> python

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:

OperadorExpressãoMétodo Especial
Adiçãop1 + p2__add__(self, other)
Subtraçãop1 - p2__sub__(self, other)
Multiplicaçãop1 * p2__mul__(self, other)
Potênciap1 ** p2__pow__(self, other)
Divisãop1 / p2__truediv__(self, other)
Divisão Inteirap1 // p2__floordiv__(self, other)
Módulop1 % p2__mod__(self, other)
Shift Esquerdap1 << p2__lshift__(self, other)
Shift Direitap1 >> p2__rshift__(self, other)
Bitwise ANDp1 & p2__and__(self, other)
Bitwise ORp1 | p2__or__(self, other)
Bitwise XORp1 ^ 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:

OperadorExpressãoMétodo Especial
Menor Quep1 < p2__lt__(self, other)
Menor ou Igualp1 <= p2__le__(self, other)
Igualp1 == p2__eq__(self, other)
Diferentep1 != p2__ne__(self, other)
Maior Quep1 > p2__gt__(self, other)
Maior ou Igualp1 >= 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

  1. Dominando Tipos de Dados em Python: Guia Prático
  2. Dominando Operadores em Python: Guia Completo
  3. Dominando a Declaração Pass em Python: Guia Prático
  4. Dominando Argumentos de Funções em Python: Parâmetros Posicionais, Nomeados e Padrão
  5. Dominando Dicionários em Python: Criação, Manipulação e Técnicas Avançadas
  6. Dominando Herança em Python: Conceitos, Sintaxe e Exemplos Práticos
  7. Dominando Iteradores em Python: Como Funcionam e Como Criar os Seus
  8. Closures em Python Explicados: Como Funções Aninhadas Capturam Variáveis
  9. Dominando Decorator @property do Python: Getters & Setters Limpos e Compatíveis
  10. Dominando datetime do Python: Guia Prático de Datas, Horários e Fusos Horários