Guía Didáctica
Sistema de Gestión Hotelera

class Habitacion:  # Define la clase Habitacion
    def __init__(self, numero, tipo, precio_noche):  # Constructor: inicializa el objeto con los datos recibidos
        self.numero       = numero  # Guarda numero como atributo de esta instancia
        self.tipo         = tipo  # Guarda tipo como atributo de esta instancia
        self.precio_noche = precio_noche  # Guarda precio_noche como atributo de esta instancia
        self.disponible   = True   # toda habitación nace libre

    def reservar(self):  # Método reservar(): acción que puede realizar este objeto
        if self.disponible:                 # evalúa el booleano directamente
            self.disponible = False  # Guarda disponible como atributo de esta instancia
            return f"✅ Habitación {self.numero} reservada con éxito."  # Retorna el valor calculado al lugar donde se llamó este método
        return f"❌ Habitación {self.numero} ya está ocupada."  # Retorna el valor calculado al lugar donde se llamó este método

class Persona:  # Define la clase Persona
    def __init__(self, nombre, email):  # Constructor: inicializa el objeto con los datos recibidos
        self.nombre = nombre  # Guarda nombre como atributo de esta instancia
        self.email  = email  # Guarda email como atributo de esta instancia

class Cliente(Persona):             # Cliente hereda de Persona
    def __init__(self, nombre, email, telefono):  # Constructor: inicializa el objeto con los datos recibidos
        super().__init__(nombre, email)  # delega al padre
        self.telefono       = telefono  # Guarda telefono como atributo de esta instancia
        self.reservaciones  = []          # historial vacío

class Reservacion:  # Define la clase Reservacion
    def __init__(self, cliente, habitacion, fecha_entrada, fecha_salida):  # Constructor: inicializa el objeto con los datos recibidos
        self.cliente       = cliente      # objeto Cliente
        self.habitacion    = habitacion   # objeto Habitacion
        self.fecha_entrada = fecha_entrada  # Guarda fecha_entrada como atributo de esta instancia
        self.fecha_salida  = fecha_salida  # Guarda fecha_salida como atributo de esta instancia

    def confirmar(self):  # Método confirmar(): acción que puede realizar este objeto
        resultado = self.habitacion.reservar()          # 1. cierra la habitación
        self.cliente.agregar_reservacion(self)          # 2. registra en el cliente
        return resultado                               # 3. devuelve resultado

# archivo biblioteca.py
def cargar_libros():  # Método cargar_libros(): acción que puede realizar este objeto
    return ["POO desde cero", "Diseño de clases", "Herencia útil"]  # Retorna el valor calculado al lugar donde se llamó este método

def mostrar_catalogo():  # Método mostrar_catalogo(): acción que puede realizar este objeto
    for titulo in cargar_libros():  # Itera sobre cada titulo en cargar_libros()
        print(f"• {titulo}")  # Muestra en consola el resultado de esta operación

if __name__ == "__main__":  # Se ejecuta solo cuando este archivo se corre directamente (no cuando se importa)
    print("Ejecutando prueba rápida del módulo biblioteca")  # Muestra en consola el resultado de esta operación
    mostrar_catalogo()  # Completa la llamada o expresión iniciada anteriormente

# archivo app.py
from biblioteca import mostrar_catalogo  # Importa mostrar_catalogo del módulo biblioteca

print("Bienvenido al sistema de biblioteca")  # Muestra en consola el resultado de esta operación
mostrar_catalogo()  # Completa la llamada o expresión iniciada anteriormente

# Al importar biblioteca.py NO se ejecuta el bloque protegido
# porque __name__ ya no vale "__main__".

from abc import ABC, abstractmethod  # Importa ABC, abstractmethod del módulo abc
import math  # Importa el módulo math para usar sus funciones y clases

class Figura(ABC):  # Figura hereda de ABC — recibe todos sus atributos y métodos
    @abstractmethod  # Obliga a las subclases a implementar el siguiente método
    def area(self):  # Método area(): acción que puede realizar este objeto
        pass  # Deja el bloque vacío porque la implementación se completará después

    @abstractmethod  # Obliga a las subclases a implementar el siguiente método
    def perimetro(self):  # Método perimetro(): acción que puede realizar este objeto
        pass  # Deja el bloque vacío porque la implementación se completará después

class Circulo(Figura):  # Circulo hereda de Figura — recibe todos sus atributos y métodos
    def __init__(self, radio):  # Constructor: inicializa el objeto con los datos recibidos
        self.radio = radio  # Guarda radio como atributo de esta instancia

    def area(self):  # Método area(): acción que puede realizar este objeto
        return math.pi * self.radio ** 2  # Retorna el valor calculado al lugar donde se llamó este método

    def perimetro(self):  # Método perimetro(): acción que puede realizar este objeto
        return 2 * math.pi * self.radio  # Retorna el valor calculado al lugar donde se llamó este método

class Rectangulo(Figura):  # Rectangulo hereda de Figura — recibe todos sus atributos y métodos
    def __init__(self, base, altura):  # Constructor: inicializa el objeto con los datos recibidos
        self.base = base  # Guarda base como atributo de esta instancia
        self.altura = altura  # Guarda altura como atributo de esta instancia

    # Falta implementar perimetro()
    def area(self):  # Método area(): acción que puede realizar este objeto
        return self.base * self.altura  # Retorna el valor calculado al lugar donde se llamó este método

# rect = Rectangulo(4, 5)
# TypeError: Can't instantiate abstract class Rectangulo
# with abstract method perimetro

class Animal:  # Define la clase Animal
    pass  # Deja el bloque vacío porque la implementación se completará después

class Mascota(Animal):  # Mascota hereda de Animal — recibe todos sus atributos y métodos
    pass  # Deja el bloque vacío porque la implementación se completará después

class Perro(Mascota):  # Perro hereda de Mascota — recibe todos sus atributos y métodos
    pass  # Deja el bloque vacío porque la implementación se completará después

paciente = Perro()  # Asigna un valor inicial o calculado a paciente

print(isinstance(paciente, Perro))  # Muestra en consola el resultado de esta operación
print(isinstance(paciente, Mascota))  # Muestra en consola el resultado de esta operación
print(isinstance(paciente, Animal))  # Muestra en consola el resultado de esta operación
print(isinstance(paciente, object))  # Muestra en consola el resultado de esta operación

# MENOS FLEXIBLE
if type(paciente) == Mascota:  # Verifica type(paciente) == Mascota antes de continuar
    print("Es mascota")  # Muestra en consola el resultado de esta operación

# MEJOR
if isinstance(paciente, Mascota):  # Verifica isinstance(paciente, Mascota) antes de continuar
    print("Es mascota")  # Muestra en consola el resultado de esta operación

import math  # Importa el módulo math para usar sus funciones y clases

class Circulo:  # Define la clase Circulo
    def __init__(self, radio):  # Constructor: inicializa el objeto con los datos recibidos
        self.radio = radio  # Guarda radio como atributo de esta instancia

    def area(self):  # Método area(): acción que puede realizar este objeto
        return math.pi * math.pow(self.radio, 2)  # Retorna el valor calculado al lugar donde se llamó este método

    def diametro(self):  # Método diametro(): acción que puede realizar este objeto
        return self.radio * 2  # Retorna el valor calculado al lugar donde se llamó este método

    def diagonal_de_caja(self):  # Método diagonal_de_caja(): acción que puede realizar este objeto
        lado = self.diametro()  # Asigna un valor inicial o calculado a lado
        return math.sqrt(lado ** 2 + lado ** 2)  # Retorna el valor calculado al lugar donde se llamó este método

nombre = "Ana López"  # Asigna un valor inicial o calculado a nombre
total = 15432.5  # Asigna un valor inicial o calculado a total

print(f"Empleado: {nombre:<19}")  # Muestra en consola el resultado de esta operación
print(f"Total bruto: {total:.2f}")  # Muestra en consola el resultado de esta operación
print(f"Total alineado: {total:>14}")  # Muestra en consola el resultado de esta operación
print(f"Total con miles: {total:,.2f}")  # Muestra en consola el resultado de esta operación
print(f"Columna completa: {total:>14,.2f}")  # Muestra en consola el resultado de esta operación

