Sistema de Gestión de Reservas en Python Avanzado

Implementación de un Sistema Completo

En esta última clase del curso, vamos a aplicar todos los conceptos aprendidos en las clases anteriores para desarrollar un sistema completo utilizando Python avanzado. El proyecto consistirá en la implementación de un sistema de gestión de reservas para un hotel. Este sistema gestionará:

Reservas: Creación y cancelación de reservas de habitaciones.
Clientes: Almacenamiento y gestión de la información de los clientes.
Habitaciones: Verificación de la disponibilidad de las habitaciones.
Pagos: Procesamiento de pagos de las reservas de forma asincrónica.

Objetivos:

Integrar los módulos y paquetes del sistema para que cada funcionalidad esté organizada de manera eficiente.
Aplicar la programación asincrónica (asyncio) para manejar pagos concurrentes sin bloquear el sistema.
Utilizar las mejores prácticas Pythonicas, como las recomendaciones de PEP 8, manejo de tipos y validaciones.
Construir un sistema modular y reutilizable mediante la creación de un paquete Python.

Requisitos:

Organizar el código en diferentes módulos y paquetes que gestionen las diferentes partes del sistema.
Aplicar programación concurrente y asincrónica para procesar múltiples reservas de manera eficiente.
Implementar validaciones básicas para asegurar que las reservas y los pagos sean gestionados correctamente.
El sistema debe ser capaz de agregar clientes, verificar la disponibilidad de habitaciones, gestionar reservas y procesar pagos de manera eficaz.

Este proyecto te ayudará a consolidar los conocimientos adquiridos durante el curso y será un ejemplo de cómo utilizar técnicas avanzadas en un entorno real para construir una aplicación completa y robusta en Python.

1. Estructura del Proyecto

Vamos a dividir nuestro sistema en diferentes módulos y paquetes para organizar el código de manera eficiente:

Paquetes del proyecto:

hotel_management/
    __init__.py
    reservations.py
    customers.py
    rooms.py
    payments.py

reservations.py: Maneja la creación y cancelación de reservas.
customers.py: Gestiona la información de los clientes.
rooms.py: Gestiona la disponibilidad y características de las habitaciones.
payments.py: Procesa los pagos de las reservas.

2. Implementación de Módulos

2.1. Módulo reservations.py

Este módulo gestionará la lógica relacionada con la creación y cancelación de reservas.

from collections import defaultdict
from datetime import datetime

class Reservation:
    def __init__(self, reservation_id, customer_name, room_number, check_in, check_out):
        self.reservation_id = reservation_id
        self.customer_name = customer_name
        self.room_number = room_number
        self.check_in = check_in
        self.check_out = check_out

class ReservationSystem:
    def __init__(self):
        # Utilizamos defaultdict para gestionar las reservas
        self.reservations = defaultdict(list)

    def add_reservation(self, reservation):
        """Agrega una nueva reserva al sistema."""
        self.reservations[reservation.room_number].append(reservation)
        print(f"Reserva creada para {reservation.customer_name} en la habitación {reservation.room_number}")

    def cancel_reservation(self, reservation_id):
        """Cancela una reserva existente por ID."""
        for room, reservations in self.reservations.items():
            for r in reservations:
                if r.reservation_id == reservation_id:
                    reservations.remove(r)
                    print(f"Reserva {reservation_id} cancelada")
                    return
        print("Reserva no encontrada")

2.2. Módulo customers.py

Este módulo gestionará la información de los clientes.

class Customer:
    def __init__(self, customer_id, name, email):
        self.customer_id = customer_id
        self.name = name
        self.email = email

class CustomerManagement:
    def __init__(self):
        self.customers = {}

    def add_customer(self, customer):
        """Agrega un nuevo cliente al sistema."""
        self.customers[customer.customer_id] = customer
        print(f"Cliente {customer.name} agregado.")

    def get_customer(self, customer_id):
        """Obtiene la información de un cliente por ID."""
        return self.customers.get(customer_id, "Cliente no encontrado.")

2.3. Módulo rooms.py

Este módulo gestionará las habitaciones disponibles en el hotel.

class Room:
    def __init__(self, room_number, room_type, price):
        self.room_number = room_number
        self.room_type = room_type
        self.price = price
        self.available = True

