Profundizando en Programación Orientada a Objetos

Métodos especiales en Python (__init__, __str__, __repr__, etc.).

El método __init__ en Python es un método especial que se utiliza en programación orientada a

objetos (POO). Su función principal es inicializar los atributos de un objeto que creamos.
Básicamente, el método __init__ reemplaza al método de inicialización que habíamos definido
previamente.
Se usa para asignar valores iniciales a los atributos de una instancia de la clase. Los atributos son las
variables que pertenecen a una instancia particular de la clase. Al llamar al método __init__,
podemos establecer los valores de estos atributos y configurar la instancia de la clase para su uso
posterior.
En términos más sencillos, piensa en el método __init__ como el constructor de un objeto en
Python. Es como darle vida a un objeto recién creado, configurando sus características
iniciales para que esté listo para su uso.

El método __str__ se utiliza para devolver una representación de cadena (string) de una instancia
de una clase. Este método se llama cuando se usa la función str() para convertir un objeto en una
cadena de caracteres.
En otras palabras, el método __str__ se emplea para definir cómo se debe imprimir una
instancia de la clase cuando se llama la función str() o cuando se utiliza la interpolación de
cadenas (f-strings).

El método __repr__ se utiliza para devolver una representación de cadena legible de un objeto.
Este método se define dentro de una clase y se llama cuando se usa la función repr() en un objeto de
esa clase.
La representación de cadena devuelta por __repr__() debe ser una cadena que sea suficiente para
recrear el objeto original. Por lo tanto, se espera que el resultado sea una cadena que contenga
información relevante sobre el objeto y sus valores de atributo.
Es importante tener en cuenta que el método __repr__() no es lo mismo que el método
__str__(). El método __str__() devuelve una representación de cadena legible para humanos
del objeto, mientras que el método __repr__() devuelve una representación de cadena que es
suficiente para recrear el objeto.

Ejemplo:

CLASS PERSONA:
DEF __INIT__(SELF, NOMBRE, EDAD):
 SELF.NOMBRE = NOMBRE
SELF.EDAD = EDAD
DEF __REPR__(SELF):
RETURN F"PERSONA(NOMBRE='{SELF.NOMBRE}', EDAD={SELF.EDAD})"

Herencia múltiple y resolución de métodos.

La herencia múltiple en programación orientada a objetos (POO) se refiere a la característica que
permite que una clase herede comportamientos y características de más de una superclase. En
contraste con la herencia simple, donde una clase solo puede heredar de una superclase, la herencia
múltiple amplía las posibilidades.

Ventajas de la herencia múltiple

Reutilización del código

Al tener varias superclases, una subclase tiene más oportunidades de reutilizar los
atributos y operaciones heredados de esas superclases.

Mejora el diseño

Permite modelar relaciones de tipo “es un” que se dan en los problemas que se
pretenden resolver.

Facilita la extensión de las aplicaciones

Añadir una nueva subclase no requiere modificar ninguna otra clase de nuestro
diseño.

Polimorfismo: sobrecarga de operadores y métodos.

El polimorfismo en programación orientada a objetos (POO) es como tener varias formas para un
mismo objeto. Imagina que una persona puede ser empleado, estudiante y padre o madre al mismo
tiempo. En POO, los objetos también son polimórficos. Crear objetos a partir de clases les permite
actuar en nombre de sus clases.

Aquí están las ventajas del polimorfismo:

 Reutilización del código

Al heredar de varias superclases, una subclase puede reutilizar atributos y

operaciones de todas ellas.

Flexibilidad

Los objetos pueden comportarse de diferentes maneras según el contexto. Por

ejemplo, un método puede tener diferentes implementaciones en distintas clases.

Mantenimiento más sencillo

Cambiar el comportamiento de un objeto no afecta a otros objetos de la misma

jerarquía.

El polimorfismo se logra mediante herencia y tiene dos tipos:

Estático (en tiempo de compilación)

Las decisiones sobre qué método o función se ejecutará se toman durante la fase
de compilación del programa.

Dinámico (en tiempo de ejecución).

Las decisiones sobre qué método o función se ejecutarán se toman durante la fase
de ejecución del programa

Ejemplos:
Métodos especiales en Python.
class Punto:
def __init__(self, x, y):
self.x = x
self.y = y

def __str__(self):
return f"({self.x}, {self.y})"

def __add__(self, otro_punto):

return Punto(self.x + otro_punto.x, self.y + otro_punto.y)

Herencia múltiple y resolución de métodos.

class A:
def saludar(self):
print("Hola desde A")

class B:
def saludar(self):
print("Hola desde B")

class C(A, B):

pass

objeto_c = C()
objeto_c.saludar() # Salida: Hola desde A

Polimorfismo: sobrecarga de operadores y métodos.

class Rectangulo:
def __init__(self, largo, ancho):
self.largo = largo
self.ancho = ancho

def area(self):
return self.largo * self.ancho

class Cuadrado(Rectangulo):
def __init__(self, lado):
super().__init__(lado, lado)
rectangulo = Rectangulo(5, 4)
cuadrado = Cuadrado(5)

print(rectangulo.area()) # Salida: 20
print(cuadrado.area()) # Salida: 25
Este programa define una clase Autenticacion que contiene un diccionario de usuarios y
contraseñas. El método autenticar verifica si el usuario y la contraseña proporcionados coinciden
con los almacenados en el diccionario. En la función main, se crea una instancia de Autenticacion y
se solicita al usuario que ingrese su nombre de usuario y contraseña, luego se llama al método
autenticar para verificar las credenciales.

class Autenticacion:
def __init__(self):
self.usuarios = {"usuario1": "contraseña1", "usuario2": "contraseña2"}

def autenticar(self, usuario, contraseña):

if usuario in self.usuarios and self.usuarios[usuario] == contraseña:
print("Inicio de sesión exitoso.")
else:
print("Nombre de usuario o contraseña incorrectos.")

def main():
autenticador = Autenticacion()
usuario = input("Ingrese su nombre de usuario: ")
contraseña = input("Ingrese su contraseña: ")

autenticador.autenticar(usuario, contraseña)

if __name__ == "__main__":
main()