Cómo personalizar el comportamiento de las clases en Python usando métodos mágicos

En Python, las clases proporcionan un medio limpio para agrupar datos y funcionalidades en elementos reutilizables. La creación de clases personalizadas le permite modelar entidades del mundo real, como usuarios, productos y empleados.

Las clases de Python definen métodos mágicos que puedes personalizar para permitirte moldear el comportamiento de tus clases para situaciones únicas.

Comprender los métodos mágicos

Imagine los métodos mágicos, también llamados métodos dunder, como hechizos secretos o cánticos ocultos que Python llama automáticamente cuando realiza ciertas acciones en un objeto.

Python proporciona una gran cantidad de comportamiento integrado para clases a través de métodos de instancia, estáticos y de clase. Puede crear clases de Pythony personalízalos aún más usando métodos mágicos.

Los métodos mágicos son métodos de instancia en Python que tienen dos guiones bajos (__método__) antes y después del nombre del método.

Estos métodos especiales dan instrucciones a Python sobre cómo manejar objetos de una clase. A continuación se muestran algunos métodos mágicos comúnmente utilizados en las clases de Python:

• __gt__: Este método comprueba si un objeto es mayor que otro.
• __en eso__: Este método se ejecuta cuando crea una instancia de una clase y es principalmente para la inicialización de atributos.
• __cadena__: Esto devuelve una representación de cadena de la clase que describe el objeto.
• __repr__: Este método proporciona una salida que le permite recrear el objeto usando evaluar().
• __len__: Cuando utiliza el len() función en un objeto, este método devuelve la longitud del objeto.
• __eq__: Este método permite la comparación entre objetos usando el doble igual a (==) operador.
• __lt__: Implementa una comparación menor que (
• __agregar__: Cuando usas la suma (+) operador en objetos que este método ejecuta y realiza operaciones de suma.
• __obtiene el objeto__: Le permite recuperar elementos de un objeto usando la sintaxis de índice, como obj[clave].

Implementando métodos mágicos

La mejor manera de entender los métodos mágicos es usándolos.

Representación de cadena de un objeto

Puede personalizar la representación de cadena de un objeto para facilitar su lectura o su posterior procesamiento.

classPerson:
def__init__(self, name, age):
 self.name = name
 self.age = age
p1 = Person('John', 25)
print(p1)

Aquí tienes un sencillo Persona clase con un __en eso__ método mágico para inicializarlo. Cuando imprimes el p1 objeto, utiliza la representación de cadena predeterminada proporcionada por Python.

Para personalizar la representación de la cadena, defina el __cadena__ y __repr__ métodos mágicos:

classPerson:
def__init__(self, name, age, height):
 self.name = name
 self.age = age
 self.height = height
def__str__(self):
returnf'{self.name} is {self.age} years old'
def__repr__(self):
returnf'{self.name} is {self.age} years old'
p1 = Person('John', 25, 78) 
print(p1)

Ahora tiene una representación de cadena más legible y completa del p1 objeto:

Propiedad de longitud de un objeto

Imagínate que, cuando llamas al len() método de un objeto Persona, desea su altura. Implementar el __len__ método mágico para el Persona clase:

classPerson:
def__init__(self, name, age, height):
 self.name = name
 self.age = age
 self.height = height
def__str__(self):
returnf'{self.name} is {self.age} years old'
def__repr__(self):
returnf'{self.name} is {self.age} years old'
def__len__(self):
return self.height
p2 = Person('Issac', 25, 89) 
print(len(p2))

El __len__ El método mágico devuelve el atributo de altura de un Persona instancia. Cuando usted llama len (p2), llamará al __len__ método mágico automáticamente que devuelve la altura del p2 objeto.

Manejo de la comparación entre objetos

Si necesita comparar objetos de una clase en función de ciertas propiedades de la clase. puedes definir __eq__ método mágico e implementar su lógica de comparación.

classPerson:
def__init__(self, name, age, height):
 self.name = name
 self.age = age
 self.height = height
def__str__(self):
returnf'{self.name} is {self.age} years old'
def__repr__(self):
returnf'{self.name} is {self.age} years old'
def__len__(self):
return self.height
def__eq__(self, other):
return self.name == other.name and self.age == other.age
p1 = Person('John', 25, 56)
p2 = Person('John', 25, 61)
print(p1 == p2)

El __eq__ método compara el nombre y edad atributos de los dos de la persona objetos para determinar la igualdad.

El doble igual a (==) el operador utiliza este método para verificar la igualdad en lugar de comparar identidades. entonces dos Persona las instancias son iguales si tienen atributos de nombre y edad coincidentes. Esto le permite anular el comportamiento predeterminado de verificación de igualdad para su clase personalizada.

Al implementar estos métodos mágicos, puede definir un comportamiento personalizado que será consistente con las funciones integradas de Python.

Métodos mágicos avanzados

A continuación se muestran algunos ejemplos avanzados del uso de métodos mágicos para personalizar clases.

Hacer que las clases actúen como contenedores

Usando métodos mágicos puedes definir clases que se comporten como contenedores. Puedes usar contenedores, como tuplas, para almacenar colecciones de elementos de datos. Proporcionan varios métodos para manipular, acceder e iterar a través de los elementos contenidos.

classPerson:
def__init__(self):
 self.data = []
def__len__(self):
return len(self.data)
def__getitem__(self, index):
return self.data[index]
def__setitem__(self, index, value):
 self.data[index] = value
def__delitem__(self, index):
del self.data[index]
p1 = Person()
p1.data = [10, 2, 7]
print(len(p1)) # 3
p1[0] = 5
print(p1[0]) # 5

Ahora un objeto Persona puede comportarse como un contenedor:

Personalización del acceso a los atributos

Utilizando el __getattr__ método mágico puedes personalizar la forma en que los atributos del Persona Se accede a la clase en función de determinadas condiciones.

classPerson:
def__getattr__(self, name):
if name == 'age':
return40
else:
raise AttributeError(f'No attribute {name}')
p1 = Person()
print(p1.age) # 40

El __getattr__ El método se ejecutará cuando intente acceder a un atributo que no existe directamente en el objeto. En este caso, comprueba si el nombre del atributo es edad y devuelve 40.

Para cualquier otro nombre de atributo, genera un Error de atributo con el mensaje correspondiente.

Hacer que las clases se comporten como invocables

El __llamar__ El método le permite tratar una instancia de la clase como un objeto invocable (es decir, una función).

classAdder:
def__call__(self, x, y):
return x + y
adder = Adder()
print(adder(2, 3)) # 5

Cuando creas una instancia de Sumador y luego llamarlo con argumentos, el __llamar__ El método se ejecuta y realiza la suma antes de devolver el resultado.

Sobrecarga del operador

Usando métodos mágicos puedes realizar la sobrecarga del operador. La sobrecarga de operadores le permite definir comportamientos personalizados para los operadores integrados cuando se usan con instancias de sus propias clases. A continuación se muestra un ejemplo común que explica la sobrecarga del operador.

classVector:
def__init__(self, x, y):
 self.x = x
 self.y = y
def__add__(self, other):
if isinstance(other, Vector):
 new_x = self.x + other.x
 new_y = self.y + other.y
return Vector(new_x, new_y)
else:
raise TypeError("Unsupported operand type for +")
def__str__(self):
returnf"({self.x}, {self.y})"
# Creating two Vector instances
v1 = Vector(2, 3)
v2 = Vector(1, 4)
# Adding two Vector instances using the + operator
v3 = v1 + v2
# Printing the result
print(v3) # Output: (3, 7)

El resultado es un nuevo vector:

El Vector clase define el __agregar__ método, que se ejecuta cuando se utiliza el + operador entre dos instancias de la clase. El método suma los componentes correspondientes de los dos vectores y devuelve un nuevo Vector instancia con el resultado.

Aquí has ​​visto métodos mágicos fundamentales que puedes implementar para personalizar el comportamiento de tu clase. Python tiene muchos más métodos mágicos que ofrecen más flexibilidad a la hora de crear clases. Referirse a documentación oficial para obtener una lista completa.

Programación orientada a objetos en Python

Los métodos mágicos en Python proporcionan formas poderosas de personalizar y mejorar el comportamiento de las clases. Los métodos mágicos van de la mano con el concepto de programación orientada a objetos (POO) en Python. Por eso es importante comprender el concepto de programación orientada a objetos cuando se intenta utilizar métodos mágicos.