Los métodos mágicos de las clases Python son aquellos que comienzan y terminan con dos caracteres subrayados. Métodos que son clave a la hora de trabajar con clases. Esto es así porque muchas de las operaciones que se hacen con clases en Python utilizan estos métodos cómo puede ser la creación del objeto (__init__) o generar una cadena que los represente (__str__). Todos estos métodos tienen un primer parámetro que hace referencia al propio objeto, que por convenio se suele llamar self. Siendo el resto de los parámetros del método variables. Veamos a continuación algunos de estos métodos y cuál es su finalidad.
Tabla de contenidos
__init__
El método mágico más utilizado en las clases de python es el constructor. Empleado para crear cada una de las instancias de las clases. Un método que no tiene una cantidad fija de parámetros, ya que estos dependen de las propiedades que tenga el objeto. Por ejemplo, se puede crear un objeto Vector
class Vector():
def __init__(self, data):
self._data = data
v = Vector([1,2])
print(v)<__main__.Vector object at 0x7fbc44cc4450>
Un objeto en el que el parámetro de la clase se guarda en una variable privada (_data).
__str__
Posiblemente el segundo método más utilizado sea __str__, con el que se crear una representación del objeto que tenga significado para las personas. En el ejemplo anterior, al imprimir el objeto se ha visto una cadena que indica el tipo de objeto y una dirección. Lo que generalmente no tiene sentido para las personas. Un problema que se puede solucionar con el método __str__.
class Vector():
def __init__(self, data):
self._data = data
def __str__(self):
return f"The values are: {self._data}"
v = Vector([1,2])
print(v)The values are: [1, 2]
Ahora al imprimir el objeto podemos ver algo que se relaciona con el contenido.
__len__
En el caso de el objeto tenga una número de elementos, como es el caso, podríamos usar la función len para obtener este. Pero si probamos con el objeto nos encontraremos con un error. Esto es así porque la clase no ha implementado aún el método __len__. Un problema se puede solucionar de tomar fácil al incluir este método.
class Vector():
def __init__(self, data):
self._data = data
def __str__(self):
return f"The values are: {self._data}"
def __len__(self):
return len(self._data)
v = Vector([1,2])
len(v)2
__getitem__
Si se desea que los usuarios puedan leer los elemento mediante el uso de corchetes es necesario implementar el método __getitem__ en la clase. Solamente leer, para modificar se tiene que crear también el método __setitem__, el cual veremos a continuación. Este es un elemento que necesita un parámetro adicional que es la posición del elemento a leer. La función debe retornar el valor leído.
class Vector():
def __init__(self, data):
self._data = data
def __str__(self):
return f"The values are: {self._data}"
def __len__(self):
return len(self._data)
def __getitem__(self, pos):
return self._data[pos]
v = Vector([1,2])
v[1]2
__setitme__
Este es el complemento del método anterior. Es este caso es necesario pasar dos parámetros adicionales, la posición y el valor a reemplazar.
class Vector():
def __init__(self, data):
self._data = data
def __str__(self):
return f"The values are: {self._data}"
def __len__(self):
return len(self._data)
def __getitem__(self, pos):
return self._data[pos]
def __setitem__(self, pos, value):
self._data[pos] = value
v = Vector([1,2])
v[1] = 20
print(v)The values are: [1, 20]
__iter__
Cuando necesitamos que nuestra clase sea iterable, lo que permite usarla por ejemplo en bucles tipo for, es necesario implementar este método. A continuación, podemos ver una implementación de este método en el que devuelve una cadena con el índice y el valor de cada elemento.
class Vector():
def __init__(self, data):
self._data = data
def __str__(self):
return f"The values are: {self._data}"
def __len__(self):
return len(self._data)
def __getitem__(self, pos):
return self._data[pos]
def __setitem__(self, pos, value):
self._data[pos] = value
def __iter__(self):
for pos in range(0, len(self._data)):
yield f"Value[{pos}]: {self._data[pos]}"
v = Vector([1,2])
for vec in v:
print(vec)Value[0]: 1 Value[1]: 2
Operadores
Existen varios métodos mágicos que permiten sobrecargar los operadores cómo puede ser la suma (__add__), la multiplicación (__mul__) o de comparación (como mayor que __gt__ o menor que __lt__). Métodos que tiene en común un segundo parámetro que hace referencia al otro objeto con el que se opera. Siendo necesario devolver el objeto resultante de la operación o el resultado en el caso de ser una operación lógica. Por ejemplo, se puede crear una operación que permita sumar dos vectores.
class Vector():
def __init__(self, data):
self._data = data
def __str__(self):
return f"The values are: {self._data}"
def __len__(self):
return len(self._data)
def __getitem__(self, pos):
return self._data[pos]
def __setitem__(self, pos, value):
self._data[pos] = value
def __iter__(self):
for pos in range(0, len(self._data)):
yield f"Value[{pos}]: {self._data[pos]}"
def __add__(self, other):
result = [None] * len(self._data)
for pos in range(len(self._data)):
result[pos] = self._data[pos] + other._data[pos]
return Vector(result)
v = Vector([1,2])
w = Vector([2,2])
print(v + w)The values are: [3, 4]
Conclusiones
En esta entrada se han visto algunos de los métodos mágicos de las clases Python que son clave a la hora de crear objetos. Es importante comprender el funcionamiento e implementar en nuestras clases todos aquellos que sean necesarios para facilitar su uso.
Deja una respuesta