Universidad Nacional Abierta y a Distancia
Estudiante: Rosa Gómez Noriega
Docente: Yahith Gutiérrez
ECBTI
Programa: Ingeniería de Sistemas
Curso: Programación
Grupo 213023_4
Grupo de ejercicios 1
Primer ejercicio
• Crear una clase llamada Persona con atributos nombre y edad, e inicialízalos con valores
predeterminados.
class Persona:
def __init__(self, nombre="Rosa", edad=34):
self.nombre = nombre
self.edad = edad
def mostrar_datos(self):
print(f"Nombre: {self.nombre}")
print(f"Edad: {self.edad}")
# Metodo para datos por consola
nombre = (input("Digite el nombre:"))
edad = int(input("Digite la edad:"))
# crear instancia
Foto
Segundo ejercicio
• Crear una clase Banco con un atributo saldo. Añadir métodos para depositar y retirar cierta
cantidad.
class Banco:
def __init__(self, saldo=0):
self.saldo = saldo
def depositar(self, cantidad):
if cantidad > 0:
self.saldo += cantidad
print(f"Depósito exitoso. Saldo actual: {self.saldo}")
else:
print("La cantidad a depositar debe ser positiva.")
def retirar(self, cantidad):
if 0 < cantidad <= self.saldo:
self.saldo -= cantidad
print(f"Retiro exitoso. Saldo actual: {self.saldo}")
else:
print("Fondos insuficientes o cantidad no válida.")
# Metodo para datos por consola
saldo = int(input("Digite la saldo:"))
cantidad = int(input("Digite la cantidad:"))
Foto
Tercer ejercicio
• Crear una clase abstracta Animal que tenga un método hacer_sonido. Luego, crear clases Perro y
Gato que hereden de Animal e implementen hacer_sonido.
class Animal:
def hacer_sonido(self):
pass
# Clase Perro
class Perro(Animal):
def hacer_sonido(self):
return "Guau Guau"
# Clase Gato
class Gato(Animal):
def hacer_sonido(self):
return "Miau"
# Metodo para datos por consola
gato= (input("mostrar sonido :"))
hacer_sonido= (input("mostrar sonido :"))
Foto
Cuarto ejercicio
• Encapsulamiento y métodos estáticos: Crear una clase Usuario con un atributo
privado_password. Añadir un método para cambiar la contraseña solo si se ingresa
correctamente la actual.
class Usuario:
def __init__(self, nombre, password):
self.nombre = nombre
self.__password = password # Atributo privado
def cambiar_password(self, password_actual, nuevo_password):
"""Cambia la contraseña solo si la actual es correcta."""
if self.__password == password_actual:
self.__password = nuevo_password
print("Contraseña actualizada correctamente.")
else:
print("Error: La contraseña actual es incorrecta.")
@staticmethod
def validar_password(password):
"""Verifica si la contraseña es segura (mínimo 6
caracteres)."""
return len(password) >= 6
# Crear un usuario
usuario1 = Usuario("Juan", "clave123")
# Intentar cambiar la contraseña con una incorrecta
usuario1.cambiar_password("claveIncorrecta", "nuevaClave456")
# Cambiar la contraseña correctamente
usuario1.cambiar_password("clave123", "nuevaClave456")
# Verificar si la nueva contraseña es válida
print("¿Es válida la nueva contraseña?",
Usuario.validar_password("nuevaClave456"))
Foto
Quinto ejercicio
• Crea una clase Rectángulo que tenga dos atributos, ancho y alto. Incluye un método área que
calcule y devuelva el área del rectángulo, y un método perímetro que devuelva el perímetro. Crea
una instancia de Rectángulo y muestra su área y perímetro.
class Rectangulo:
def __init__(self, ancho, alto):
self.ancho = ancho
self.alto = alto
def area(self):
return self.ancho * self.alto
def perimetro(self):
return 2 * (self.ancho + self.alto)
# Crear una instancia de Rectangulo
rectangulo1 = Rectangulo(5, 10)
# Mostrar resultados en consola
print(f"Área del rectángulo: {rectangulo1.area()}")
print(f"Perímetro del rectángulo: {rectangulo1.perimetro()}")
Foto
Sexto ejercicio
• Crea una clase Producto que tenga los atributos nombre, precio, stock, y descuento
(inicialmente en 0). Agrega métodos aplicar_descuento(porcentaje) que ajuste el precio en función
del porcentaje de descuento dado, y actualizar_stock(cantidad) que modifique el stock según la
cantidad (positiva o negativa). También, crea un método descripcion que devuelva una cadena con
toda la información del producto. Crea varios productos, aplícales descuentos y actualiza su stock.
class Producto:
def __init__(self, nombre, precio, stock, descuento=0):
self.nombre = nombre
self.precio = precio
self.stock = stock
self.descuento = descuento
def aplicar_descuento(self, porcentaje):
"""Aplica un descuento al precio del producto."""
if 0 <= porcentaje <= 100:
self.descuento = porcentaje
self.precio *= (1 - porcentaje / 100)
else:
print("Porcentaje de descuento inválido.")
def actualizar_stock(self, cantidad):
"""Actualiza el stock sumando o restando la cantidad dada."""
if self.stock + cantidad >= 0:
self.stock += cantidad
else:
print("No hay suficiente stock disponible.")
def descripcion(self):
"""Devuelve una descripción completa del producto."""
return f"Producto: {self.nombre}, Precio: ${self.precio:.2f},
Stock: {self.stock}, Descuento: {self.descuento}%"
# Crear varios productos
producto1 = Producto("Laptop", 1200, 10)
producto2 = Producto("Smartphone", 800, 15)
producto3 = Producto("Auriculares", 100, 30)
# Aplicar descuentos
producto1.aplicar_descuento(10) # 10% de descuento
producto2.aplicar_descuento(5) # 5% de descuento
producto3.aplicar_descuento(15) # 15% de descuento
# Actualizar stock
producto1.actualizar_stock(-2) # Vender 2 laptops
producto2.actualizar_stock(-5) # Vender 5 smartphones
producto3.actualizar_stock(10) # Recibir 10 auriculares nuevos
# Mostrar información de los productos en consola
print(producto1.descripcion())
print(producto2.descripcion())
print(producto3.descripcion())
Foto
Preguntas orientadora
1. ¿Cómo contribuyen las clases y objetos a la organización del código en un proyecto de
software, y por qué es importante esta organización para el mantenimiento y escalabilidad del
mismo?
Las clases y objetos son fundamentales en la programación orientada a objetos (POO). Las clases
actúan como plantillas que definen atributos y métodos, mientras que los objetos son instancias
concretas de estas clases. Esta estructura permite modularizar el código, facilitando su
comprensión y gestión. Al dividir un proyecto en clases y objetos, se promueve la reutilización del
código y se evita la duplicidad, siguiendo el principio DRY ("Don't Repeat Yourself"). Esta
organización es esencial para el mantenimiento, ya que permite localizar y corregir errores de
manera más eficiente. Además, facilita la escalabilidad del software, ya que se pueden añadir
nuevas funcionalidades sin alterar significativamente el código existente
2. ¿De qué manera los métodos dentro de una clase permiten encapsular la funcionalidad y
facilitar la reutilización del código en diferentes partes de un programa? Proporciona un ejemplo
que ilustre esta relación.
El encapsulamiento es un principio de la POO que consiste en ocultar los detalles internos de una
clase y exponer solo lo necesario a través de métodos públicos. Esto protege los datos y asegura
que solo se manipulen mediante las interfaces definidas, evitando accesos indebidos o
modificaciones accidentales. Al encapsular la funcionalidad dentro de métodos, se promueve la
reutilización del código, ya que estos métodos pueden ser invocados en diferentes partes del
programa sin necesidad de reescribir la lógica.
3. ¿Por qué es fundamental la abstracción en la programación orientada a objetos, y cómo
ayuda a los desarrolladores a enfocarse en la lógica del problema sin preocuparse por los
detalles de implementación?
La abstracción es un concepto clave en la POO que permite a los desarrolladores centrarse en las
características esenciales de un objeto, ignorando los detalles innecesarios. Al utilizar la
abstracción, se pueden crear interfaces o clases abstractas que definen métodos y propiedades
comunes, dejando la implementación específica a las clases derivadas. Esto facilita la gestión de la
complejidad en sistemas de software, ya que los desarrolladores pueden trabajar con
representaciones simplificadas de los objetos, enfocándose en la lógica del problema sin distraerse
con las particularidades de la implementación.
Por ejemplo, en un sistema de gestión de vehículos, se puede crear una clase abstracta Vehiculo
con métodos como arrancar() y detener(). Las clases concretas Coche y Moto heredarían de
Vehiculo e implementarían estos métodos según sus especificaciones, permitiendo a los
desarrolladores interactuar con objetos de tipo Vehiculo sin preocuparse por cómo cada tipo de
vehículo implementa dichas funciones.
Referencia
Dueñas Meza, J. M., Valdés Benjumea, J. J., & Rodríguez Niño, M. C. (2021). Didáctica para
el aprendizaje de algoritmos (19 - 23). Sello Editorial
UNAD. https://doi.org/10.22490/9789586517799