# SIN FORMATO
print(f"Laptop {15432.5}")  # Muestra en consola el resultado de esta operación
print(f"Mouse {250}")  # Muestra en consola el resultado de esta operación

# CON FORMATO
print(f"{'Laptop':<19} L {15432.5:>14,.2f}")  # Muestra en consola el resultado de esta operación
print(f"{'Mouse':<19} L {250:>14,.2f}")  # Muestra en consola el resultado de esta operación

# carrito.__items contiene objetos Producto
total = sum(item.get_precio() for item in carrito._Carrito__items)  # Asigna un valor inicial o calculado a total

# equivalente más largo
total = 0  # Asigna un valor inicial o calculado a total
for item in carrito._Carrito__items:  # Itera sobre cada item en carrito._Carrito__items
    total += item.get_precio()  # Completa la llamada o expresión iniciada anteriormente

# universidad: promedio de créditos aprobados
creditos_aprobados = sum(curso.creditos for curso in cursos if curso.aprobado)  # Asigna un valor inicial o calculado a creditos_aprobados

# nómina: total de pagos
pago_total = sum(empleado.calcular_pago() for empleado in empleados)  # Asigna un valor inicial o calculado a pago_total

# figuras: encontrar la de mayor área
mayor = max(figuras, key=lambda f: f.area())

# veterinaria: ordenar pacientes por peso
pacientes_ordenados = sorted(pacientes, key=lambda p: p.peso)

# universidad: alumno con mejor promedio
mejor = max(estudiantes, key=lambda e: e.promedio())

# CON lambda
mayor = max(figuras, key=lambda f: f.area())  # Asigna un valor inicial o calculado a mayor

# SIN lambda
def obtener_area(figura):  # Método obtener_area(): acción que puede realizar este objeto
    return figura.area()  # Retorna el valor calculado al lugar donde se llamó este método

mayor = max(figuras, key=obtener_area)  # Asigna un valor inicial o calculado a mayor

# tienda: total de la compra
total = sum(producto.get_precio() for producto in items)  # Asigna un valor inicial o calculado a total

# figuras: la de mayor área
figura_mayor = max(figuras, key=lambda f: f.area())  # Asigna un valor inicial o calculado a figura_mayor

# universidad: el alumno con menor promedio
en_riesgo = min(estudiantes, key=lambda e: e.promedio())  # Asigna un valor inicial o calculado a en_riesgo

# SIN key=
mayor = max([10, 25, 7])  # Asigna un valor inicial o calculado a mayor

# CON key= sobre objetos
mayor_salario = max(empleados, key=lambda e: e.calcular_pago())  # Asigna un valor inicial o calculado a mayor_salario

# sum() transforma primero y suma después
pago_total = sum(e.calcular_pago() for e in empleados)  # Asigna un valor inicial o calculado a pago_total

class Carrito:  # Define la clase Carrito
    def __init__(self):  # Constructor: inicializa el objeto con los datos recibidos
        self._Carrito__items = []  # Guarda _Carrito__items como atributo protegido de la instancia

    def agregar_producto(self, producto):  # Método agregar_producto(): acción que puede realizar este objeto
        self._Carrito__items.append(producto)  # Agrega un elemento al final de self._Carrito__items

    def generar_recibo(self):  # Método generar_recibo(): acción que puede realizar este objeto
        lineas = []  # Crea una lista vacía para almacenar datos en lineas
        for producto in self._Carrito__items:  # Itera sobre cada producto en self._Carrito__items
            lineas.append(f"{producto.nombre:<19} L {producto.get_precio():>10,.2f}")  # Agrega un elemento al final de lineas
        return "\n".join(lineas)  # Retorna el valor calculado al lugar donde se llamó este método

# INCORRECTO
lineas.join("\n")

# CORRECTO
"\n".join(lineas)

class Figura(ABC):  # Figura hereda de ABC — recibe todos sus atributos y métodos
    @abstractmethod  # Obliga a las subclases a implementar el siguiente método
    def area(self):  # Método area(): acción que puede realizar este objeto
        pass  # Deja el bloque vacío porque la implementación se completará después

    def describir(self):  # Método describir(): acción que puede realizar este objeto
        return f"Soy un objeto de tipo {self.__class__.__name__}"  # Retorna el valor calculado al lugar donde se llamó este método

class Triangulo(Figura):  # Triangulo hereda de Figura — recibe todos sus atributos y métodos
    def area(self):  # Método area(): acción que puede realizar este objeto
        return 0  # Retorna el valor calculado al lugar donde se llamó este método

figura = Triangulo()  # Asigna un valor inicial o calculado a figura
print(figura.describir())  # Muestra en consola el resultado de esta operación

# SIN introspección
def describir(self):  # Método describir(): acción que puede realizar este objeto
    return "Soy una figura"  # Retorna el valor calculado al lugar donde se llamó este método

# CON introspección
def describir(self):  # Método describir(): acción que puede realizar este objeto
    return f"Soy un objeto de tipo {self.__class__.__name__}"  # Retorna el valor calculado al lugar donde se llamó este método

# ── Importación del módulo abc ──────────────────────────────────────────
from abc import ABC, abstractmethod  # Importa ABC, abstractmethod del módulo abc

# ── Clase abstracta: define el CONTRATO ─────────────────────────────────
class Servicio(ABC):                # hereda de ABC para activar el mecanismo
    """Clase base abstracta para todos los servicios del hotel."""  # Continúa la lógica del ejemplo paso a paso

    def __init__(self, nombre: str):  # Constructor: inicializa el objeto con los datos recibidos
        self.__nombre = nombre           # atributo privado compartido

    def get_nombre(self) -> str:  # Getter: devuelve el valor de nombre
        return self.__nombre  # Retorna el valor calculado al lugar donde se llamó este método

    @abstractmethod                  # ← método OBLIGATORIO en subclases
    def calcular_costo(self) -> float:  # Método calcular_costo(): acción que puede realizar este objeto
        """Retorna el costo total del servicio."""  # Continúa la lógica del ejemplo paso a paso
        ...                          # el cuerpo puede ser ... o pass

    @abstractmethod                  # ← otro método OBLIGATORIO
    def descripcion(self) -> str:  # Método descripcion(): acción que puede realizar este objeto
        """Retorna una descripción legible del servicio."""  # Continúa la lógica del ejemplo paso a paso
        ...  # Continúa la lógica del ejemplo paso a paso

    def recibo(self) -> str:          # método CONCRETO: usa los abstractos
        return (  # Retorna el valor calculado al lugar donde se llamó este método
            f"  Servicio : {self.get_nombre()}\n"  # Continúa la lógica del ejemplo paso a paso
            f"  Detalle  : {self.descripcion()}\n"  # Continúa la lógica del ejemplo paso a paso
            f"  Costo    : ${self.calcular_costo():.2f}"  # Continúa la lógica del ejemplo paso a paso
        )  # Cierra la estructura abierta en las líneas anteriores

# ── Clase concreta 1: Habitacion ─────────────────────────────────────────
class Habitacion(Servicio):  # Habitacion hereda de Servicio — recibe todos sus atributos y métodos
    def __init__(self, numero: int, noches: int, tarifa_noche: float):  # Constructor: inicializa el objeto con los datos recibidos
        super().__init__(f"Habitación {numero}")  # Llama al constructor de la clase padre para inicializar atributos heredados
        self.__noches       = noches  # Guarda __noches como atributo privado de la instancia
        self.__tarifa_noche = tarifa_noche  # Guarda __tarifa_noche como atributo privado de la instancia

    def calcular_costo(self) -> float:   # ✅ implementa contrato
        return self.__noches * self.__tarifa_noche  # Retorna el valor calculado al lugar donde se llamó este método

    def descripcion(self) -> str:        # ✅ implementa contrato
        return f"{self.__noches} noche(s) × ${self.__tarifa_noche:.2f}/noche"  # Retorna el valor calculado al lugar donde se llamó este método

