Métodos Mágicos

Em Python, os métodos mágicos são métodos especiais que pode definir para adicionar funcionalidades às suas classes. Também são conhecidos como dunder methods, por causa dos sublinhados duplos __ que aparecem antes e depois dos nomes desses métodos. É possível que já tenha visto dois desses métodos: __init__ e __str__. Veja um exemplo simples:

class Circle:
    def __init__(self, radius):                     # Inicializa o objeto
        self.radius = radius

    def __str__(self):                              # Representa como string
        return f'Circle with radius {self.radius}'

c = Circle(5)    # Cria um objeto Circle chamado c
print(c)         # Circle with radius 5

No exemplo, definimos dois métodos mágicos:

  • __init__ é um método construtor que é chamado quando se cria uma instância da classe. Aqui, ele define o raio do Circle.

  • __str__ define como uma instância da classe deveria ser convertida em string quando usada em contextos como a função print().

Mas estes não são os únicos métodos mágicos em Python. Existem muitos outros. Alguns deles são mostrados abaixo, permitindo que as instâncias da classe possam ser somadas com + ou comparadas com < ou >:

class Circle:
    def __init__(self, radius):                     # Inicializa o objeto
        self.radius = radius

    def __str__(self):                              # Representa como string
        return f'Circle with radius {self.radius}'

    def __add__(self, other):                       # Adiciona dois círculos
        return Circle(self.radius + other.radius)   # Retorna um novo círculo

    def __lt__(self, other):                        # Comparação "menos que" entre dois círculos
        return self.radius < other.radius           # Compara os raios

c1 = Circle(5)
c2 = Circle(7)
c3 = c1 + c2     # This would create a new Circle with radius 12
print(c3)        # Circle with radius 12
print(c1 < c2)   # True

Nesse caso:

  • __add__ permite-nos utilizar o operador + com instâncias de Circle. Ele soma o raio dos círculos e devolve um novo Circle.

  • __lt__ (menos que) permite comparar duas instâncias de Circle com o operador <. Ele verifica se o raio do primeiro círculo é menor do que o do segundo.

Os métodos mágicos tornam as classes em Python mais expressivas e intuitivas, fazendo-as funcionar de maneira semelhante aos objetos nativos da linguagem.

Lembre-se de manter a convenção de sublinhados duplos, pois o interpretador do Python procura especificamente esses nomes especiais para executar certas operações. Pode encontrar a lista completa de métodos mágicos em Python seguindo este link. Abaixo estão alguns dos métodos mágicos mais populares:

Método Mágico

Operador

Descrição

__eq__

==

Retorna True se self for igual a other.

__lt__

<

Retorna True se self for menor que other.

__le__

<=

Retorna True se self for menor ou igual a other.

__gt__

>

Retorna True se self for maior que other.

__ge__

>=

Retorna True se self for maior ou igual a other.

__add__(self, other)

+

Implementa a adição com o operador +.

__sub__(self, other)

-

Implementa a subtração com o operador -.

__mul__(self, other)

*

Implementa a multiplicação com o operador *.

__truediv__(self, other)

/

Implementa a divisão com o operador /.

__floordiv__(self, other)

//

Implementa a divisão inteira com o operador //.

__mod__(self, other)

%

Implementa o módulo com o operador %.

__pow__(self, other)

**

Implementa o operador de potência **.

__abs__(self)

abs()

Implementa o comportamento para a função embutida abs().

__round__(self, n)

round()

Implementa o comportamento para a função embutida round().

__neg__(self)

-

Implementa a negação com o operador unário -.

Desafio: Criar uma Classe Vector

A sua tarefa é definir uma classe, Vector, que representa um vetor tridimensional com atributos x, y e z.

A classe deve incluir a implementação dos métodos especiais __add__, __sub__ e __mul__ para a adição, subtração e o produto interno (dot product) de vetores, respetivamente.

Além disso, implemente um método magnitude para calcular a magnitude (o comprimento) do vetor.

3d-vector.webp

Os métodos solicitados:

  • __add__: Deve receber outro objeto Vector e retornar um novo Vector que resulte da soma dos componentes x, y e z dos dois vetores.

  • __sub__: Deve receber outro objeto Vector e retornar um novo Vector que resulte da subtração dos componentes x, y e z do segundo vetor em relação ao primeiro.

  • __mul__: Deve receber outro objeto Vector e retornar o produto interno dos dois vetores, calculado como:

  • magnitude: Deve retornar a magnitude (comprimento) do vetor, calculada como:

Entrada

Saída

v1 = Vector(1, 2, 3); v2 = Vector(4, 5, 6); v3 = v1 + v2; v4 = v1 - v2; print(v1 * v2); print(v1.magnitude()); v4 = Vector(-3, -3, -3)

32
3.74165

Constraints

Time limit: 2 seconds

Memory limit: 512 MB

Output limit: 1 MB

To check your solution you need to sign in
Sign in to continue