class RoomManagement:
    def __init__(self):
        self.rooms = {}

    def add_room(self, room):
        """Agrega una nueva habitación al sistema."""
        self.rooms[room.room_number] = room
        print(f"Habitación {room.room_number} agregada.")

    def check_availability(self, room_number):
        """Verifica si una habitación está disponible."""
        room = self.rooms.get(room_number)
        if room and room.available:
            print(f"Habitación {room_number} está disponible.")
            return True
        print(f"Habitación {room_number} no está disponible.")
        return False

2.4. Módulo payments.py

Este módulo procesará los pagos utilizando asincronismo con asyncio.

import asyncio
import random

async def process_payment(customer_name, amount):
    """Simula el procesamiento de un pago."""
    print(f"Procesando pago de {customer_name} por ${amount}...")
    await asyncio.sleep(random.randint(1, 3))  # Simula una operación de pago
    print(f"Pago de ${amount} completado para {customer_name}")
    return True

3. Implementación del Sistema Completo

En el archivo main.py, vamos a integrar los módulos y utilizar programación concurrente y asincrónica para procesar varias reservas y pagos al mismo tiempo.

import asyncio
from hotel_management.reservations import Reservation, ReservationSystem
from hotel_management.customers import Customer, CustomerManagement
from hotel_management.rooms import Room, RoomManagement
from hotel_management.payments import process_payment
from hotel_management.datetime import datetime

async def main():
    # Inicializar sistemas
    reservation_system = ReservationSystem()
    customer_mgmt = CustomerManagement()
    room_mgmt = RoomManagement()

    # Crear habitaciones
    room_mgmt.add_room(Room(101, "Single", 100))
    room_mgmt.add_room(Room(102, "Double", 150))

    # Agregar clientes
    customer1 = Customer(1, "Alice", "alice@example.com")
    customer_mgmt.add_customer(customer1)

    customer2 = Customer(2, "Bob", "bob@example.com")
    customer_mgmt.add_customer(customer2)

    # Verificar disponibilidad de habitaciones
    if room_mgmt.check_availability(101):
        reservation = Reservation(1, "Alice", 101, datetime.now(), datetime.now())
        reservation_system.add_reservation(reservation)

        # Procesar pago asincrónicamente
        await process_payment("Alice", 100)

    if room_mgmt.check_availability(102):
        reservation = Reservation(2, "Bob", 102, datetime.now(), datetime.now())
        reservation_system.add_reservation(reservation)

        # Procesar pago asincrónicamente
        await process_payment("Bob", 150)

if __name__ == "__main__":
    asyncio.run(main())

4. Explicación del Proyecto

En este proyecto, aplicamos los conceptos de las clases anteriores:

Módulos y paquetes: Creamos un sistema modular donde cada parte (reservas, clientes, habitaciones, pagos) está bien organizada en su propio módulo.
Validaciones: A través de la lógica implementada en la gestión de habitaciones y reservas.
Asincronismo (asyncio): Usamos asyncio para procesar pagos de manera concurrente sin bloquear el sistema.
Decoradores y métodos estáticos: Aunque no se usan directamente aquí, podrían aplicarse para funcionalidades específicas como verificaciones adicionales o cálculo de descuentos.

5. Conclusión

Este proyecto final integra las diferentes áreas cubiertas en el curso, demostrando cómo las técnicas avanzadas de Python pueden combinarse para construir un sistema robusto y eficiente.

Alexis Dorado Muñoz

student•

Gracias por el curso

Juan Acevedo

student•

Que gran curso nos dio la profe Carli , felicidades a los que llegaron hasta acá y hayan podido entender. Respecto al proyecto quise hacer el mío propio , puede tener mejoras asi que si alguien quiere revisarlo y hacer feedback , bienvenido sea NUNCA PARES DE APRENDER! 💚

Link GitHub Repo:

Pedro Jose Soto Ayala

student•

El repo esta privado

Damian Araya

student•

No encontré la opción de certificarse por proyecto, pero dejo el link del repositorio del mio. Ahora tomaré el examen.

Juan David Jiménez López

student•

creo que quitaron la opción en todos los cursos pero no estoy seguro, lo escuché en un aconferencía.

Mireya Lara

student•

