Métodos Mágicos

En Python, los métodos mágicos son métodos especiales que puedes definir para agregar funcionalidad a tus clases. También se conocen como métodos "dunder", debido a los dobles guiones bajos __ que preceden y siguen a sus nombres. Ya has conocido dos de estos métodos: __init__ y __str__. Observa un ejemplo sencillo:

class Circle:
    def __init__(self, radius):                     # Inicializar el objeto
        self.radius = radius

    def __str__(self):                              # Representar como una cadena
        return f'Circle with radius {self.radius}'

c = Circle(5)    # Crear un objeto Circle llamado c
print(c)         # Circle with radius 5

En el ejemplo, hemos definido dos métodos mágicos:

__init__ es un método constructor que se llama cuando se crea una instancia de la clase. Aquí, establece el radio del Circle.

__str__ define cómo una instancia de la clase debe convertirse a una cadena cuando se utiliza en contextos como print().

Pero estos no son los únicos métodos mágicos en Python. Hay muchos más. A continuación se presentan algunos que permiten que las instancias de clase se puedan sumar con un + o comparar con un < o >:

class Circle:
    def __init__(self, radius):                     # Inicializar el objeto
        self.radius = radius

    def __str__(self):                              # Representar como una cadena
        return f'Circle with radius {self.radius}'

    def __add__(self, other):                       # Sumar dos círculos
        return Circle(self.radius + other.radius)   # Devolver un nuevo círculo

    def __lt__(self, other):                        # Comparación "menor que" entre dos círculos
        return self.radius < other.radius           # Comparar radios

c1 = Circle(5)
c2 = Circle(7)
c3 = c1 + c2     # Esto crearía un nuevo Circle con radio 12
print(c3)        # Circle with radius 12
print(c1 < c2)   # True

En este caso:

__add__ nos permite usar el operador + con instancias de Circle. Suma los radios de los círculos y devuelve un nuevo Circle.

__lt__ (menor que) nos permite comparar dos instancias de Circle con el operador <. Verifica si el radio del primer círculo es menor que el del segundo.

Los métodos mágicos hacen que nuestras clases en Python sean más expresivas e intuitivas, comportándose más como objetos integrados de Python.

Recuerda mantener la nomenclatura especial de doble guión bajo, porque el intérprete de Python busca estos métodos de nombres especiales para realizar ciertas operaciones. Puedes encontrar la lista de todos los métodos mágicos disponibles en Python siguiendo este enlace. A continuación se presentan algunos de los métodos mágicos más populares:

Método Mágico	Operador	Descripción
`__eq__`	`==`	Devuelve `True` si `self` es igual a `other`.
`__lt__`	`<`	Devuelve `True` si `self` es menor que `other`.
`__le__`	`<=`	Devuelve `True` si `self` es menor o igual que `other`.
`__gt__`	`>`	Devuelve `True` si `self` es mayor que `other`.
`__ge__`	`>=`	Devuelve `True` si `self` es mayor o igual que `other`.
`__add__(self, other)`	`+`	Implementa la suma con el operador `+`.
`__sub__(self, other)`	`-`	Implementa la resta con el operador `-`.
`__mul__(self, other)`	`*`	Implementa la multiplicación con el operador `*`.
`__truediv__(self, other)`	`/`	Implementa la división con el operador `/`.
`__floordiv__(self, other)`	`//`	Implementa la división entera con el operador `//`.
`__mod__(self, other)`	`%`	Implementa el módulo con el operador `%`.
`__pow__(self, other)`	`**`	Implementa la potencia con el operador `**`.
`__abs__(self)`	`abs()`	Implementa el comportamiento de la función incorporada `abs()`.
`__round__(self, n)`	`round()`	Implementa el comportamiento de la función incorporada `round()`.
`__neg__(self)`	`-`	Implementa la negación con el operador unario `-`.

💡

Ten en cuenta que no todos los métodos tienen sentido para todas las clases; debes implementar solo aquellos que sean útiles para tu problema.

Desafío: Crear una clase Vector

Se te pide definir una clase, Vector, que representa un vector tridimensional con atributos x, y y z.

La clase debe incluir la implementación de los métodos especiales __add__, __sub__ y __mul__ para la suma de vectores, la resta y el producto escalar, respectivamente.

Además de estos, implementa un método magnitude para calcular la magnitud del vector.

Los métodos solicitados:

__add__: Este método debe aceptar otro objeto Vector y devolver un nuevo Vector que es el resultado de sumar los componentes x, y y z de los dos vectores.

__sub__: Este método debe aceptar otro objeto Vector y devolver un nuevo Vector que es el resultado de restar los componentes x, y y z del segundo vector al primero.

__mul__: Este método debe aceptar otro objeto Vector y devolver el producto escalar de los dos vectores, calculado como $$(x1 \cdot x2) + (y1 \cdot y2) + (z1 \cdot z2)$$.

magnitude: Este método debe devolver la magnitud (longitud) del vector, calculada como $$\sqrt{x^2 + y^2 + z^2}$$.

Entrada	Salida
`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

Desafío: Crear una clase Vector

Constraints

To check your solution you need to sign in

Sign in to continue