INTEGRANTE 1: Clases Abstractas y Polimorfismo
Código Ampliado:
python
from abc import ABC, abstractmethod
# CLASE ABSTRACTA BASE
class Persona(ABC):
"""
Clase abstracta que define la estructura común
para todas las personas en el sistema.
No se puede instanciar directamente.
"""
@abstractmethod
def mostrar_info(self):
"""Método obligatorio para todas las subclases"""
pass
# IMPLEMENTACIÓN CONCRETA
class Usuario(Persona):
def __init__(self, nombre, cedula, correo,
contrasena_encriptada, titulos="", experiencia=""):
"""
Constructor de Usuario con nuevos atributos extendidos
"""
[Link] = nombre
[Link] = cedula
[Link] = correo
self.contrasena_encriptada = contrasena_encriptada
[Link] = False # Estado inicial
[Link] = titulos
[Link] = experiencia
def mostrar_info(self):
"""
Implementación concreta del método abstracto
Muestra información específica del usuario
"""
return f"Usuario: {[Link]}, Títulos: {[Link]}, Experiencia: {[Link]}"
Explicación del Funcionamiento:
"Esta es la base de nuestro sistema. La clase Persona actúa como un contrato que dice:
'Cualquiera que sea una Persona en nuestro sistema DEBE poder mostrar su información'. Es
abstracta, así que no podemos crear un objeto 'Persona' directamente - es solo un molde."
"El @abstractmethod fuerza a todas las subclases a implementar mostrar_info(). Si alguien
crea una clase que hereda de Persona pero olvida este método, Python mostrará un error
inmediato. Esto previene bugs futuros."
"La clase Usuario implementa este contrato. Tiene atributos extendidos
como titulos y experiencia que hacen los perfiles más completos. El
método mostrar_info() devuelve información formateada específica para usuarios."
INTEGRANTE 2: Herencia y Especialización
Código Ampliado:
python
# HERENCIA - ESPECIALIZACIÓN
class UsuarioEstudiante(Usuario):
def __init__(self, nombre, cedula, correo, contrasena_encriptada,
universidad, titulos="", experiencia=""):
"""
Constructor que hereda de Usuario y añade atributo específico
"""
# Llama al constructor de la clase padre
super().__init__(nombre, cedula, correo,
contrasena_encriptada, titulos, experiencia)
[Link] = universidad # Atributo específico
def mostrar_info(self):
"""
Sobrescribe el método para incluir información de estudiante
"""
return (f"Estudiante: {[Link]}, "
f"Universidad: {[Link]}, "
f"Títulos: {[Link]}, "
f"Experiencia: {[Link]}")
# EMPRESA CON REQUERIMIENTOS
class Empresa(Persona):
def __init__(self, nombre_empresa, tipo_empresa,
correo_empresa, contrasena_encriptada,
cualidades_requeridas=""):
"""
Empresa con cualidades específicas que busca
"""
self.nombre_empresa = nombre_empresa
self.tipo_empresa = tipo_empresa
self.correo_empresa = correo_empresa
self.contrasena_encriptada = contrasena_encriptada
[Link] = [] # Lista de usuarios contratados
self.cualidades_requeridas = cualidades_requeridas
def mostrar_info(self):
"""
Implementación para empresas
"""
return f"Empresa: {self.nombre_empresa}, Busca: {self.cualidades_requeridas}"
Explicación del Funcionamiento:
"Usamos herencia para crear especializaciones. UsuarioEstudiante ES UN Usuario con algo
extra: la universidad. El super().__init__() es clave - reutiliza el código del padre, evitando
duplicación."
"El polimorfismo se ve claramente: mostrar_info() se comporta diferente según el tipo. Un
Usuario muestra una cosa, un Estudiante muestra otra, pero ambos responden al mismo
'mensaje'. En el dashboard, podemos llamar persona.mostrar_info() sin saber exactamente
qué tipo es."
"La clase Empresa también implementa Persona, mostrando cómo una misma interfaz
abstracta puede servir para entidades diferentes. Las empresas
tienen cualidades_requeridas que permiten un matching inteligente con usuarios."
INTEGRANTE 3: Interfaces Mejoradas
Código Ampliado:
python
class RegistroUsuario:
def __init__(self, master, app):
"""
Ventana de registro con campos extendidos
"""
[Link] = master
[Link] = app
[Link]("Registrar Usuario")
[Link]("350x500")
# Campo dinámico para tipo de usuario
[Link](master, text="Tipo de Usuario").pack(pady=5)
self.tipo_var = [Link](value="General")
tipo_combo = [Link](master, textvariable=self.tipo_var,
values=["General", "Estudiante"])
tipo_combo.pack()
# CAMPOS EXTENDIDOS - Perfiles enriquecidos
campos = ["Nombre", "Cédula", "Correo",
"Contraseña", "Títulos", "Experiencia"]
[Link] = {}
for campo in campos:
[Link](master, text=campo).pack(pady=5)
entry = [Link](master,
show="*" if campo == "Contraseña" else None,
width=30)
[Link]()
[Link][campo] = entry
# Campo dinámico que aparece solo para estudiantes
self.label_universidad = [Link](master, text="Universidad")
self.entry_universidad = [Link](master, width=30)
# Evento que muestra/oculta campos dinámicamente
self.tipo_var.trace("w", self.actualizar_campos)
[Link](master, text="Guardar",
command=[Link]).pack(pady=20)
def actualizar_campos(self, *args):
"""
Muestra/oculta campos según el tipo seleccionado
"""
if self.tipo_var.get() == "Estudiante":
self.label_universidad.pack(pady=5)
self.entry_universidad.pack()
else:
self.label_universidad.pack_forget()
self.entry_universidad.pack_forget()
Explicación del Funcionamiento:
"Las interfaces se han mejorado significativamente. En lugar de formularios básicos, ahora
capturamos información crucial como Títulos y Experiencia, creando perfiles completos que
permiten un matching realista."
"La magia está en actualizar_campos(). Cuando el usuario selecciona 'Estudiante',
automáticamente aparece el campo 'Universidad'. Esto se logra con trace() que 'escucha'
cambios en la variable. Es un formulario dinámico que se adapta al contexto."
"Cada campo tiene validación implícita. Los Entry widgets con show='*' ocultan contraseñas.
El método guardar() (no mostrado completo) verifica que ningún campo obligatorio esté
vacío antes de crear el objeto."
INTEGRANTE 4: Dashboard y Contratación
Código Ampliado:
python
class UserDashboard:
def __init__(self, master, app, user):
"""
Panel de usuario que muestra información completa
"""
[Link] = master
[Link] = app
[Link] = user
[Link]("Panel Usuario")
[Link]("400x350")
# POLIMORFISMO EN ACCIÓN
[Link](master, text=f"Bienvenido {[Link]}",
font=("Arial", 14, "bold")).pack(pady=10)
estado = " Contratado" if [Link] else " Disponible"
[Link](master, text=f"Estado: {estado}",
font=("Arial", 12)).pack(pady=5)
# Aquí se usa mostrar_info() - funciona para cualquier Persona
info_completa = user.mostrar_info()
[Link](master, text=info_completa,
wraplength=350, justify="left").pack(pady=10)
class EmpresaDashboard:
def ver_disponibles(self):
"""
Muestra tabla extendida con toda la información de usuarios
"""
ventana = [Link]([Link])
[Link]("Usuarios Disponibles")
[Link]("700x400")
# TABLA CON INFORMACIÓN COMPLETA
columnas = ("Nombre", "Correo", "Cédula",
"Títulos", "Experiencia", "Tipo")
tabla = [Link](ventana, columns=columnas,
show="headings", height=15)
# Configurar encabezados
for col in columnas:
[Link](col, text=col)
[Link](col, width=100)
# Llenar tabla con datos extendidos
for usuario in [Link]:
if not [Link]: # Solo disponibles
tipo = "Estudiante" if isinstance(usuario, UsuarioEstudiante) else "General"
[Link]("", "end", iid=[Link],
values=([Link], [Link],
[Link], [Link],
[Link], tipo))
[Link](fill="both", expand=True, padx=10, pady=10)
# BOTÓN DE CONTRATACIÓN CON LOGÍCA COMPLETA
def contratar_usuario():
seleccion = [Link]()
if not seleccion:
[Link]("Selección",
"Seleccione un usuario primero")
return
cedula_seleccionada = seleccion[0]
for usuario in [Link]:
if [Link] == cedula_seleccionada:
[Link] = True
[Link](usuario)
[Link].guardar_datos() # Persiste el cambio
[Link]("Éxito",
f"¡{[Link]} ha sido contratado!")
[Link]()
return
[Link](ventana, text=" Contratar Usuario",
command=contratar_usuario,
style="[Link]").pack(pady=10)
Explicación del Funcionamiento:
"Los dashboards ahora muestran información completa gracias al
polimorfismo. user.mostrar_info() funciona igual si el usuario es normal o estudiante - cada
uno muestra lo relevante para su tipo."
"La tabla de usuarios disponibles es mucho más informativa. Muestra no solo datos básicos,
sino también Títulos y Experiencia, permitiendo a las empresas tomar decisiones basadas en
cualificaciones reales."
"El sistema de contratación actualiza tres cosas simultáneamente: 1) Cambia el estado del
usuario a contratado=True, 2) Añade el usuario a la lista de empleados de la empresa, 3)
Guarda los cambios persistentemente con guardar_datos(). Esto asegura consistencia en
todo el sistema."
"El matching mejorado es bidireccional: empresas ven las cualificaciones de usuarios, y en
futuras mejoras, usuarios podrían ver los requerimientos específicos de empresas. Esto simula
un mercado laboral real donde ambas partes toman decisiones informadas."