Curso terminado, pero sin duda, no presentaré el examen en estos momentos. Siento que no sé nada. Haré primero el proyecto final y cuando consiga el resultado, tal vez en ese momento ya crea que tengo probabildiades de obtener el certificado. Me siento como cuando estudio inglés, absorbo un montón de datos sobre gramática, pero cuando intento tener una conversación el cerebro se me apaga jajajaja

Agustín Alberto Leiva

student•

En mi caso en cada clase cuando se presentaba un nuevo tema, le pedía a alguna IA que me genere actividades que sean escalables sobre ese tema, luego yo las resolvía en código, así implementaba lo aprendido y lo reforzaba. Esa estrategia aplica en muchos ámbitos académicos, como programación o inglés. agustin-arg/Curso-Python

Edwin Daniel Méndez Amaya

student•

Les comparto otra opción para el módulo reservations. Es bien recibida cualquier obervación.from collections import defaultdictfrom datetime import datefrom .customers import Customerfrom .rooms import Room

class Reservation: total = 0 def __init__(self, customer: Customer, room: Room, date: date) -> None: self.customer = customer self.room = room self.date = date self.id = Reservation.get_reservation_id() def get_reservation_id(): Reservation.total += 1 return Reservation.total def __str__(self) -> str: # Devuelve una representación amigable para el usuario return f"Descripción de reserva: Cliente: {self.customer.name}, habitación: {self.room.number} " class ReservationSystem: def __init__(self) -> None: self.reservations = defaultdict(list) def add_reservation(self, reservation: Reservation) -> bool: """Agrega una nueva reserva al sistema.""" if reservation.room.availability == True: key = reservation.id reservation.room.availability = False self.reservations[key] = reservation print(f'Habitación: {reservation.room.number} reservada en la reserva #{key}') return True else: print(f'La {reservation.room} ya ha sido reservada') return False

