Universidad Autónoma de Baja California
Práctica 8 - Herencia.
Facultad:
Facultad de Ingeniería de Mexicali.
Programa educativo:
Licenciatura en Sistemas Computacionales.
Grupo:
141-1.
Asignatura:
Lenguaje de Programación Interpretado.
Nombre del docente:
Oscar Joel Lopez Plata.
Objetivo:
Diseñar un sistema orientado a objetos en Python que represente la estructura de
una empresa usando herencia y sobreescritura de métodos.
Introducción:
La herencia en Python es una forma de organizar el código que permite crear
nuevas clases a partir de otras ya existentes, aprovechando sus características y
comportamientos. Básicamente, permite que una clase herede atributos y métodos
de otra, facilitando la reutilización de código sin tener que escribir todo desde cero.
Esto hace que el programa sea más entendible, más modular y mucho más práctico
al momento de trabajar con sistemas más complejos.
Además, la herencia permite extender o modificar el comportamiento de una clase
base, adaptándola a nuevas necesidades sin afectar su estructura original. Gracias
a esto, es posible construir jerarquías de clases que representen relaciones más
claras entre los distintos elementos del programa. En conjunto, la herencia ayuda a
que el código sea más organizado, reutilizable y sencillo de mantener.
Desarrollo:
# --------- Clases ---------#
class Empleado:
def __init__(self, nombre, edad, ahorros, salario, id):
[Link] = nombre;
[Link] = edad;
[Link] = ahorros;
[Link] = salario;
[Link] = id;
def trabajar(self):
print(f"{[Link]} esta trabajando...")
def registrar_entrada(self):
print(f"Asistencia de {[Link]} registrada.")
def descasar(self, minutos):
print(f"{[Link]} esta tomandose {minutos} minutos de descanso.")
def comer(self, comida):
print(f"{[Link]} acaba de tomar su descanso y esta comiendo
{comida}.")
def mostrar_info(self):
print(f"{[Link]}:\n\t*Edad: {[Link]}\n\t*Ahorros:
{[Link]}\n\t*Salario: {[Link]}\n\t*ID: {[Link]}")
def cobrar_salario(self):
[Link] += [Link]
print(f"¡{[Link]} acaba de cobrar su salario de {[Link]} y
ahora sus ahorros son de {[Link]}!")
class Desarrollador(Empleado):
def __init__(self, nombre, edad, ahorros, salario, id, lenguaje):
Empleado.__init__(self, nombre, edad, ahorros, salario, id)
[Link] = lenguaje
def programar(self):
print(f"{[Link]} esta programando en {[Link]}...")
def trabajar(self, minutos, comida):
[Link]()
[Link](minutos)
[Link](comida)
class Gerente(Empleado):
def __init__(self, nombre, edad, ahorros, salario, id, equipo):
Empleado.__init__(self, nombre, edad, ahorros, salario, id)
[Link] = equipo
def dirigir_reunion(self):
print(f"{[Link]} dirije una reunion con su equipo...")
def evaluar_desempeno(self):
print(f"{[Link]} evalua el desempeno de su equipo...")
def trabajar(self, minutos, comida):
self.dirigir_reunion()
self.evaluar_desempeno()
[Link](minutos)
[Link](comida)
class AdministradorSistemas(Empleado):
def __init__(self, nombre, edad, ahorros, salario, id, servidores):
Empleado.__init__(self, nombre, edad, ahorros, salario, id)
[Link] = servidores
def monitorear_servidores(self):
print(f"{[Link]} monitorea los {[Link]} servidores...")
def detectar_fallos(self):
print(f"{[Link]} busca fallos en los sistemas...")
def reiniciar_servidores(self):
print(f"{[Link]} reinicia los servidores...")
def trabajar(self, minutos, comida):
self.monitorear_servidores()
self.detectar_fallos()
self.reiniciar_servidores()
[Link](minutos)
[Link](comida)
class DevOps(Desarrollador, AdministradorSistemas):
def __init__(self, nombre, edad, ahorros, salario, id, lenguaje,
servidores, herramienta_ci_id):
Desarrollador.__init__(self, nombre, edad, ahorros, salario, id,
lenguaje)
AdministradorSistemas.__init__(self, nombre, edad, ahorros, salario,
id, servidores)
self.herramienta_ci_id = herramienta_ci_id
def desplegar(self):
print(f"{[Link]} está desplegando...")
def probar_sistema(self):
print(f"{[Link]} prueba el sistema...")
def escribir_reporte(self):
print(f"{[Link]} esta realizando el reporte...")
def trabajar(self, minutos, comida):
self.probar_sistema()
[Link]()
self.escribir_reporte()
[Link](minutos)
[Link](comida)
# --------- Flujo Principal ---------#
dev = Desarrollador("Nacho", 49, 70000, 4500, 1155441, "Python")
gerente = Gerente("Gerardo", 56, 300000, 10000, 100002, ["Ignacio", "Pepe",
"Guille", "Mar", "Iselda"])
ad_sist = AdministradorSistemas("Laura", 38, 20000, 4200, 3315242, 3)
dev_ops = DevOps("Roy", 25, 70000, 5200, 3465816, "Python", 2,"CI/CD GitHub
Actions")
print("----Informacion de empleados-----")
dev.mostrar_info()
gerente.mostrar_info()
ad_sist.mostrar_info()
dev_ops.mostrar_info()
empleados = [dev, gerente, ad_sist, dev_ops]
print("\n\n----Jornada laboral-----")
for empleado in empleados:
print("\n***Siguiente empleado: ")
empleado.registrar_entrada()
[Link](20, "Pizza")
empleado.cobrar_salario()
print("\n----Informacion de empleados-----")
dev.mostrar_info()
gerente.mostrar_info()
ad_sist.mostrar_info()
dev_ops.mostrar_info()
print("\n----MRO-----")
print(Empleado.__mro__)
print(Desarrollador.__mro__)
print(Gerente.__mro__)
print(AdministradorSistemas.__mro__)
print(DevOps.__mro__)
¿Por qué todos los objetos pueden ejecutarse dentro del mismo for usando
trabajar(), aunque cada uno realiza acciones diferentes? Porque todos lo
heredan de la misma clase, a pesar de que todos lo reescriben para tener
funcionalidades específicas, aunque prácticamente son el mismo método. Es una
forma de aplicar el polimorfismo.
Conclusión:
En conclusión, la herencia en Python permite desarrollar programas de una manera
más organizada y eficiente, ya que facilita la reutilización de código y evita la
duplicación innecesaria de funcionalidades. Al heredar atributos y métodos, es
posible construir nuevas clases a partir de otras existentes, manteniendo una
estructura clara y coherente dentro del programa.
Además, la capacidad de extender y adaptar el comportamiento de las clases base
brinda mayor flexibilidad al momento de resolver problemas más complejos.
Comprender cómo funciona la herencia y aplicarla correctamente es fundamental
para crear programas más estructurados, reutilizables y fáciles de mantener a lo
largo del tiempo.