💪 Ejercicios Prácticos

Pon en práctica todo lo aprendido y fortalece tus habilidades

🎯 Desafío de la Clase

Completa todos los ejercicios para dominar las funciones en Python. Cada ejercicio te ayudará a entender mejor cómo crear y usar funciones efectivamente.

🐙 Recuerda: Sube todos tus ejercicios a GitHub para seguir practicando el uso de esta herramienta y llevar un registro de tu progreso.

📝 Lista de Ejercicios

Fácil

1. Clase Persona Simple

Crea una clase Persona con los atributos nombre y edad. Instancia dos personas y muestra sus datos.

class Persona:
    def __init__(self, nombre, edad):
        self.nombre = nombre
        self.edad = edad

persona1 = Persona("Ana", 25)
persona2 = Persona("Carlos", 30)
print(persona1.nombre, persona1.edad)
print(persona2.nombre, persona2.edad)
Fácil

2. Saludo Personalizado

Agrega un método saludar() a la clase Persona que imprima "Hola, soy [nombre]".

class Persona:
    def __init__(self, nombre):
        self.nombre = nombre
    def saludar(self):
        print(f"Hola, soy {self.nombre}")

persona = Persona("Ana")
persona.saludar()
Fácil

3. Contador de Objetos

Crea una clase Contador que tenga un atributo de clase para contar cuántos objetos se han creado.

class Contador:
    cantidad = 0 # atributo de clase
    def __init__(self):
        Contador.cantidad += 1

c1 = Contador()
c2 = Contador()
c3 = Contador()
print(Contador.cantidad) # 3
Medio

4. Encapsulamiento Básico

Crea una clase Cuenta con un atributo privado __saldo. Implementa métodos para depositar y retirar dinero, validando que el saldo nunca sea negativo.

class Cuenta:
    def __init__(self, saldo):
        self.__saldo = saldo
    def depositar(self, monto):
        if monto > 0:
            self.__saldo += monto
    def retirar(self, monto):
        if self.__saldo >= monto:
            self.__saldo -= monto
    def mostrar_saldo(self):
        print(f"Saldo actual: {self.__saldo}")

cuenta = Cuenta(100)
cuenta.depositar(50)
cuenta.retirar(30)
cuenta.mostrar_saldo()
Medio

5. Getters y Setters

Modifica la clase Cuenta para que el saldo solo pueda leerse y modificarse usando @property y su setter.

class Cuenta:
    def __init__(self, saldo):
        self.__saldo = saldo
    @property
    def saldo(self):
        return self.__saldo
    @saldo.setter
    def saldo(self, valor):
        if valor >= 0:
            self.__saldo = valor

cuenta = Cuenta(200)
print(cuenta.saldo)
cuenta.saldo = 500
print(cuenta.saldo)
Medio

6. Producto con Stock

Crea una clase Producto con atributos nombre (público), _stock (protegido) y __precio (privado). Implementa métodos para vender y reponer stock.

class Producto:
    def __init__(self, nombre, precio, stock):
        self.nombre = nombre
        self._stock = stock
        self.__precio = precio
    def vender(self, cantidad):
        if self._stock >= cantidad:
            self._stock -= cantidad
    def reponer(self, cantidad):
        self._stock += cantidad
    def mostrar_info(self):
        print(f"{self.nombre} - Stock: {self._stock} - Precio: {self._Producto__precio}")

p = Producto("Mouse", 10, 5)
p.vender(2)
p.reponer(3)
p.mostrar_info()
Medio

7. Constructor con Validación

Crea una clase Libro cuyo constructor valide que el número de páginas y el precio no sean negativos. Lanza un ValueError si no se cumple.

class Libro:
    def __init__(self, titulo, paginas, precio):
        if paginas < 0 or precio < 0:
            raise ValueError("Páginas y precio no pueden ser negativos")
        self.titulo = titulo
        self.paginas = paginas
        self.precio = precio

l = Libro("Python", 200, 25)
print(l.titulo, l.paginas, l.precio)
Medio

8. Valores por Defecto

Haz que la clase Libro permita crear libros con o sin precio y páginas (por defecto: 100 páginas, precio 0.0).

class Libro:
    def __init__(self, titulo, autor, paginas=100, precio=0.0):
        self.titulo = titulo
        self.autor = autor
        self.paginas = paginas
        self.precio = precio

l1 = Libro("Python", "Guido")
l2 = Libro("AI", "Alan", 300, 50)
print(l1.titulo, l1.paginas, l1.precio)
print(l2.titulo, l2.paginas, l2.precio)
Medio

