Rafael Alves ITM

Métodos especiais em Python

Leitura de 3 min

🎯 Métodos Especiais em Python

Em poucas palavras

Definição técnica ou simplificada do conceito.

📝 Notas e Desenvolvimento

Em Python, métodos especiais (também conhecidos como “métodos mágicos” ou “dunder methods” - de “double underscore”) são métodos predefinidos que têm um significado especial para o interpretador Python. Eles permitem que você personalize o comportamento de suas classes e objetos, tornando-os mais integrados à linguagem.

Esses métodos são sempre definidos com dois underscores (__) antes e depois do nome.

Exemplos:

  • __init__: Construtor da classe (inicializa um novo objeto).
  • __str__: Representação em string do objeto (usado por print() e str()).
  • __repr__: Representação “oficial” do objeto (usado para depuração e em alguns casos pelo interpretador).
  • __len__: Retorna o comprimento do objeto (usado por len()).
  • __getitem__: Permite acessar elementos do objeto usando a sintaxe de índice (por exemplo, objeto[0]).
  • __setitem__: Permite definir elementos do objeto usando a sintaxe de índice (por exemplo, objeto[0] = valor).
  • __delitem__: Permite deletar elementos do objeto usando a sintaxe de índice (por exemplo, del objeto[0]).
  • __add__: Define o comportamento do operador de adição (+).
  • __mul__: Define o comportamento do operador de multiplicação (*).
  • __eq__: Define o comportamento do operador de igualdade (==).
  • __lt__: Define o comportamento do operador “menor que” (<).
  • __gt__: Define o comportamento do operador “maior que” (>).
  • __del__: Destrutor da classe (executado quando um objeto está prestes a ser destruído).

Exemplo: Classe Vector

O código abaixo mostra a implementação de uma classe Vector que define alguns métodos especiais para realizar operações com vetores:

import math
 
class Vector:
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y
 
    def __repr__(self):
        return f'Vector({self.x!r}, {self.y!r})'
 
    def __abs__(self):
        return math.hypot(self.x, self.y)
 
    def __bool__(self):
        return bool(abs(self))
 
    def __add__(self, other):
        x = self.x + other.x
        y = self.y + other.y
        return Vector(x, y)
 
    def __mul__(self, scalar):
        return Vector(self.x * scalar, self.y * scalar)

Explicação:

  • __init__(self, x=0, y=0): Inicializa um novo vetor com as coordenadas x e y.
  • __repr__(self): Retorna uma representação do vetor que pode ser usada para recriá-lo (por exemplo, Vector(3, 4)). O !r garante que as strings sejam representadas com aspas.
  • __abs__(self): Retorna o módulo (comprimento) do vetor.
  • __bool__(self): Retorna True se o vetor tiver comprimento diferente de zero, False caso contrário.
  • __add__(self, other): Retorna um novo vetor que é a soma deste vetor com outro vetor.
  • __mul__(self, scalar): Retorna um novo vetor que é este vetor multiplicado por um escalar.

Exemplo de uso:

v1 = Vector(3, 4)
v2 = Vector(1, 2)
 
print(v1)           # Output: Vector(3, 4)
print(abs(v1))      # Output: 5.0
print(bool(v1))     # Output: True
print(v1 + v2)      # Output: Vector(4, 6)
print(v1 * 2)       # Output: Vector(6, 8)

Importância:

Os métodos especiais permitem que você crie classes que se comportam de forma natural e intuitiva em Python. Eles são fundamentais para a criação de código expressivo e idiomático.

Referência:

🔗 Conexões e Contexto

📚 Referências e Fontes

Citações Diretas

Visão de gráfico

Backlinks