# ── Clase concreta 2: Restaurante ────────────────────────────────────────
class Restaurante(Servicio):  # Restaurante hereda de Servicio — recibe todos sus atributos y métodos
    def __init__(self, comensales: int, precio_cubierto: float):  # Constructor: inicializa el objeto con los datos recibidos
        super().__init__("Restaurante del Hotel")  # Llama al constructor de la clase padre para inicializar atributos heredados
        self.__comensales     = comensales  # Guarda __comensales como atributo privado de la instancia
        self.__precio_cubierto = precio_cubierto  # Guarda __precio_cubierto como atributo privado de la instancia

    def calcular_costo(self) -> float:  # Método calcular_costo(): acción que puede realizar este objeto
        return self.__comensales * self.__precio_cubierto  # Retorna el valor calculado al lugar donde se llamó este método

    def descripcion(self) -> str:  # Método descripcion(): acción que puede realizar este objeto
        return f"{self.__comensales} comensal(es) × ${self.__precio_cubierto:.2f}/cubierto"  # Retorna el valor calculado al lugar donde se llamó este método

# ── Clase concreta 3: Spa ────────────────────────────────────────────────
class Spa(Servicio):  # Spa hereda de Servicio — recibe todos sus atributos y métodos
    def __init__(self, tratamiento: str, duracion_min: int, tarifa_hora: float):  # Constructor: inicializa el objeto con los datos recibidos
        super().__init__("Spa & Bienestar")  # Llama al constructor de la clase padre para inicializar atributos heredados
        self.__tratamiento  = tratamiento  # Guarda __tratamiento como atributo privado de la instancia
        self.__duracion_min = duracion_min  # Guarda __duracion_min como atributo privado de la instancia
        self.__tarifa_hora  = tarifa_hora  # Guarda __tarifa_hora como atributo privado de la instancia

    def calcular_costo(self) -> float:  # Método calcular_costo(): acción que puede realizar este objeto
        return (self.__duracion_min / 60) * self.__tarifa_hora  # Retorna el valor calculado al lugar donde se llamó este método

    def descripcion(self) -> str:  # Método descripcion(): acción que puede realizar este objeto
        return f"{self.__tratamiento} — {self.__duracion_min} min a ${self.__tarifa_hora:.2f}/h"  # Retorna el valor calculado al lugar donde se llamó este método

# ── Uso: polimorfismo con lista ──────────────────────────────────────────
servicios = [  # Asigna un valor inicial o calculado a servicios
    Habitacion(101, 3, 1200.00),  # Continúa la lógica del ejemplo paso a paso
    Restaurante(2, 350.00),  # Continúa la lógica del ejemplo paso a paso
    Spa("Masaje sueco", 90, 800.00),  # Continúa la lógica del ejemplo paso a paso
]  # Cierra la estructura abierta en las líneas anteriores

print("═══ FACTURA DE SERVICIOS ═══")  # Muestra en consola el resultado de esta operación
total = 0.0  # Asigna un valor inicial o calculado a total
for s in servicios:  # Itera sobre cada s en servicios
    print(s.recibo())  # Muestra en consola el resultado de esta operación
    print("  ─────────────────────")  # Muestra en consola el resultado de esta operación
    total += s.calcular_costo()  # Completa la llamada o expresión iniciada anteriormente
print(f"  TOTAL A PAGAR: ${total:.2f}")  # Muestra en consola el resultado de esta operación

# ── ¿Qué pasa si intentamos instanciar Servicio directamente? ────────────
try:  # Intenta ejecutar el bloque; si hay error, lo captura el except
    mal = Servicio("Prueba")        # ❌ TypeError — es abstracta
except TypeError as e:  # Captura el error TypeError as e si ocurre en el try
    print(f"\nError esperado: {e}")  # Muestra en consola el resultado de esta operación

# ── Sin importar abc — el "contrato" es una convención, no una ley ───────

class Servicio:                      # clase normal, NO hereda de ABC
    """Clase base 'pseudo-abstracta' — sin mecanismo real de Python."""  # Continúa la lógica del ejemplo paso a paso

    def __init__(self, nombre: str):  # Constructor: inicializa el objeto con los datos recibidos
        self.__nombre = nombre  # Guarda __nombre como atributo privado de la instancia

    def get_nombre(self) -> str:  # Getter: devuelve el valor de nombre
        return self.__nombre  # Retorna el valor calculado al lugar donde se llamó este método

    def calcular_costo(self) -> float:  # Método calcular_costo(): acción que puede realizar este objeto
        # En lugar de @abstractmethod, lanzamos el error manualmente
        raise NotImplementedError(  # Lanza una excepción para señalar un error y detener el flujo normal
            f"{self.__class__.__name__} debe implementar 'calcular_costo()'"  # Continúa la lógica del ejemplo paso a paso
        )  # Cierra la estructura abierta en las líneas anteriores

    def descripcion(self) -> str:  # Método descripcion(): acción que puede realizar este objeto
        raise NotImplementedError(  # Lanza una excepción para señalar un error y detener el flujo normal
            f"{self.__class__.__name__} debe implementar 'descripcion()'"  # Continúa la lógica del ejemplo paso a paso
        )  # Cierra la estructura abierta en las líneas anteriores

    def recibo(self) -> str:  # Método recibo(): acción que puede realizar este objeto
        return (  # Retorna el valor calculado al lugar donde se llamó este método
            f"  Servicio : {self.get_nombre()}\n"  # Continúa la lógica del ejemplo paso a paso
            f"  Detalle  : {self.descripcion()}\n"  # Continúa la lógica del ejemplo paso a paso
            f"  Costo    : ${self.calcular_costo():.2f}"  # Continúa la lógica del ejemplo paso a paso
        )  # Cierra la estructura abierta en las líneas anteriores

# Las subclases son idénticas al ejemplo anterior ─────────────────────────
class Habitacion(Servicio):  # Habitacion hereda de Servicio — recibe todos sus atributos y métodos
    def __init__(self, numero, noches, tarifa_noche):  # Constructor: inicializa el objeto con los datos recibidos
        super().__init__(f"Habitación {numero}")  # Llama al constructor de la clase padre para inicializar atributos heredados
        self.__noches       = noches  # Guarda __noches como atributo privado de la instancia
        self.__tarifa_noche = tarifa_noche  # Guarda __tarifa_noche como atributo privado de la instancia

    def calcular_costo(self):  # Método calcular_costo(): acción que puede realizar este objeto
        return self.__noches * self.__tarifa_noche  # Retorna el valor calculado al lugar donde se llamó este método

    def descripcion(self):  # Método descripcion(): acción que puede realizar este objeto
        return f"{self.__noches} noche(s) × ${self.__tarifa_noche:.2f}/noche"  # Retorna el valor calculado al lugar donde se llamó este método

# ── DIFERENCIA CLAVE: ¿qué pasa si NO implementamos descripcion? ─────────
class ServicioIncompleto(Servicio):   # olvida implementar ambos métodos
    def __init__(self):  # Constructor: inicializa el objeto con los datos recibidos
        super().__init__("Incompleto")  # Llama al constructor de la clase padre para inicializar atributos heredados

# Sin ABC: Python permite crear el objeto sin error ──────────────────────
obj_malo = ServicioIncompleto()   # ⚠️ NO lanza error aquí...
print("Objeto creado sin error (sin ABC).")  # Muestra en consola el resultado de esta operación

try:  # Intenta ejecutar el bloque; si hay error, lo captura el except
    obj_malo.calcular_costo()     # ❌ el error llega TARDE, al llamar el método
except NotImplementedError as e:  # Captura el error NotImplementedError as e si ocurre en el try
    print(f"Error tardío: {e}")  # Muestra en consola el resultado de esta operación

# Uso normal — igual que con ABC ─────────────────────────────────────────
h = Habitacion(202, 2, 950.00)  # Asigna un valor inicial o calculado a h
print(h.recibo())  # Muestra en consola el resultado de esta operación