9. Herencia Simple

Crea una clase Empleado que herede de Persona y agregue el atributo puesto y un método trabajar().

class Persona:
    def __init__(self, nombre):
        self.nombre = nombre

class Empleado(Persona):
    def __init__(self, nombre, puesto):
        super().__init__(nombre)
        self.puesto = puesto
    def trabajar(self):
        print(f"{self.nombre} está trabajando como {self.puesto}")

e = Empleado("Ana", "Ingeniera")
e.trabajar()
Medio

10. Lista de Objetos

Crea una lista de objetos Producto y muestra el nombre de todos los productos cuyo stock sea mayor a 0.

class Producto:
    def __init__(self, nombre, stock):
        self.nombre = nombre
        self.stock = stock

productos = [
    Producto("Mouse", 5),
    Producto("Teclado", 0),
    Producto("Monitor", 3)
]
for p in productos:
    if p.stock > 0:
        print(p.nombre)
Difícil

11. Manipulación de Objetos en Memoria

Crea una clase Carrito que permita agregar y eliminar productos (objetos) y calcule el total del carrito.

class Producto:
    def __init__(self, nombre, precio):
        self.nombre = nombre
        self.precio = precio

class Carrito:
    def __init__(self):
        self.productos = []
    def agregar(self, producto):
        self.productos.append(producto)
    def eliminar(self, producto):
        self.productos.remove(producto)
    def total(self):
        return sum(p.precio for p in self.productos)

c = Carrito()
p1 = Producto("Mouse", 10)
p2 = Producto("Teclado", 20)
c.agregar(p1)
c.agregar(p2)
print(c.total())
Difícil

12. Desafío Final: Sistema de Biblioteca

Implementa un sistema con clases Libro, Usuario y Biblioteca. Permite prestar y devolver libros, controlar el stock y mostrar los libros prestados a cada usuario.

class Libro:
    def __init__(self, titulo, stock):
        self.titulo = titulo
        self.stock = stock

class Usuario:
    def __init__(self, nombre):
        self.nombre = nombre
        self.prestados = []

class Biblioteca:
    def __init__(self):
        self.libros = []
    def agregar_libro(self, libro):
        self.libros.append(libro)
    def prestar(self, libro, usuario):
        if libro.stock > 0:
            libro.stock -= 1
            usuario.prestados.append(libro)
    def devolver(self, libro, usuario):
        if libro in usuario.prestados:
            libro.stock += 1
            usuario.prestados.remove(libro)
    def mostrar_prestados(self, usuario):
        for libro in usuario.prestados:
            print(libro.titulo)

b = Biblioteca()
l1 = Libro("Python", 2)
l2 = Libro("AI", 1)
b.agregar_libro(l1)
b.agregar_libro(l2)
u = Usuario("Ana")
b.prestar(l1, u)
b.mostrar_prestados(u)

🏆 Desafío Final

¡Pon a prueba todos tus conocimientos con este desafío integrador!

Difícil

Desafío: Sistema de Calificaciones

Crea un programa que calcule el promedio de calificaciones de un estudiante y determine su nivel de rendimiento.

  • Pide al estudiante que ingrese 5 calificaciones (0-100)
  • Calcula el promedio de las calificaciones
  • Determina el nivel de rendimiento según el promedio:
  • • 90-100: Excelente
  • • 80-89: Muy Bueno
  • • 70-79: Bueno
  • • 60-69: Regular
  • • 0-59: Necesita Mejorar
  • Muestra el promedio y el nivel de rendimiento
# Solución: Sistema de calificaciones # Pedir las 5 calificaciones calificaciones = [] for i in range(5): calificacion = float(input(f"Ingresa la calificación {i+1}: ")) calificaciones.append(calificacion) # Calcular promedio promedio = sum(calificaciones) / len(calificaciones) # Determinar nivel de rendimiento if promedio >= 90: nivel = "Excelente" elif promedio >= 80: nivel = "Muy Bueno" elif promedio >= 70: nivel = "Bueno" elif promedio >= 60: nivel = "Regular" else: nivel = "Necesita Mejorar" # Mostrar resultados print("Calificaciones:", calificaciones) print("Promedio:", promedio) print("Nivel de rendimiento:", nivel)

🎉 ¡Felicidades!

Has completado exitosamente los fundamentos básicos de Python. Estos ejercicios te han ayudado a:

Próximo paso: Estás listo para continuar con estructuras de datos más complejas, bucles y condicionales en las siguientes clases.