class Persona:
    def __init__(self, nombre, edad):
        self.nombre = nombre      # Atributo
        self.edad = edad          # Atributo

    def saludar(self):            # Método
        return f"Hola, soy {self.nombre}"

class Persona:
    def __init__(self, nombre, edad):
        self.nombre = nombre
        self.edad = edad

# Creamos dos objetos distintos
persona1 = Persona("Ana", 30)
persona2 = Persona("Luis", 25)

print(persona1.nombre)  # Ana
print(persona2.nombre)  # Luis

class Coche:
    def __init__(self, marca, velocidad):
        self.marca = marca          # Atributo
        self.velocidad = velocidad  # Atributo

    def acelerar(self):             # Método
        self.velocidad += 10
        return f"Velocidad actual: {self.velocidad} km/h"

# Creamos un objeto
mi_coche = Coche("Toyota", 120)

print(mi_coche.acelerar())  # Velocidad actual: 130 km/h

class Cafetera:
    def __init__(self):
        self.agua = 100

    def hacer_cafe(self):
        # El usuario no ve estos detalles internos
        self.agua -= 10
        return "Café listo"

# El usuario solo usa el método, sin saber cómo funciona dentro
cafetera = Cafetera()
print(cafetera.hacer_cafe())

class CuentaBancaria:
    def __init__(self, saldo):
        self.__saldo = saldo   # Atributo privado

    def depositar(self, cantidad):
        self.__saldo += cantidad

    def obtener_saldo(self):
        return self.__saldo

cuenta = CuentaBancaria(100)
cuenta.depositar(50)
print(cuenta.obtener_saldo())  # 150

class Animal:
    def __init__(self, nombre):
        self.nombre = nombre

    def hacer_sonido(self):
        return "Sonido genérico"

# Clase hija que hereda de Animal
class Perro(Animal):
    def hacer_sonido(self):
        return "Guau!"

mi_perro = Perro("Toby")
print(mi_perro.nombre)          # Toby
print(mi_perro.hacer_sonido())  # Guau!

class Animal:
    def hacer_sonido(self):
        return "Sonido genérico"

class Perro(Animal):
    def hacer_sonido(self):
        return "Guau!"

class Gato(Animal):
    def hacer_sonido(self):
        return "Miau!"

# Función que usa polimorfismo
def reproducir_sonido(animal):
    print(animal.hacer_sonido())

reproducir_sonido(Perro())  # Guau!
reproducir_sonido(Gato())   # Miau!

from abc import ABC, abstractmethod

# Clase abstracta
class Animal(ABC):

    @abstractmethod
    def hacer_sonido(self):
        pass

# Clase hija que implementa el método abstracto
class Perro(Animal):
    def hacer_sonido(self):
        return "Guau!"

mi_perro = Perro()
print(mi_perro.hacer_sonido())  # Guau!

# Ejemplo del principio S (Responsabilidad Única)

class Reporte:
    def generar(self):
        return "Datos del reporte"

class ReportePrinter:
    def imprimir(self, reporte):
        print(reporte.generar())

printer = ReportePrinter()
printer.imprimir(Reporte())

# Ejemplo simple de Singleton en Python

class Config:
    _instancia = None

    def __new__(cls):
        if cls._instancia is None:
            cls._instancia = super().__new__(cls)
        return cls._instancia

c1 = Config()
c2 = Config()

print(c1 is c2)  # True

# Ejemplo simple de Decorator

def mayusculas(func):
    def wrapper():
        return func().upper()
    return wrapper

@mayusculas
def saludar():
    return "hola"

print(saludar())  # HOLA

# Ejemplo simple de Strategy

class EstrategiaA:
    def ejecutar(self):
        return "Estrategia A"

class EstrategiaB:
    def ejecutar(self):
        return "Estrategia B"

class Contexto:
    def __init__(self, estrategia):
        self.estrategia = estrategia

    def operar(self):
        return self.estrategia.ejecutar()

ctx = Contexto(EstrategiaA())
print(ctx.operar())  # Estrategia A