Introdução aos métodos mágicos

Métodos mágicos, também conhecidos como métodos de sublinhado duplo (abreviação de «dois sublinhados»), são métodos especiais do Python que permitem definir como os objetos se comportam em situações específicas.

Nesta lição, você aprenderá a usar métodos mágicos comuns, como __str__, __repr__ e outros.

O que são métodos mágicos?

Métodos mágicos são métodos predefinidos do Python chamados automaticamente quando operações específicas são realizadas em objetos. Eles são identificados pelos dois sublinhados, como em __init__ ou __str__.

O método __init__

O método __init__ é um construtor que inicializa um novo objeto. Ele é chamado automaticamente quando um objeto é criado:

# Using the __init__ method to initialize attributes
class Person:
    def __init__(self, name, age):
        self.name = name  # Initialize the name attribute
        self.age = age  # Initialize the age attribute

# Creating an instance of Person
person = Person("Alice", 30)
print(person.name, person.age)  # Outputs: Alice 30

O método __str__

O método __str__ define a representação textual de um objeto quando print() é chamado:

# Defining the __str__ method
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        return f"Name: {self.name}, Age: {self.age}"  # String representation

person = Person("Alice", 30)
print(person)  # Outputs: Name: Alice, Age: 30

O método __repr__

O método __repr__ fornece uma representação textual oficial de um objeto, geralmente usada para depuração:

# Defining the __repr__ method
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __repr__(self):
        return f"Person('{self.name}', {self.age})"  # Debug-friendly representation

person = Person("Alice", 30)
print(repr(person))  # Outputs: Person('Alice', 30)

Sobrecarregando operadores com métodos mágicos

Você pode usar métodos mágicos para personalizar o comportamento de operadores como + ou ==:

# Overloading the + operator with __add__
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        return Point(self.x + other.x, self.y + other.y)  # Adding two points

    def __str__(self):
        return f"({self.x}, {self.y})"

point1 = Point(1, 2)
point2 = Point(3, 4)
result = point1 + point2  # Calls __add__
print(result)  # Outputs: (4, 6)

Métodos mágicos usados com frequência

Veja alguns métodos mágicos usados com frequência:

• __len__: define o comportamento da função len().
• __getitem__: permite fazer indexações como em uma lista ou um dicionário.
• __eq__: personaliza a comparação de igualdade usando ==.

Usando __len__ e __getitem__

Você pode usar __len__ para definir o comprimento de um objeto personalizado e __getitem__ para torná-lo indexável:

# Using __len__ and __getitem__ in a custom class
class CustomList:
    def __init__(self, items):
        self.items = items

    def __len__(self):
        return len(self.items)  # Defines the behavior of len()

    def __getitem__(self, index):
        return self.items[index]  # Enables indexing

custom_list = CustomList([1, 2, 3])
print(len(custom_list))  # Outputs: 3
print(custom_list[1])  # Outputs: 2

Erros comuns com métodos mágicos

Veja alguns erros que devem ser evitados:

• Definir um método mágico sem corresponder ao comportamento pretendido.
• Sobrecarregar operadores sem necessidade.
• Esquecer o implementing dos métodos mágicos exigidos em tipos de dados personalizados.

O que aprendemos?

Nesta lição, você aprendeu:

• O que são métodos mágicos e por que são úteis.
• Como usar métodos mágicos comuns, como __init__, __str__ e __repr__.
• Como sobrecarregar operadores usando métodos mágicos.

Muito bem! Vamos passar ao próximo tópico.