class CuentaBancaria:  # Define la clase CuentaBancaria
    """Cuenta bancaria con saldo protegido por getter y setters."""  # Continúa la lógica del ejemplo paso a paso

    def __init__(self, titular: str, saldo_inicial: float):  # Constructor: inicializa el objeto con los datos recibidos
        self.__titular = titular  # Guarda __titular como atributo privado de la instancia
        if saldo_inicial < 0:  # Verifica saldo_inicial < 0 antes de continuar
            raise ValueError("El saldo inicial no puede ser negativo.")  # Lanza una excepción para señalar un error y detener el flujo normal
        self.__saldo = saldo_inicial       # atributo privado

    # ── Getters ──────────────────────────────────────────────────────────
    def get_titular(self) -> str:  # Getter: devuelve el valor de titular
        return self.__titular  # Retorna el valor calculado al lugar donde se llamó este método

    def get_saldo(self) -> float:  # Getter: devuelve el valor de saldo
        return self.__saldo  # Retorna el valor calculado al lugar donde se llamó este método

    # ── Setters con validación ────────────────────────────────────────────
    def depositar(self, monto: float) -> None:  # Método depositar(): acción que puede realizar este objeto
        if monto <= 0:  # Verifica monto <= 0 antes de continuar
            raise ValueError("El monto a depositar debe ser positivo.")  # Lanza una excepción para señalar un error y detener el flujo normal
        self.__saldo += monto  # Continúa la lógica del ejemplo paso a paso
        print(f"  ✅ Depósito de ${monto:,.2f} realizado. Saldo: ${self.__saldo:,.2f}")  # Muestra en consola el resultado de esta operación

    def retirar(self, monto: float) -> None:  # Método retirar(): acción que puede realizar este objeto
        if monto <= 0:  # Verifica monto <= 0 antes de continuar
            raise ValueError("El monto a retirar debe ser positivo.")  # Lanza una excepción para señalar un error y detener el flujo normal
        if monto > self.__saldo:  # Verifica monto > self.__saldo antes de continuar
            raise ValueError(f"Fondos insuficientes. Saldo disponible: ${self.__saldo:,.2f}")  # Lanza una excepción para señalar un error y detener el flujo normal
        self.__saldo -= monto  # Continúa la lógica del ejemplo paso a paso
        print(f"  ✅ Retiro de ${monto:,.2f} realizado. Saldo: ${self.__saldo:,.2f}")  # Muestra en consola el resultado de esta operación

    def estado(self) -> str:  # Método estado(): acción que puede realizar este objeto
        return f"Cuenta de {self.__titular} | Saldo: ${self.__saldo:,.2f}"  # Retorna el valor calculado al lugar donde se llamó este método

# ── Uso ──────────────────────────────────────────────────────────────────
cuenta = CuentaBancaria("Ana López", 5000.00)  # Asigna un valor inicial o calculado a cuenta
print("Estado inicial:", cuenta.get_saldo())  # Muestra en consola el resultado de esta operación

cuenta.depositar(2000)  # Completa la llamada o expresión iniciada anteriormente
cuenta.retirar(800)  # Completa la llamada o expresión iniciada anteriormente

try:  # Intenta ejecutar el bloque; si hay error, lo captura el except
    cuenta.retirar(99999)                # ❌ intento de sobregiro
except ValueError as e:  # Captura el error ValueError as e si ocurre en el try
    print(f"  ❌ Error: {e}")  # Muestra en consola el resultado de esta operación

print(cuenta.estado())  # Muestra en consola el resultado de esta operación

# Acceso directo al atributo privado — Python lo rechaza ─────────────────
try:  # Intenta ejecutar el bloque; si hay error, lo captura el except
    cuenta.__saldo = -9999             # ⚠️ crea un atributo nuevo, no modifica el real
    print("Saldo real:", cuenta.get_saldo())  # el __saldo real no cambió
except AttributeError as e:  # Captura el error AttributeError as e si ocurre en el try
    print(f"  ❌ {e}")  # Muestra en consola el resultado de esta operación

class Empleado:  # Define la clase Empleado
    """Empleado del hotel con encapsulamiento completo."""  # Continúa la lógica del ejemplo paso a paso

    def __init__(self, nombre: str, puesto: str, salario: float):  # Constructor: inicializa el objeto con los datos recibidos
        self.set_nombre(nombre)     # reutiliza la validación del setter
        self.__puesto  = puesto     # read-only: solo getter
        self.set_salario(salario)  # Completa la llamada o expresión iniciada anteriormente

    # ── Getters ──────────────────────────────────────────────────────────
    def get_nombre(self)  -> str:   return self.__nombre  # Getter: devuelve el valor de nombre
    def get_puesto(self)  -> str:   return self.__puesto   # read-only
    def get_salario(self) -> float: return self.__salario  # Getter: devuelve el valor de salario

    # ── Setters con validación ────────────────────────────────────────────
    def set_nombre(self, nuevo_nombre: str) -> None:  # Setter: valida y actualiza el atributo nombre
        nuevo_nombre = nuevo_nombre.strip()  # Asigna un valor inicial o calculado a nuevo_nombre
        if not nuevo_nombre:  # Verifica not nuevo_nombre antes de continuar
            raise ValueError("El nombre no puede estar vacío.")  # Lanza una excepción para señalar un error y detener el flujo normal
        self.__nombre = nuevo_nombre  # Guarda __nombre como atributo privado de la instancia

    def set_salario(self, nuevo_salario: float) -> None:  # Setter: valida y actualiza el atributo salario
        if nuevo_salario < 0:  # Verifica nuevo_salario < 0 antes de continuar
            raise ValueError(f"El salario no puede ser negativo. Recibido: {nuevo_salario}")  # Lanza una excepción para señalar un error y detener el flujo normal
        self.__salario = nuevo_salario  # Guarda __salario como atributo privado de la instancia

    def aplicar_aumento(self, porcentaje: float) -> None:  # Método aplicar_aumento(): acción que puede realizar este objeto
        if porcentaje <= 0:  # Verifica porcentaje <= 0 antes de continuar
            raise ValueError("El porcentaje de aumento debe ser positivo.")  # Lanza una excepción para señalar un error y detener el flujo normal
        aumento = self.__salario * (porcentaje / 100)  # Asigna un valor inicial o calculado a aumento
        self.__salario += aumento  # Continúa la lógica del ejemplo paso a paso
        print(f"  Aumento del {porcentaje}%: +${aumento:,.2f} → Nuevo salario: ${self.__salario:,.2f}")  # Muestra en consola el resultado de esta operación

    def __str__(self) -> str:  # Define cómo se muestra el objeto al usar print()
        return f"[{self.__puesto}] {self.__nombre} — Salario: ${self.__salario:,.2f}"  # Retorna el valor calculado al lugar donde se llamó este método

# ── Uso ──────────────────────────────────────────────────────────────────
emp = Empleado("Carlos Ruiz", "Recepcionista", 18000.00)  # Asigna un valor inicial o calculado a emp
print(emp)  # Muestra en consola el resultado de esta operación
emp.aplicar_aumento(10)  # Completa la llamada o expresión iniciada anteriormente
emp.set_nombre("Carlos A. Ruiz")  # Completa la llamada o expresión iniciada anteriormente
print(emp)  # Muestra en consola el resultado de esta operación

try:  # Intenta ejecutar el bloque; si hay error, lo captura el except
    emp.set_salario(-5000)             # ❌ salario negativo
except ValueError as e:  # Captura el error ValueError as e si ocurre en el try
    print(f"  ❌ {e}")  # Muestra en consola el resultado de esta operación