def cancel_reservation(self, reservation_id: int) -> None: """Cancela una reserva existente por ID.""" if reservation_id in self.reservations.keys(): reserv = self.reservations[reservation_id] reserv.room.availability = True ```python from collections import defaultdict from datetime import date from .customers import Customer from .rooms import Room

class Reservation: total = 0

def __init__(self, customer: Customer, room: Room, date: date) -> None:
    self.customer = customer
    self.room = room
    self.date = date
    self.id = Reservation.get_reservation_id()

def get_reservation_id():
    Reservation.total += 1
    return Reservation.total

def __str__(self) -> str:
    # Devuelve una representación amigable para el usuario
    return f"Descripción de reserva: Cliente: {self.customer.name}, habitación: {self.room.number} "

class ReservationSystem: def init(self) -> None: self.reservations = defaultdict(list)

def add_reservation(self, reservation: Reservation) -> bool:
    """Agrega una nueva reserva al sistema."""
    if reservation.room.availability == True:
        key = reservation.id
        reservation.room.availability = False
        self.reservations[key] = reservation
        print(f'Habitación: {reservation.room.number} reservada en la reserva #{key}')
        return True
    else:
        print(f'La {reservation.room} ya ha sido reservada')
        return False


def cancel_reservation(self, reservation_id: int) -> None:
    """Cancela una reserva existente por ID."""
    if reservation_id in self.reservations.keys():
        reserv = self.reservations[reservation_id]
        reserv.room.availability = True

Yetzojhanan Varela Sierra

student•

jejeje, me salió un poco distinto a mi, pero acá comparto:

main.py

import asyncio
from hotel_management.reservations import Reservation, ReservationSystem
from hotel_management.customers import Customer, CustomerManagement
from hotel_management.rooms import Room, RoomManagement
from hotel_management.payments import process_payment
from datetime import datetime

async def main():
    # Inicializar sistemas
    customer_mgmt = CustomerManagement()
    room_mngmt = RoomManagement()
    reservation_mngmt = ReservationSystem()

    # Crear habitaciones
    room1 = Room(101, "Single", 100, {"TV": True, "WiFi": True, "AirConditioning": True})
    room2 = Room(102, "Double", 200, {"TV": True, "WiFi": True, "AirConditioning": True})
    room_mngmt.add_room(room1)
    room_mngmt.add_room(room2)

    # Agregar clientes
    customer1 = Customer(1, "Alice", "alice@example.com")
    customer2 = Customer(2, "Bob", "bob@example.com")
    customer_mgmt.add_customer(customer1)
    customer_mgmt.add_customer(customer2)

    # Verificar disponibilidad de habitaciones

    # Crear reservas
    reservation_1 = Reservation("Alice", 1, datetime.now().strftime("%d-%m-%Y"), datetime.now().strftime("%d-%m-%Y"), 4, 101)
    reservation_2 = Reservation("Bob", 2, datetime.now().strftime("%d-%m-%Y"), datetime.now().strftime("%d-%m-%Y"), 2, 102)

    # Verificar disponibilidad de habitaciones
    if room_mngmt.check_availability(reservation_2.room_number):
        reservation_mngmt.add_reservation(reservation_1)
        room_mngmt.rooms[reservation_1.room_number]["room_status"] = "Deactivated"

        # Procesar pago asincrónicamente
        await process_payment(customer1.customer_name, room_mngmt.rooms[reservation_1.room_number]["room_price"])

    # Verificar disponibilidad de habitaciones
    if room_mngmt.check_availability(reservation_2.room_number):
        reservation_mngmt.add_reservation(reservation_2)
        room_mngmt.rooms[reservation_2.room_number]["room_status"] = "Deactivated"

        # Procesar pago asincrónicamente
        await process_payment(customer2.customer_name, room_mngmt.rooms[reservation_2.room_number]["room_price"])

    # Cancelar reservas
    reservation_mngmt.cancel_reservation(1)
    #reservation_mngmt.cancel_reservation(2)

if __name__ == "__main__":
    asyncio.run(main())
```reservations.py```python
from collections import defaultdict
from datetime import datetime

class Reservation:
    def __init__(self, customer_name: str, reservation_id: int, check_in_date: str, check_out_date: str, number_of_guests: int, room_number: int):
        self.customer_name = customer_name
        self.reservation_id = reservation_id
        self.check_in_date = datetime.strptime(check_in_date, "%d-%m-%Y") #usamos strptime para convertir la fecha en un objeto datetime con formato especificado (dd-mm-yyyy)
        self.check_out_date = datetime.strptime(check_out_date, "%d-%m-%Y")
        self.number_of_guests = number_of_guests
        self.room_number = room_number
        self.status = "active" #puede ser "active", "canceled" o "completed"

class ReservationSystem:
    def __init__(self):
        self.reservations = defaultdict(dict)
    
    def add_reservation(self, reservation: Reservation):
        if reservation.reservation_id in self.reservations:
            print("La reserva ya existe")
            return
        self.reservations[reservation.reservation_id] = {**reservation.__dict__}
        print(f"Reserva {reservation.reservation_id} creada exitosamente para {reservation.customer_name}.")
        return True

    def cancel_reservation(self, reservation_id):
        if reservation_id in self.reservations and self.reservations[reservation_id]["status"] == "active":
            self.reservations[reservation_id]["status"] = "canceled"
            print(f"Reserva {reservation_id} cancelada exitosamente")
        else:
            print(f"Reserva {reservation_id} no encontrada.")
```rooms.py```python
from collections import defaultdict

class Room:
    def __init__(self, room_number: int, room_type: str, room_price: float, room_services: dict):
        self.room_number = room_number
        self.room_type = room_type
        self.room_price = room_price
        self.room_services = room_services
        self.room_status = "Active" #puede ser "Active", "Deactivated"

class RoomManagement:
    def __init__(self):
        self.rooms = defaultdict(dict)

    def add_room(self, room: Room):
        self.services = defaultdict(dict)
        self.services = {**room.room_services}
        if not room.room_number in self.rooms:
            self.rooms[room.room_number] = {**room.__dict__} #usamos ** para desempaquetar el objeto room en un diccionario con los atributos de la clase Room
            self.rooms[room.room_number]["room_services"] = self.services #añadimos el diccionario de servicios a la habitación
            print(f"Habitación {room.room_number} creada exitosamente.")
        else:
            print("La habitación ya existe")
            return

    def check_availability(self, room_number):
        if room_number in self.rooms and self.rooms[room_number]["room_status"] == "Active":
            print(f"La habitación {room_number} está disponible")
            return True
        print(f"La habitación {room_number} no está disponible")
        return False
```customers.py```python
class Customer:
    def __init__(self, customer_id: int, customer_name: str, customer_email: str):
        self.customer_id = customer_id
        self.customer_name = customer_name
        self.customer_email = customer_email

class CustomerManagement:
    def __init__(self):
        self.customers = {}

    def add_customer(self, customer: Customer):
        self.customers[customer.customer_id] = {
            "customer_name": customer.customer_name,
            "customer_email": customer.customer_email,
        }
        print(f"Cliente {customer.customer_name} creado con éxito.")

    def get_customer(self, customer_id: int):
       customer = self.customers.get(customer_id)
       if customer:
           print(f"Nombre: {customer['customer_name']} - Email: {customer['customer_email']}.")
       else:
           print(f"Cliente con el ID {customer_id} no encontrado.")
```payments.py```python
import asyncio
import random

async def process_payment(customer_name, amount):
    print(f"Procesando pago de {customer_name} por un valor de: ${amount}.")
    await asyncio.sleep(random.randint(3,6))
    print(f"Pago procesado de {customer_name}  por un valor de: ${amount}.")
    return True

if __name__ == "__main__":
    asyncio.run(process_payment("Alice", 200))

Alexis Dorado Muñoz

student•

Gracias por tu aporte

German Raul Pech May

student•

hola, estoy por terminar el curso pero veo que en las clases finales no explican donde subir el proyecto para que lo revisen y sea aprobado

Alexis Dorado Muñoz

student•

En el curso aparece la opción, certificarse por examen o por proyecto

angie.catolico

student•

Hola estoy por finalizar el curso, quiero validar el examen es solo teórico con los temas vistos en las clases? o es aplicable?

from collections import defaultdict
from datetime import datetime

class Reservation:
    def __init__(self, reservation_id, customer_name, room_number, check_in, check_out):
        self.reservation_id = reservation_id
        self.customer_name = customer_name
        self.room_number = room_number
        self.check_in = check_in
        self.check_out = check_out

class ReservationSystem:
    def __init__(self):
        # Utilizamos defaultdict para gestionar las reservas
        self.reservations = defaultdict(list)

    def add_reservation(self, reservation):
        """Agrega una nueva reserva al sistema."""
        self.reservations[reservation.room_number].append(reservation)
        print(f"Reserva creada para {reservation.customer_name} en la habitación {reservation.room_number}")

    def cancel_reservation(self, reservation_id):
        """Cancela una reserva existente por ID."""
        for room, reservations in self.reservations.items():
            for r in reservations:
                if r.reservation_id == reservation_id:
                    reservations.remove(r)
                    print(f"Reserva {reservation_id} cancelada")
                    return
        print("Reserva no encontrada")

class Customer:
    def __init__(self, customer_id, name, email):
        self.customer_id = customer_id
        self.name = name
        self.email = email

class CustomerManagement:
    def __init__(self):
        self.customers = {}

    def add_customer(self, customer):
        """Agrega un nuevo cliente al sistema."""
        self.customers[customer.customer_id] = customer
        print(f"Cliente {customer.name} agregado.")

    def get_customer(self, customer_id):
        """Obtiene la información de un cliente por ID."""
        return self.customers.get(customer_id, "Cliente no encontrado.")

class Room:
    def __init__(self, room_number, room_type, price):
        self.room_number = room_number
        self.room_type = room_type
        self.price = price
        self.available = True

class RoomManagement:
    def __init__(self):
        self.rooms = {}

    def add_room(self, room):
        """Agrega una nueva habitación al sistema."""
        self.rooms[room.room_number] = room
        print(f"Habitación {room.room_number} agregada.")

    def check_availability(self, room_number):
        """Verifica si una habitación está disponible."""
        room = self.rooms.get(room_number)
        if room and room.available:
            print(f"Habitación {room_number} está disponible.")
            return True
        print(f"Habitación {room_number} no está disponible.")
        return False

import asyncio
import random

async def process_payment(customer_name, amount):
    """Simula el procesamiento de un pago."""
    print(f"Procesando pago de {customer_name} por ${amount}...")
    await asyncio.sleep(random.randint(1, 3))  # Simula una operación de pago
    print(f"Pago de ${amount} completado para {customer_name}")
    return True

import asyncio
from hotel_management.reservations import Reservation, ReservationSystem
from hotel_management.customers import Customer, CustomerManagement
from hotel_management.rooms import Room, RoomManagement
from hotel_management.payments import process_payment
from hotel_management.datetime import datetime

async def main():
    # Inicializar sistemas
    reservation_system = ReservationSystem()
    customer_mgmt = CustomerManagement()
    room_mgmt = RoomManagement()

    # Crear habitaciones
    room_mgmt.add_room(Room(101, "Single", 100))
    room_mgmt.add_room(Room(102, "Double", 150))

    # Agregar clientes
    customer1 = Customer(1, "Alice", "alice@example.com")
    customer_mgmt.add_customer(customer1)

    customer2 = Customer(2, "Bob", "bob@example.com")
    customer_mgmt.add_customer(customer2)

    # Verificar disponibilidad de habitaciones
    if room_mgmt.check_availability(101):
        reservation = Reservation(1, "Alice", 101, datetime.now(), datetime.now())
        reservation_system.add_reservation(reservation)

        # Procesar pago asincrónicamente
        await process_payment("Alice", 100)

    if room_mgmt.check_availability(102):
        reservation = Reservation(2, "Bob", 102, datetime.now(), datetime.now())
        reservation_system.add_reservation(reservation)

        # Procesar pago asincrónicamente
        await process_payment("Bob", 150)

if __name__ == "__main__":
    asyncio.run(main())

def __init__(self, customer: Customer, room: Room, date: date) -> None:
    self.customer = customer
    self.room = room
    self.date = date
    self.id = Reservation.get_reservation_id()

def get_reservation_id():
    Reservation.total += 1
    return Reservation.total

def __str__(self) -> str:
    # Devuelve una representación amigable para el usuario
    return f"Descripción de reserva: Cliente: {self.customer.name}, habitación: {self.room.number} "
    

def add_reservation(self, reservation: Reservation) -> bool:
    """Agrega una nueva reserva al sistema."""
    if reservation.room.availability == True:
        key = reservation.id
        reservation.room.availability = False
        self.reservations[key] = reservation
        print(f'Habitación: {reservation.room.number} reservada en la reserva #{key}')
        return True
    else:
        print(f'La {reservation.room} ya ha sido reservada')
        return False


def cancel_reservation(self, reservation_id: int) -> None:
    """Cancela una reserva existente por ID."""
    if reservation_id in self.reservations.keys():
        reserv = self.reservations[reservation_id]
        reserv.room.availability = True
    

import asyncio
from hotel_management.reservations import Reservation, ReservationSystem
from hotel_management.customers import Customer, CustomerManagement
from hotel_management.rooms import Room, RoomManagement
from hotel_management.payments import process_payment
from datetime import datetime

async def main():
    # Inicializar sistemas
    customer_mgmt = CustomerManagement()
    room_mngmt = RoomManagement()
    reservation_mngmt = ReservationSystem()

    # Crear habitaciones
    room1 = Room(101, "Single", 100, {"TV": True, "WiFi": True, "AirConditioning": True})
    room2 = Room(102, "Double", 200, {"TV": True, "WiFi": True, "AirConditioning": True})
    room_mngmt.add_room(room1)
    room_mngmt.add_room(room2)

    # Agregar clientes
    customer1 = Customer(1, "Alice", "alice@example.com")
    customer2 = Customer(2, "Bob", "bob@example.com")
    customer_mgmt.add_customer(customer1)
    customer_mgmt.add_customer(customer2)

    # Verificar disponibilidad de habitaciones

    # Crear reservas
    reservation_1 = Reservation("Alice", 1, datetime.now().strftime("%d-%m-%Y"), datetime.now().strftime("%d-%m-%Y"), 4, 101)
    reservation_2 = Reservation("Bob", 2, datetime.now().strftime("%d-%m-%Y"), datetime.now().strftime("%d-%m-%Y"), 2, 102)

    # Verificar disponibilidad de habitaciones
    if room_mngmt.check_availability(reservation_2.room_number):
        reservation_mngmt.add_reservation(reservation_1)
        room_mngmt.rooms[reservation_1.room_number]["room_status"] = "Deactivated"

        # Procesar pago asincrónicamente
        await process_payment(customer1.customer_name, room_mngmt.rooms[reservation_1.room_number]["room_price"])

    # Verificar disponibilidad de habitaciones
    if room_mngmt.check_availability(reservation_2.room_number):
        reservation_mngmt.add_reservation(reservation_2)
        room_mngmt.rooms[reservation_2.room_number]["room_status"] = "Deactivated"

        # Procesar pago asincrónicamente
        await process_payment(customer2.customer_name, room_mngmt.rooms[reservation_2.room_number]["room_price"])

    # Cancelar reservas
    reservation_mngmt.cancel_reservation(1)
    #reservation_mngmt.cancel_reservation(2)

if __name__ == "__main__":
    asyncio.run(main())
```reservations.py```python
from collections import defaultdict
from datetime import datetime

class Reservation:
    def __init__(self, customer_name: str, reservation_id: int, check_in_date: str, check_out_date: str, number_of_guests: int, room_number: int):
        self.customer_name = customer_name
        self.reservation_id = reservation_id
        self.check_in_date = datetime.strptime(check_in_date, "%d-%m-%Y") #usamos strptime para convertir la fecha en un objeto datetime con formato especificado (dd-mm-yyyy)
        self.check_out_date = datetime.strptime(check_out_date, "%d-%m-%Y")
        self.number_of_guests = number_of_guests
        self.room_number = room_number
        self.status = "active" #puede ser "active", "canceled" o "completed"

class ReservationSystem:
    def __init__(self):
        self.reservations = defaultdict(dict)
    
    def add_reservation(self, reservation: Reservation):
        if reservation.reservation_id in self.reservations:
            print("La reserva ya existe")
            return
        self.reservations[reservation.reservation_id] = {**reservation.__dict__}
        print(f"Reserva {reservation.reservation_id} creada exitosamente para {reservation.customer_name}.")
        return True

    def cancel_reservation(self, reservation_id):
        if reservation_id in self.reservations and self.reservations[reservation_id]["status"] == "active":
            self.reservations[reservation_id]["status"] = "canceled"
            print(f"Reserva {reservation_id} cancelada exitosamente")
        else:
            print(f"Reserva {reservation_id} no encontrada.")
```rooms.py```python
from collections import defaultdict

class Room:
    def __init__(self, room_number: int, room_type: str, room_price: float, room_services: dict):
        self.room_number = room_number
        self.room_type = room_type
        self.room_price = room_price
        self.room_services = room_services
        self.room_status = "Active" #puede ser "Active", "Deactivated"

class RoomManagement:
    def __init__(self):
        self.rooms = defaultdict(dict)

    def add_room(self, room: Room):
        self.services = defaultdict(dict)
        self.services = {**room.room_services}
        if not room.room_number in self.rooms:
            self.rooms[room.room_number] = {**room.__dict__} #usamos ** para desempaquetar el objeto room en un diccionario con los atributos de la clase Room
            self.rooms[room.room_number]["room_services"] = self.services #añadimos el diccionario de servicios a la habitación
            print(f"Habitación {room.room_number} creada exitosamente.")
        else:
            print("La habitación ya existe")
            return

    def check_availability(self, room_number):
        if room_number in self.rooms and self.rooms[room_number]["room_status"] == "Active":
            print(f"La habitación {room_number} está disponible")
            return True
        print(f"La habitación {room_number} no está disponible")
        return False
```customers.py```python
class Customer:
    def __init__(self, customer_id: int, customer_name: str, customer_email: str):
        self.customer_id = customer_id
        self.customer_name = customer_name
        self.customer_email = customer_email

class CustomerManagement:
    def __init__(self):
        self.customers = {}

    def add_customer(self, customer: Customer):
        self.customers[customer.customer_id] = {
            "customer_name": customer.customer_name,
            "customer_email": customer.customer_email,
        }
        print(f"Cliente {customer.customer_name} creado con éxito.")

    def get_customer(self, customer_id: int):
       customer = self.customers.get(customer_id)
       if customer:
           print(f"Nombre: {customer['customer_name']} - Email: {customer['customer_email']}.")
       else:
           print(f"Cliente con el ID {customer_id} no encontrado.")
```payments.py```python
import asyncio
import random

async def process_payment(customer_name, amount):
    print(f"Procesando pago de {customer_name} por un valor de: ${amount}.")
    await asyncio.sleep(random.randint(3,6))
    print(f"Pago procesado de {customer_name}  por un valor de: ${amount}.")
    return True

if __name__ == "__main__":
    asyncio.run(process_payment("Alice", 200))

Sistema de Gestión de Reservas en Python Avanzado

Fundamentos de Programación y Python

Fundamentos de Programación con Python para Principiantes

Instalación y Uso Básico de Python en Windows y Mac

Semántica y Sintaxis en Programación Python

Práctica: Te doy la bienvenida a los ejercicios interactivos

Manejo de Cadenas y Operaciones Básicas en Python

Tipos de Datos en Python: Enteros, Flotantes y Booleanos

Dominio de la función `print` en Python: usos y formatos avanzados

Operaciones matemáticas avanzadas en Python: módulo, potencia y más

Entrada de información y manejo de tipos de datos en Python

Colección y Procesamiento de Datos en Python

Manipulación de Listas en Python: Creación, Indexación y Métodos Básicos

Copiar listas en Python sin compartir memoria con slicing

Manejo de Matrices y Tuplas en Python

Matrices en Juegos y Imágenes con Python

Diccionarios en Python: Uso y Manipulación de Datos

Control de Flujo en Python

Estructuras Condicionales en Programación: Uso de If, Else y Elif

Iteración y control de flujo con bucles en Python

Iteradores y Generadores en Python: Uso Eficiente de Memoria

Listas por comprensión en Python: creación y optimización de listas

Funciones y Manejo de Excepciones en Python

Funciones y Parámetros en Python: Crea una Calculadora Básica

Funciones Lambda en Python: Uso y Aplicaciones Prácticas

Recursividad en Python: Factoriales y Serie de Fibonacci

Manejo de Excepciones y Errores en Python

Programación Orientada a Objetos en Python

Programación Orientada a Objetos en Python: Clases y Métodos Básicos

Gestión de Biblioteca con Programación Orientada a Objetos

Herencia y Polimorfismo en Programación Orientada a Objetos

Programación Orientada a Objetos: Implementación de Clases y Herencia

Polimorfismo en Programación Orientada a Objetos

Herencia y Uso de la Función super() en Python

Programación Orientada a Objetos: Atributos, Métodos y `super()` en Python

Lectura y escritura de archivos

Manipulación de Archivos TXT y CSV en Python

Manipulación de archivos CSV con Python: lectura y escritura

Manejo de Archivos JSON en Python para Aplicaciones Web y APIs

Biblioteca estándar de Python

Uso Eficiente de la Biblioteca Estándar de Python

Uso de las librerías OS, Math y Random en Python

Análisis de Datos de Ventas con Python y Statistics

Desarrollo del juego Batalla Naval en Python

Conceptos avanzados de Python

Programación Avanzada en Python: POO, Excepciones y Proyectos

Escritura de Código Pytónico y Buenas Prácticas en Python

Comentarios y Docstrings: Buenas Prácticas en Programación

Tiempo de vida y alcance de variables en Python

Anotaciones de Tipo en Python para Código Más Legible

Validación de Tipos y Manejo de Excepciones en Python

Estructuras de Datos Avanzadas en Python: Collection y Enumeraciones

Decoradores

Decoradores en Python: Extiende Funcionalidades de Funciones

Uso de Decoradores Anidados y con Parámetros en Python

Decoradores en Programación Orientada a Objetos en Python

Métodos y estructura de clases en Python

Uso de Métodos Mágicos en Python

Sobrecarga de Operadores en Python: Personaliza Comportamiento de Clases

Ejecutar scripts Python con `if __name__ == '__main__'`

Metaprogramación en Python: Métodos `__new__` y `__init__`

Uso de *args y **kwargs en funciones de Python

Métodos y Atributos Privados y Protegidos en Python

Uso de Property en Python: Getter, Setter y Eliminación de Atributos

Métodos estáticos y de clase en Python

Programación concurrente y asíncrona

Concurrencia y Paralelismo en Python: Técnicas y Librerías Básicas

Concurrencia y Paralelismo en Python: `threading` y `multiprocessing`

Asincronismo en Python con AsyncIO y Corrutinas

Sincronía y Concurrencia en Python: Teoría y Práctica

Creación de módulos y paquetes

Módulos y Paquetes en Python: Reutilización y Organización de Código

Uso de Paquetes y Subpaquetes en Python con Visual Studio Code

Publicación de Paquetes Python en PyPI

Proyecto final

Sistema de Gestión de Reservas en Python Avanzado

Sistema de Gestión de Reservas en Python Avanzado

Ejecutar scripts Python con `if name == 'main'`

Metaprogramación en Python: Métodos `new` y `init`