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:
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
classReservation: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
classReservationSystem:def__init__(self):# Utilizamos defaultdict para gestionar las reservas self.reservations = defaultdict(list)defadd_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}")defcancel_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")returnprint("Reserva no encontrada")
2.2. Módulo customers.py
Este módulo gestionará la información de los clientes.
classCustomer:def__init__(self, customer_id, name, email): self.customer_id = customer_id
self.name = name
self.email = email
classCustomerManagement:def__init__(self): self.customers ={}defadd_customer(self, customer):"""Agrega un nuevo cliente al sistema.""" self.customers[customer.customer_id]= customer
print(f"Cliente {customer.name} agregado.")defget_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.
classRoom:def__init__(self, room_number, room_type, price): self.room_number = room_number
self.room_type = room_type
self.price = price
self.available =TrueclassRoomManagement:def__init__(self): self.rooms ={}defadd_room(self, room):"""Agrega una nueva habitación al sistema.""" self.rooms[room.room_number]= room
print(f"Habitación {room.room_number} agregada.")defcheck_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.")returnTrueprint(f"Habitación {room_number} no está disponible.")returnFalse
2.4. Módulo payments.py
Este módulo procesará los pagos utilizando asincronismo con asyncio.
import asyncio
import random
asyncdefprocess_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 pagoprint(f"Pago de ${amount} completado para {customer_name}")returnTrue
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
asyncdefmain():# 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 habitacionesif room_mgmt.check_availability(101): reservation = Reservation(1,"Alice",101, datetime.now(), datetime.now()) reservation_system.add_reservation(reservation)# Procesar pago asincrónicamenteawait 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ónicamenteawait 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.
No encontré la opción de certificarse por proyecto, pero dejo el link del repositorio del mio. Ahora tomaré el examen.
creo que quitaron la opción en todos los cursos pero no estoy seguro, lo escuché en un aconferencía.
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
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
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:
El repo esta privado
termine el curso, pero alquien me puede explicar para subrlo
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+=1returnReservation.totaldef __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}')returnTrueelse:print(f'La {reservation.room} ya ha sido reservada')returnFalsedef 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
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
asyncdefmain():# 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 habitacionesif 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ónicamenteawait process_payment(customer1.customer_name, room_mngmt.rooms[reservation_1.room_number]["room_price"])# Verificar disponibilidad de habitacionesif 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ónicamenteawait 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
classReservation: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"classReservationSystem:def__init__(self): self.reservations = defaultdict(dict)defadd_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}.")returnTruedefcancel_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
classRoom: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"classRoomManagement:def__init__(self): self.rooms = defaultdict(dict)defadd_room(self, room: Room): self.services = defaultdict(dict) self.services ={**room.room_services}ifnot 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ónprint(f"Habitación {room.room_number} creada exitosamente.")else:print("La habitación ya existe")returndefcheck_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")returnTrueprint(f"La habitación {room_number} no está disponible")returnFalse```customers.py```python
classCustomer: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
classCustomerManagement:def__init__(self): self.customers ={}defadd_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.")defget_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
asyncdefprocess_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}.")returnTrueif __name__ =="__main__": asyncio.run(process_payment("Alice",200))
Gracias por tu aporte
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
En el curso aparece la opción, certificarse por examen o por proyecto
Hola estoy por finalizar el curso, quiero validar el examen es solo teórico con los temas vistos en las clases? o es aplicable?