class Reservacion:  # Define la clase Reservacion
    """Reservación hotelera con encapsulamiento de todos sus atributos."""  # Continúa la lógica del ejemplo paso a paso

    def __init__(self, num_habitacion: int, huesped: str, noches: int):  # Constructor: inicializa el objeto con los datos recibidos
        self.__num_habitacion = num_habitacion   # write-once: sin setter
        self.set_huesped(huesped)  # Completa la llamada o expresión iniciada anteriormente
        self.set_noches(noches)  # Completa la llamada o expresión iniciada anteriormente

    # ── Getters ──────────────────────────────────────────────────────────
    def get_num_habitacion(self) -> int:   return self.__num_habitacion  # Getter: devuelve el valor de num_habitacion
    def get_huesped(self)       -> str:   return self.__huesped  # Getter: devuelve el valor de huesped
    def get_noches(self)        -> int:   return self.__noches  # Getter: devuelve el valor de noches

    # ── Setters ──────────────────────────────────────────────────────────
    def set_huesped(self, nombre: str) -> None:  # Setter: valida y actualiza el atributo huesped
        nombre = nombre.strip()  # Asigna un valor inicial o calculado a nombre
        if not nombre:  # Verifica not nombre antes de continuar
            raise ValueError("El nombre del huésped no puede estar vacío.")  # Lanza una excepción para señalar un error y detener el flujo normal
        self.__huesped = nombre  # Guarda __huesped como atributo privado de la instancia

    def set_noches(self, cantidad: int) -> None:  # Setter: valida y actualiza el atributo noches
        if not (1 <= cantidad <= 30):  # Verifica not (1 <= cantidad <= 30) antes de continuar
            raise ValueError(f"Las noches deben estar entre 1 y 30. Recibido: {cantidad}")  # Lanza una excepción para señalar un error y detener el flujo normal
        self.__noches = cantidad  # Guarda __noches como atributo privado de la instancia

    def costo_estimado(self, tarifa_noche: float = 1200.0) -> float:  # Método costo_estimado(): acción que puede realizar este objeto
        return self.__noches * tarifa_noche  # Retorna el valor calculado al lugar donde se llamó este método

    def __str__(self) -> str:  # Define cómo se muestra el objeto al usar print()
        return (  # Retorna el valor calculado al lugar donde se llamó este método
            f"Reservación | Hab: {self.__num_habitacion} | "  # Continúa la lógica del ejemplo paso a paso
            f"Huésped: {self.__huesped} | Noches: {self.__noches} | "  # Continúa la lógica del ejemplo paso a paso
            f"Costo est.: ${self.costo_estimado():,.2f}"  # Continúa la lógica del ejemplo paso a paso
        )  # Cierra la estructura abierta en las líneas anteriores

# ── Uso ──────────────────────────────────────────────────────────────────
r = Reservacion(305, "María García", 3)  # Asigna un valor inicial o calculado a r
print(r)  # Muestra en consola el resultado de esta operación

r.set_noches(5)           # extensión de estancia
r.set_huesped("María G. Pérez")  # Completa la llamada o expresión iniciada anteriormente
print(r)  # Muestra en consola el resultado de esta operación

try:  # Intenta ejecutar el bloque; si hay error, lo captura el except
    r.set_noches(0)         # ❌ valor fuera de rango
except ValueError as e:  # Captura el error ValueError as e si ocurre en el try
    print(f"  ❌ {e}")  # Muestra en consola el resultado de esta operación

try:  # Intenta ejecutar el bloque; si hay error, lo captura el except
    r.set_noches(45)        # ❌ demasiadas noches
except ValueError as e:  # Captura el error ValueError as e si ocurre en el try
    print(f"  ❌ {e}")  # Muestra en consola el resultado de esta operación

# ── Definición de la clase ───────────────────────────────────────────────
class Huesped:  # Define la clase Huesped
    def __init__(self, nombre: str, habitacion: int, noches: int):  # Constructor: inicializa el objeto con los datos recibidos
        self.nombre     = nombre  # Guarda nombre como atributo de esta instancia
        self.habitacion = habitacion  # Guarda habitacion como atributo de esta instancia
        self.noches     = noches  # Guarda noches como atributo de esta instancia

    def costo(self, tarifa: float = 1000.0) -> float:  # Método costo(): acción que puede realizar este objeto
        return self.noches * tarifa  # Retorna el valor calculado al lugar donde se llamó este método

    def __str__(self) -> str:  # Define cómo se muestra el objeto al usar print()
        return f"Hab {self.habitacion:>3} | {self.nombre:<20} | {self.noches} noche(s)"  # Retorna el valor calculado al lugar donde se llamó este método

# ── 1. Crear lista vacía y agregar con append() ──────────────────────────
huespedes = []                          # lista vacía

huespedes.append(Huesped("Ana Torres",    101, 3))  # Agrega un elemento al final de huespedes
huespedes.append(Huesped("Luis Ramos",    102, 1))  # Agrega un elemento al final de huespedes
huespedes.append(Huesped("Sandra Paz",    203, 5))  # Agrega un elemento al final de huespedes
huespedes.append(Huesped("Jorge Medina", 204, 2))  # Agrega un elemento al final de huespedes
huespedes.append(Huesped("Laura Soto",   305, 7))  # Agrega un elemento al final de huespedes

# ── 2. Recorrer con for básico ────────────────────────────────────────────
print("═══ LISTA COMPLETA DE HUÉSPEDES ═══")  # Muestra en consola el resultado de esta operación
for h in huespedes:  # Itera sobre cada h en huespedes
    print(f"  {h}")                     # usa __str__ automáticamente

# ── 3. Recorrer con enumerate() — índice + elemento ──────────────────────
print("\n═══ CON NÚMERO DE ORDEN ═══")  # Muestra en consola el resultado de esta operación
for i, h in enumerate(huespedes, start=1):  # Itera sobre cada i, h en enumerate(huespedes, start=1)
    print(f"  {i}. {h.nombre}")  # Muestra en consola el resultado de esta operación

# ── 4. Filtrar con for + if ───────────────────────────────────────────────
print("\n═══ HUÉSPEDES CON MÁS DE 3 NOCHES ═══")  # Muestra en consola el resultado de esta operación
for h in huespedes:  # Itera sobre cada h en huespedes
    if h.noches > 3:  # Verifica h.noches > 3 antes de continuar
        print(f"  {h.nombre} — {h.noches} noches")  # Muestra en consola el resultado de esta operación

# ── 5. Calcular total con for ─────────────────────────────────────────────
total = 0.0  # Asigna un valor inicial o calculado a total
for h in huespedes:  # Itera sobre cada h en huespedes
    total += h.costo()  # Completa la llamada o expresión iniciada anteriormente
print(f"\n  Ingresos totales del hotel: ${total:,.2f}")  # Muestra en consola el resultado de esta operación

# ── 6. Comprensión de lista: obtener solo los nombres ────────────────────
nombres = [h.nombre for h in huespedes]  # Asigna un valor inicial o calculado a nombres
print(f"\n  Nombres (comprensión): {nombres}")  # Muestra en consola el resultado de esta operación

# ── 7. Comprensión de lista con filtro ───────────────────────────────────
estancias_largas = [h.nombre for h in huespedes if h.noches >= 5]  # Asigna un valor inicial o calculado a estancias_largas
print(f"  Estancias ≥ 5 noches: {estancias_largas}")  # Muestra en consola el resultado de esta operación

# ── 1. Diccionario simple: clave → valor ─────────────────────────────────
#    clave  = número de habitación (int)
#    valor  = estado (str)
habitaciones = {  # Asigna un valor inicial o calculado a habitaciones
    101: "disponible",  # Continúa la lógica del ejemplo paso a paso
    102: "ocupada",  # Continúa la lógica del ejemplo paso a paso
    103: "mantenimiento",  # Continúa la lógica del ejemplo paso a paso
    201: "disponible",  # Continúa la lógica del ejemplo paso a paso
    202: "ocupada",  # Continúa la lógica del ejemplo paso a paso
    203: "disponible",  # Continúa la lógica del ejemplo paso a paso
}  # Cierra la estructura abierta en las líneas anteriores

# ── 2. Acceso directo por clave ───────────────────────────────────────────
print("Estado hab. 102:", habitaciones[102])  # Muestra en consola el resultado de esta operación

# ── 3. Acceso seguro con get() ─────────────────────────────────────────────
estado = habitaciones.get(999, "no existe")   # clave inexistente
print("Estado hab. 999:", estado)  # Muestra en consola el resultado de esta operación

