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 comunes 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 sobre objetos. Se identifican mediante sus dobles 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 en forma de cadena 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 oficial en forma de cadena de un objeto, que suele utilizarse 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 de uso común

Estos son algunos métodos mágicos de uso común:

• __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 que se pueda indexar:

# 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é aprendió?

En esta lección, aprendió:

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

¡Buen trabajo! Pasemos al siguiente tema.