Introducción a los métodos mágicos

Los métodos mágicos, también conocidos como métodos dunder (abreviatura de «double underscore»), son métodos especiales de Python que permiten definir cómo se comportan los objetos en situaciones específicas.

En esta lección, aprenderá a utilizar métodos mágicos habituales como __str__, __repr__ y otros.

¿Qué son los métodos mágicos?

Los métodos mágicos son métodos predefinidos de Python que se llaman automáticamente cuando se realizan operaciones específicas en los objetos. Se identifican mediante dos guiones bajos, como __init__ o __str__.

El método __init__

El método __init__ es un constructor que inicializa un objeto nuevo. Se llama automáticamente cuando se crea un objeto:

# 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

El método __str__

El método __str__ define la representación textual de un objeto cuando se llama a print():

# 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

El método __repr__

El método __repr__ proporciona una representación textual oficial de un objeto, que se utiliza a menudo para la depuración:

# 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)

Sobrecarga de operadores con métodos mágicos

Puede utilizar métodos mágicos para personalizar el comportamiento de operadores como + o ==:

# 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 habituales

Estos son algunos métodos mágicos de uso frecuente:

• __len__: Define el comportamiento de la función len().
• __getitem__: Permite utilizar índices como en una lista o un diccionario.
• __eq__: Personaliza la comparación de igualdad mediante ==.

Uso de __len__ y __getitem__

Puede utilizar __len__ para definir la longitud de un objeto personalizado y __getitem__ para permitir el acceso mediante índices:

# 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

Errores comunes con los métodos mágicos

Estos son algunos errores que debe evitar:

• Definir un método mágico sin respetar el comportamiento previsto.
• Utilizar la sobrecarga de operadores sin necesidad.
• Olvidar implementar los métodos mágicos necesarios en los tipos de datos personalizados.

¿Qué aprendimos?

En esta lección, aprendió:

• Qué son los métodos mágicos y por qué son útiles.
• Cómo utilizar métodos mágicos habituales como __init__, __str__ y __repr__.
• Cómo sobrecargar operadores mediante métodos mágicos.

¡Excelente trabajo! Pasemos al siguiente tema.