# ── 4. Recorrer con items() ──────────────────────────────────────────────
print("\n═══ INVENTARIO COMPLETO ═══")  # Muestra en consola el resultado de esta operación
for numero, estado in habitaciones.items():  # Itera sobre cada numero, estado en habitaciones.items()
    print(f"  Hab {numero}: {estado}")  # Muestra en consola el resultado de esta operación

# ── 5. Filtrar con for + if sobre items() ────────────────────────────────
print("\n═══ HABITACIONES DISPONIBLES ═══")  # Muestra en consola el resultado de esta operación
for numero, estado in habitaciones.items():  # Itera sobre cada numero, estado en habitaciones.items()
    if estado == "disponible":  # Verifica estado == "disponible" antes de continuar
        print(f"  ✅ Habitación {numero}")  # Muestra en consola el resultado de esta operación

# ── 6. Actualizar un valor ────────────────────────────────────────────────
habitaciones[201] = "ocupada"             # check-in en hab. 201
print(f"\nHab 201 actualizada: {habitaciones[201]}")  # Muestra en consola el resultado de esta operación

# ── 7. Agregar una habitación nueva ──────────────────────────────────────
habitaciones[301] = "disponible"  # Asigna un valor inicial o calculado a habitaciones[301]
print(f"Total de habitaciones: {len(habitaciones)}")  # Muestra en consola el resultado de esta operación

# ── 8. Comprensión de diccionario: solo las disponibles ──────────────────
disponibles = {num: est for num, est in habitaciones.items() if est == "disponible"}  # Asigna un valor inicial o calculado a disponibles
print(f"\nDisponibles (dict comprehension): {disponibles}")  # Muestra en consola el resultado de esta operación

# ── Diccionario anidado: cada clave es un ID, cada valor es un dict ───────
reservaciones = {  # Asigna un valor inicial o calculado a reservaciones
    "RES-001": {  # Continúa la lógica del ejemplo paso a paso
        "huesped"    : "Ana Torres",  # Continúa la lógica del ejemplo paso a paso
        "habitacion" : 101,  # Continúa la lógica del ejemplo paso a paso
        "noches"     : 3,  # Continúa la lógica del ejemplo paso a paso
        "desayuno"   : True,  # Continúa la lógica del ejemplo paso a paso
    },  # Continúa la lógica del ejemplo paso a paso
    "RES-002": {  # Continúa la lógica del ejemplo paso a paso
        "huesped"    : "Luis Ramos",  # Continúa la lógica del ejemplo paso a paso
        "habitacion" : 204,  # Continúa la lógica del ejemplo paso a paso
        "noches"     : 1,  # Continúa la lógica del ejemplo paso a paso
        "desayuno"   : False,  # Continúa la lógica del ejemplo paso a paso
    },  # Continúa la lógica del ejemplo paso a paso
    "RES-003": {  # Continúa la lógica del ejemplo paso a paso
        "huesped"    : "Sandra Paz",  # Continúa la lógica del ejemplo paso a paso
        "habitacion" : 305,  # Continúa la lógica del ejemplo paso a paso
        "noches"     : 5,  # Continúa la lógica del ejemplo paso a paso
        "desayuno"   : True,  # Continúa la lógica del ejemplo paso a paso
    },  # Continúa la lógica del ejemplo paso a paso
}  # Cierra la estructura abierta en las líneas anteriores

# ── 1. Recorrer con items(): id_reservacion, datos ───────────────────────
TARIFA        = 1200.0  # Asigna un valor inicial o calculado a TARIFA
COSTO_DESAYUNO = 150.0  # Asigna un valor inicial o calculado a COSTO_DESAYUNO

print("═══ RESUMEN DE RESERVACIONES ═══")  # Muestra en consola el resultado de esta operación
for id_res, datos in reservaciones.items():  # Itera sobre cada id_res, datos en reservaciones.items()
    costo = datos["noches"] * TARIFA  # Asigna un valor inicial o calculado a costo
    if datos["desayuno"]:  # Verifica datos["desayuno"] antes de continuar
        costo += datos["noches"] * COSTO_DESAYUNO  # Continúa la lógica del ejemplo paso a paso
    print(f"  {id_res} | {datos['huesped']:<15} | Hab {datos['habitacion']} | ${costo:,.2f}")  # Muestra en consola el resultado de esta operación

# ── 2. Acceder a un dato específico de una reservación ───────────────────
print(f"\nHuésped RES-002: {reservaciones['RES-002']['huesped']}")  # Muestra en consola el resultado de esta operación

# ── 3. Agregar una nueva reservación en tiempo de ejecución ──────────────
reservaciones["RES-004"] = {  # Continúa la lógica del ejemplo paso a paso
    "huesped"    : "Jorge Medina",  # Continúa la lógica del ejemplo paso a paso
    "habitacion" : 102,  # Continúa la lógica del ejemplo paso a paso
    "noches"     : 2,  # Continúa la lógica del ejemplo paso a paso
    "desayuno"   : False,  # Continúa la lógica del ejemplo paso a paso
}  # Cierra la estructura abierta en las líneas anteriores
print(f"\nTotal reservaciones: {len(reservaciones)}")  # Muestra en consola el resultado de esta operación

# ── 4. Filtrar con for: reservaciones CON desayuno ───────────────────────
print("\n═══ RESERVACIONES CON DESAYUNO ═══")  # Muestra en consola el resultado de esta operación
for id_res, datos in reservaciones.items():  # Itera sobre cada id_res, datos en reservaciones.items()
    if datos["desayuno"]:  # Verifica datos["desayuno"] antes de continuar
        print(f"  ☕ {id_res} — {datos['huesped']}")  # Muestra en consola el resultado de esta operación

# ── 5. Comprensión de diccionario ────────────────────────────────────────
# Obtener solo {id: nombre_huesped} para las reservaciones largas
largas = {  # Asigna un valor inicial o calculado a largas
    id_res: datos["huesped"]  # Cierra la lista o el índice construido en las líneas anteriores
    for id_res, datos in reservaciones.items()  # Recorre cada elemento de la colección indicada
    if datos["noches"] >= 3  # Verifica datos["noches"] >= 3 antes de continuar
}  # Cierra la estructura abierta en las líneas anteriores
print(f"\nReservaciones largas (≥3 noches): {largas}")  # Muestra en consola el resultado de esta operación

# ── = (asignación) — GUARDA un valor ────────────────────────────────────
estado = "disponible"   # la variable 'estado' ahora CONTIENE "disponible"
noches = 3              # la variable 'noches' ahora CONTIENE 3
precio = noches * 1200  # calcula y GUARDA el resultado en 'precio'

# ── == (comparación) — PREGUNTA si dos cosas son iguales ─────────────────
print(estado == "disponible")   # → True  (sí son iguales)
print(estado == "ocupada")      # → False (no son iguales)
print(noches == 5)              # → False
print(noches == 3)              # → True

# ── En un if siempre usamos == ───────────────────────────────────────────
if estado == "disponible":       # ✅ correcto: comparamos
    print("La habitación está libre")  # Muestra en consola el resultado de esta operación

# ── = dentro de un objeto ────────────────────────────────────────────────
class Habitacion:  # Define la clase Habitacion
    def __init__(self, numero):  # Constructor: inicializa el objeto con los datos recibidos
        self.numero     = numero        # = GUARDA el número en el objeto
        self.disponible = True         # = GUARDA True en el atributo

    def reservar(self):  # Método reservar(): acción que puede realizar este objeto
        if self.disponible == True:   # == PREGUNTA si está disponible
            self.disponible = False   # = CAMBIA el estado a False
            return "✅ Habitación reservada"  # Retorna el valor calculado al lugar donde se llamó este método
        return "❌ Ya estaba ocupada"  # Retorna el valor calculado al lugar donde se llamó este método

h = Habitacion(101)  # Asigna un valor inicial o calculado a h
print(h.reservar())     # → ✅ Habitación reservada
print(h.reservar())     # → ❌ Ya estaba ocupada

# ── Una lista es como una fila de cajas numeradas ───────────────────────
reservaciones = []               # fila vacía

