10 Ejercicios Resueltos de Python: Programación Orientada a Objetos (POO) en la Universidad

Llegamos al núcleo duro de la carrera en larebelion.com. Si quieres aprobar asignaturas como Programación II o Metodología de la Programación, tienes que dominar las clases, los objetos, la herencia y el polimorfismo en Python.

Te traemos 10 ejercicios clásicos de exámenes sobre POO extraídos de las mejores facultades de España. ¡Prepara tus métodos __init__ porque empezamos!

---

21. Clase Básica: Geometría (UPM)

Enunciado: Crea una clase Rectangulo que reciba la base y la altura en su constructor, y contenga métodos para calcular el área y el perímetro.

class Rectangulo:
    def __init__(self, base, altura):
        self.base = base
        self.altura = altura

    def area(self):
        return self.base * self.altura

    def perimetro(self):
        return 2 * (self.base + self.altura)

22. Encapsulamiento: Cuenta Bancaria (UPC)

Enunciado: Implementa una clase CuentaBancaria con un atributo privado para el saldo (__saldo) y métodos para depositar y retirar dinero, validando que no se pueda retirar más del saldo disponible.

class CuentaBancaria:
    def __init__(self, saldo_inicial=0):
        self.__saldo = saldo_inicial

    def depositar(self, cantidad):
        if cantidad > 0: self.__saldo += cantidad

    def retirar(self, cantidad):
        if 0 < cantidad <= self.__saldo:
            self.__saldo -= cantidad
            return True
        return False

    def get_saldo(self):
        return self.__saldo

23. Herencia: Vehículos (UGR)

Enunciado: Crea una clase base Vehiculo con atributos marca y ruedas. Luego, crea una subclase Coche que herede de ella y añada el atributo puertas.

class Vehiculo:
    def __init__(self, marca, ruedas):
        self.marca = marca
        self.ruedas = ruedas

class Coche(Vehiculo):
    def __init__(self, marca, puertas):
        # Llamamos al constructor padre con super()
        super().__init__(marca, ruedas=4)
        self.puertas = puertas

24. Polimorfismo: Empleados (UV)

Enunciado: Define una clase Empleado con un método calcular_salario(). Crea las clases Programador y Gerente que sobrescriban este método de forma diferente.

class Empleado:
    def __init__(self, base): self.base = base
    def calcular_salario(self): pass

class Programador(Empleado):
    def calcular_salario(self):
        return self.base + 500 # Bono de código

class Gerente(Empleado):
    def calcular_salario(self):
        return self.base + 2000 # Bono de dirección

25. Composición: Ordenador y CPU (UC3M)

Enunciado: Demuestra la composición creando una clase Procesador que se instancie dentro del constructor de una clase Ordenador.

class Procesador:
    def __init__(self, modelo):
        self.modelo = modelo

class Ordenador:
    def __init__(self, marca, cpu_modelo):
        self.marca = marca
        # Composición: El procesador pertenece al ordenador
        self.cpu = Procesador(cpu_modelo)

26. Métodos Mágicos (Dunder): __str__ (US)

Enunciado: Crea una clase Libro (título, autor) y sobrescribe el método __str__ para que al hacer print(libro) devuelva "Título por Autor".

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

    def __str__(self):
        return f"{self.titulo} por {self.autor}"

27. Sobrecarga de Operadores: __add__ (UMA)

Enunciado: Implementa una clase Punto2D (x, y) que permita sumar dos puntos usando el operador matemático +.

class Punto2D:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, otro_punto):
        return Punto2D(self.x + otro_punto.x, self.y + otro_punto.y)

28. Atributos de Clase vs Instancia (UAM)

Enunciado: Crea una clase Usuario que lleve la cuenta total de cuántos usuarios han sido instanciados usando un atributo de clase.

class Usuario:
    # Atributo de clase
    total_usuarios = 0

    def __init__(self, nombre):
        self.nombre = nombre # Atributo de instancia
        Usuario.total_usuarios += 1

29. Excepciones Personalizadas (UNED)

Enunciado: Crea una excepción propia llamada SaldoInsuficienteError y lánzala (raise) en una clase Monedero si se intenta pagar más de lo que hay.

class SaldoInsuficienteError(Exception):
    pass

class Monedero:
    def __init__(self, saldo): self.saldo = saldo

    def pagar(self, importe):
        if importe > self.saldo:
            raise SaldoInsuficienteError("No hay dinero suficiente.")
        self.saldo -= importe

30. Relación entre Clases: Universidad (USAL)

Enunciado: Escribe una clase Curso que mantenga una lista de objetos Alumno. Implementa un método para matricular un alumno en el curso.

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

class Curso:
    def __init__(self, nombre_asignatura):
        self.asignatura = nombre_asignatura
        self.alumnos = [] # Lista de objetos Alumno

    def matricular(self, alumno):
        self.alumnos.append(alumno)

    def listar_alumnos(self):
        return [a.nombre for a in self.alumnos]