Em [[Linguagem de programação Python|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:
```python
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:**
```python
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:**
* [10.3. operator — Standard operators as functions — Python 3.5.9 documentation](https://docs.python.org/3.5/library/operator.html)