# append() AGREGA una nueva caja AL FINAL de la fila
reservaciones.append("RES-001")   # → ["RES-001"]
reservaciones.append("RES-002")   # → ["RES-001", "RES-002"]
reservaciones.append("RES-003")   # → ["RES-001", "RES-002", "RES-003"]

print(reservaciones)             # → ['RES-001', 'RES-002', 'RES-003']
print(len(reservaciones))        # → 3

# ── append de objetos enteros ────────────────────────────────────────────
class Reservacion:  # Define la clase Reservacion
    def __init__(self, id_res):  # Constructor: inicializa el objeto con los datos recibidos
        self.id_res = id_res  # Guarda id_res como atributo de esta instancia
    def __str__(self):  # Define cómo se muestra el objeto al usar print()
        return f"Reservación({self.id_res})"  # Retorna el valor calculado al lugar donde se llamó este método

historial = []  # Crea una lista vacía para almacenar datos en historial
historial.append(Reservacion("RES-001"))   # guarda el OBJETO completo
historial.append(Reservacion("RES-002"))  # Agrega un elemento al final de historial

for r in historial:  # Itera sobre cada r en historial
    print(r)   # → Reservación(RES-001)  /  Reservación(RES-002)

# ── Diferencia clave entre append() y = ──────────────────────────────────
lista_a = [1, 2, 3]  # Asigna un valor inicial o calculado a lista_a
lista_a.append(4)  # AGREGA 4 al final → [1, 2, 3, 4]

lista_b = [1, 2, 3]  # Asigna un valor inicial o calculado a lista_b
lista_b = [4]      # REEMPLAZA toda la lista → [4]  ⚠️ pierdes [1,2,3]

# ── Error clásico: guardar el resultado de append() ──────────────────────
lista_c = [1, 2]  # Asigna un valor inicial o calculado a lista_c
lista_c = lista_c.append(3)   # ⚠️ append devuelve None
print(lista_c)                 # → None  ❌ la lista original se perdió

def confirmar(self):  # Método confirmar(): acción que puede realizar este objeto
    resultado = self.habitacion.reservar()      # línea 1
    self.cliente.agregar_reservacion(self)    # línea 2
    return resultado                           # línea 3

# Python evalúa siempre de DERECHA a IZQUIERDA cuando hay =
#
#   resultado  =  self.habitacion.reservar()
#       ↑                   ↑
#   DESTINO           ORIGEN (se ejecuta primero)
#
# Paso 1: Python ejecuta self.habitacion.reservar()
# Paso 2: ese método DEVUELVE un valor (ej: "✅ Habitación reservada")
# Paso 3: ese valor se GUARDA en la variable 'resultado'
# Paso 4: 'return resultado' lo entrega al código que llamó confirmar()

# Mismo principio con una suma:
x = 5 + 3          # primero calcula 5+3=8, luego guarda 8 en x

# Sin variable intermedia — también válido:
return self.habitacion.reservar()  # ✅ directo, pero llama al método una sola vez

# Con variable — más legible y evita doble llamada:
resultado = self.habitacion.reservar()  # Asigna un valor inicial o calculado a resultado
return resultado                    # ✅ preferido en código profesional

# En __init__ de Reservacion guardamos el OBJETO Habitacion completo:
class Reservacion:  # Define la clase Reservacion
    def __init__(self, cliente, habitacion, fecha_entrada, fecha_salida):  # Constructor: inicializa el objeto con los datos recibidos
        self.cliente    = cliente      # ← OBJETO Cliente guardado aquí
        self.habitacion = habitacion   # ← OBJETO Habitacion guardado aquí

    def confirmar(self):  # Método confirmar(): acción que puede realizar este objeto
        # self            → este objeto Reservacion
        # self.habitacion → el objeto Habitacion guardado en el atributo
        # .reservar()     → llama al método reservar() de ESE objeto Habitacion
        resultado = self.habitacion.reservar()  # Asigna un valor inicial o calculado a resultado

# Es exactamente igual a:  hab101.reservar()  — donde hab101 === self.habitacion

# ¿Qué pasa si no pongo self en la definición del método? ────────────────
class ReservacionMal:  # Define la clase ReservacionMal
    def confirmar():              # ⚠️ sin self
        resultado = habitacion.reservar()  # ❌ NameError: 'habitacion' no existe

reserva = ReservacionMal()  # Asigna un valor inicial o calculado a reserva
reserva.confirmar()             # ❌ TypeError: confirmar() takes 0 arguments but 1 was given
# Python intenta pasar el objeto pero no hay parámetro para recibirlo

# self.cliente ES el objeto Cliente completo — puedes usar TODOS sus atributos y métodos

class Cliente:  # Define la clase Cliente
    def __init__(self, nombre, email):  # Constructor: inicializa el objeto con los datos recibidos
        self.nombre        = nombre  # Guarda nombre como atributo de esta instancia
        self.email         = email  # Guarda email como atributo de esta instancia
        self.reservaciones = []  # Guarda reservaciones como atributo de esta instancia

    def agregar_reservacion(self, reservacion):  # Método agregar_reservacion(): acción que puede realizar este objeto
        self.reservaciones.append(reservacion)  # Agrega un elemento al final de self.reservaciones

    def get_nombre(self):        return self.nombre  # Getter: devuelve el valor de nombre
    def get_email(self):         return self.email  # Getter: devuelve el valor de email
    def total_reservaciones(self): return len(self.reservaciones)  # Método total_reservaciones(): acción que puede realizar este objeto

# Desde confirmar() puedes hacer CUALQUIERA de estas cosas:
def confirmar(self):  # Método confirmar(): acción que puede realizar este objeto
    # Acceder a atributos:
    print(self.cliente.nombre)              # → "Ana Torres"
    print(self.cliente.email)               # → "ana@email.com"
    # Llamar a métodos:
    print(self.cliente.get_nombre())        # → "Ana Torres" (getter)
    print(self.cliente.total_reservaciones()) # → número de reservaciones
    # Agregar esta reservación al historial del cliente:
    self.cliente.agregar_reservacion(self)  # ← lo que hace la línea 2

# ── Hay DOS usos distintos de self — no confundirlos ────────────────────

# USO 1: self en la DEFINICIÓN (parámetro) — significa "yo, este objeto"
def agregar_reservacion(self, reservacion):   # self = el objeto Cliente
    self.reservaciones.append(reservacion)  # Agrega un elemento al final de self.reservaciones

# USO 2: self en la LLAMADA (argumento) — pasa la Reservacion como dato
self.cliente.agregar_reservacion(self)  # Completa la llamada o expresión iniciada anteriormente
#  ↑ objeto Reservacion        ↑ ¡este self también es la Reservacion!
#  llama al método del cliente    y le pasa ESTA reservación como argumento

# Traducido a nombres más claros:
#   self             = la Reservacion actual
#   self.cliente     = el objeto Cliente
#   agregar_reservacion(self) → "cliente, guarda ESTA reservación en tu historial"

# ── ¿QUÉ PASA SI NO PONGO self? ──────────────────────────────────────────
class Cliente:  # Define la clase Cliente
    def __init__(self, nombre):  # Constructor: inicializa el objeto con los datos recibidos
        self.nombre = nombre  # Guarda nombre como atributo de esta instancia
        self.reservaciones = []  # Guarda reservaciones como atributo de esta instancia
    def agregar_reservacion(self, reservacion):  # Método agregar_reservacion(): acción que puede realizar este objeto
        self.reservaciones.append(reservacion)  # Agrega un elemento al final de self.reservaciones

class Reservacion:  # Define la clase Reservacion
    def __init__(self, cliente, id_res):  # Constructor: inicializa el objeto con los datos recibidos
        self.cliente = cliente  # Guarda cliente como atributo de esta instancia
        self.id_res  = id_res  # Guarda id_res como atributo de esta instancia

    def confirmar_correcto(self):  # Método confirmar_correcto(): acción que puede realizar este objeto
        self.cliente.agregar_reservacion(self)   # ✅ pasa la reservación completa

    def confirmar_incorrecto(self):  # Método confirmar_incorrecto(): acción que puede realizar este objeto
        self.cliente.agregar_reservacion()        # ❌ falta el argumento reservacion

cli = Cliente("Ana Torres")  # Asigna un valor inicial o calculado a cli
res = Reservacion(cli, "RES-001")  # Asigna un valor inicial o calculado a res

res.confirmar_correcto()  # Completa la llamada o expresión iniciada anteriormente
print(cli.reservaciones[0].id_res)   # → RES-001  ✅

try:  # Intenta ejecutar el bloque; si hay error, lo captura el except
    res.confirmar_incorrecto()  # Completa la llamada o expresión iniciada anteriormente
except TypeError as e:  # Captura el error TypeError as e si ocurre en el try
    print(f"Error: {e}")   # → TypeError: missing 1 required argument: 'reservacion'

# ════════════════════════════════════════════════════════════════════
#  SISTEMA COMPLETO — Hotel con historial de reservaciones por cliente  # Comentario de apoyo que guía la lectura del ejemplo
# ════════════════════════════════════════════════════════════════════  # Comentario de apoyo que guía la lectura del ejemplo

class Habitacion:  # Define la clase Habitacion
    def __init__(self, numero: int, tipo: str, tarifa: float):  # Constructor: inicializa el objeto con los datos recibidos
        self.numero     = numero  # Guarda numero como atributo de esta instancia
        self.tipo       = tipo  # Guarda tipo como atributo de esta instancia
        self.tarifa     = tarifa  # Guarda tarifa como atributo de esta instancia
        self.disponible = True  # Guarda disponible como atributo de esta instancia

    def reservar(self) -> str:  # Método reservar(): acción que puede realizar este objeto
        if self.disponible:  # Verifica self.disponible antes de continuar
            self.disponible = False  # Guarda disponible como atributo de esta instancia
            return f"✅ Hab {self.numero} ({self.tipo}) reservada"  # Retorna el valor calculado al lugar donde se llamó este método
        return f"❌ Hab {self.numero} ya está ocupada"  # Retorna el valor calculado al lugar donde se llamó este método

    def __str__(self) -> str:  # Define cómo se muestra el objeto al usar print()
        est = "disponible" if self.disponible else "ocupada"  # Asigna un valor inicial o calculado a est
        return f"Hab {self.numero} [{self.tipo}] ${self.tarifa:.2f}/noche — {est}"  # Retorna el valor calculado al lugar donde se llamó este método


class Cliente:  # Define la clase Cliente
    def __init__(self, nombre: str, email: str):  # Constructor: inicializa el objeto con los datos recibidos
        self.nombre        = nombre  # Guarda nombre como atributo de esta instancia
        self.email         = email  # Guarda email como atributo de esta instancia
        self.reservaciones = []       # lista vacía — se llena con append()

    def agregar_reservacion(self, reservacion) -> None:  # Método agregar_reservacion(): acción que puede realizar este objeto
        self.reservaciones.append(reservacion)  # Agrega un elemento al final de self.reservaciones

    def ver_reservaciones(self) -> None:  # Método ver_reservaciones(): acción que puede realizar este objeto
        """Imprime todo el historial del cliente con totales."""  # Continúa la lógica del ejemplo paso a paso
        print(f"\n  📋 Historial de {self.nombre} ({self.email})")  # Muestra en consola el resultado de esta operación
        print(f"  {'─' * 50}")  # Muestra en consola el resultado de esta operación
        if not self.reservaciones:  # Verifica not self.reservaciones antes de continuar
            print("  Sin reservaciones registradas.")  # Muestra en consola el resultado de esta operación
            return  # Termina el método y devuelve el control al llamador
        total = 0.0  # Asigna un valor inicial o calculado a total
        for i, res in enumerate(self.reservaciones, start=1):  # Itera sobre cada i, res en enumerate(self.reservaciones, start=1)
            costo = res.noches * res.habitacion.tarifa  # Asigna un valor inicial o calculado a costo
            total += costo  # Continúa la lógica del ejemplo paso a paso
            print(  # Muestra en consola el resultado de esta operación
                f"  {i}. Hab {res.habitacion.numero} | "  # Continúa la lógica del ejemplo paso a paso
                f"{res.fecha_entrada} → {res.fecha_salida} | "  # Continúa la lógica del ejemplo paso a paso
                f"{res.noches} noche(s) | ${costo:,.2f}"  # Continúa la lógica del ejemplo paso a paso
            )  # Cierra la estructura abierta en las líneas anteriores
        print(f"  {'─' * 50}")  # Muestra en consola el resultado de esta operación
        print(f"  Total gastado: ${total:,.2f}")  # Muestra en consola el resultado de esta operación

    def __str__(self) -> str:  # Define cómo se muestra el objeto al usar print()
        return f"Cliente: {self.nombre} | {len(self.reservaciones)} reservación(es)"  # Retorna el valor calculado al lugar donde se llamó este método


class Reservacion:  # Define la clase Reservacion
    def __init__(self, cliente: Cliente, habitacion: Habitacion,  # Constructor: inicializa el objeto con los datos recibidos
                 fecha_entrada: str, fecha_salida: str, noches: int):  # Completa la firma o la condición iniciada en la línea anterior
        self.cliente       = cliente  # Guarda cliente como atributo de esta instancia
        self.habitacion    = habitacion  # Guarda habitacion como atributo de esta instancia
        self.fecha_entrada  = fecha_entrada  # Guarda fecha_entrada como atributo de esta instancia
        self.fecha_salida   = fecha_salida  # Guarda fecha_salida como atributo de esta instancia
        self.noches         = noches  # Guarda noches como atributo de esta instancia

    def confirmar(self) -> str:  # Método confirmar(): acción que puede realizar este objeto
        resultado = self.habitacion.reservar()   # 1. cierra la habitación
        self.cliente.agregar_reservacion(self) # 2. agrega al historial del cliente
        return resultado                        # 3. devuelve el mensaje

# ════════════════════════════════════════════════════════════════════
# Crear habitaciones
hab101 = Habitacion(101, "Estándar",    1200.0)  # Asigna un valor inicial o calculado a hab101
hab202 = Habitacion(202, "Junior Suite", 2500.0)  # Asigna un valor inicial o calculado a hab202
hab305 = Habitacion(305, "Suite Master", 4500.0)  # Asigna un valor inicial o calculado a hab305

# Crear clientes
ana  = Cliente("Ana Torres", "ana@email.com")  # Asigna un valor inicial o calculado a ana
luis = Cliente("Luis Ramos", "luis@email.com")  # Asigna un valor inicial o calculado a luis

# Crear y confirmar reservaciones
r1 = Reservacion(ana,  hab101, "2026-06-01", "2026-06-04", 3)  # Asigna un valor inicial o calculado a r1
r2 = Reservacion(ana,  hab305, "2026-07-15", "2026-07-20", 5)  # Asigna un valor inicial o calculado a r2
r3 = Reservacion(luis, hab202, "2026-06-10", "2026-06-12", 2)  # Asigna un valor inicial o calculado a r3

print(r1.confirmar())   # ✅ Hab 101 reservada
print(r2.confirmar())   # ✅ Hab 305 reservada
print(r3.confirmar())   # ✅ Hab 202 reservada

# ── VER TODAS LAS RESERVACIONES DE UN CLIENTE ────────────────────────────
ana.ver_reservaciones()  # Completa la llamada o expresión iniciada anteriormente
luis.ver_reservaciones()  # Completa la llamada o expresión iniciada anteriormente

# ── Acceso directo a la lista con for ────────────────────────────────────
print(f"\nAna tiene {len(ana.reservaciones)} reservación(es):")  # Muestra en consola el resultado de esta operación
for r in ana.reservaciones:  # Itera sobre cada r en ana.reservaciones
    print(f"  → Hab {r.habitacion.numero} — {r.fecha_entrada}")  # Muestra en consola el resultado de esta operación

# ── Intento de reservar habitación ya ocupada ─────────────────────────────
r4 = Reservacion(luis, hab101, "2026-06-05", "2026-06-07", 2)  # Asigna un valor inicial o calculado a r4
print("\n" + r4.confirmar())   # ❌ ya estaba ocupada