Manual Completo de Programación
Orientada a Objetos (POO) en Python
Este manual reúne teoría, ejemplos prácticos, ejercicios resueltos y un banco de problemas
para dominar la Programación Orientada a Objetos (POO) en Python. La POO permite
estructurar programas usando clases y objetos, mejorando la legibilidad, reutilización y
mantenibilidad del código.
1. Concepto de POO
La Programación Orientada a Objetos organiza el software en torno a 'objetos', que
encapsulan datos (atributos) y comportamientos (métodos). Los cuatro pilares básicos son:
Abstracción, Encapsulamiento, Herencia y Polimorfismo.
2. Clases y Objetos
Una clase define la estructura y comportamiento de un objeto. Los objetos son instancias de
una clase.
3. Abstracción
Consiste en modelar solo lo esencial de una entidad, ocultando los detalles innecesarios.
4. Encapsulamiento
Consiste en proteger los datos internos del acceso directo, exponiendo solo métodos
controlados.
5. Herencia
Permite crear nuevas clases a partir de otras existentes, reutilizando código y agregando
funcionalidades.
6. Polimorfismo
Permite que diferentes clases implementen un mismo método de manera distinta.
7. Métodos Especiales (Dunder)
Permiten integrar las clases con Python: __init__, __repr__, __len__, __add__, etc.
8. Métodos de Clase y Estáticos
@classmethod recibe cls y sirve para constructores alternativos. @staticmethod no recibe
ni self ni cls.
9. Composición
En lugar de heredar, una clase puede incluir objetos de otras clases como atributos.
10. Dataclasses
Las dataclasses reducen el código repetitivo, generando automáticamente __init__, __repr__ y
__eq__.
Ejemplos Resueltos Paso a Paso
Ejemplo 1: Clase Persona
Este ejemplo define una clase 'Persona'. El método __init__ inicializa los atributos. El método
'saludar' devuelve un mensaje personalizado.
class Persona:
def __init__(self, nombre, edad):
[Link] = nombre # atributo de instancia
[Link] = edad # atributo de instancia
def saludar(self):
return f"Hola, soy {[Link]} y tengo {[Link]} años."
p = Persona("Marco", 46)
print([Link]())
Ejemplo 2: Herencia y Polimorfismo
La clase abstracta 'Animal' define un método hablar() que debe ser implementado. Las
subclases 'Perro' y 'Gato' lo implementan de forma distinta. Al iterar sobre una lista de
animales, cada uno responde según su tipo.
class Animal:
def hablar(self):
raise NotImplementedError("Debe implementarse en la
subclase")
class Perro(Animal):
def hablar(self):
return "Guau"
class Gato(Animal):
def hablar(self):
return "Miau"
animales = [Perro(), Gato()]
for a in animales:
print([Link]())
Banco de Ejercicios Resueltos
Ejercicio 1: Rectángulo
Crea una clase 'Rectangulo' con atributos base y altura, y un método area().
class Rectangulo:
def __init__(self, base, altura):
[Link] = base
[Link] = altura
def area(self):
return [Link] * [Link]
r = Rectangulo(10, 5)
print("Área:", [Link]())
Ejercicio 2: Estudiante
Implementa una clase 'Estudiante' con nombre, edad y notas. Agrega un método
promedio().
class Estudiante:
def __init__(self, nombre, edad, notas):
[Link] = nombre
[Link] = edad
[Link] = notas
def promedio(self):
return sum([Link]) / len([Link])
e = Estudiante("Ana", 20, [15, 18, 17])
print("Promedio:", [Link]())
Ejercicio 3: Figura Abstracta
Define una clase abstracta 'Figura' con un método area(). Implementa 'Cuadrado' y 'Círculo'.
from abc import ABC, abstractmethod
import math
class Figura(ABC):
@abstractmethod
def area(self):
pass
class Cuadrado(Figura):
def __init__(self, lado):
[Link] = lado
def area(self):
return [Link] ** 2
class Circulo(Figura):
def __init__(self, radio):
[Link] = radio
def area(self):
return [Link] * ([Link] ** 2)
figuras = [Cuadrado(4), Circulo(3)]
for f in figuras:
print("Área:", [Link]())
Ejercicio 4: Facturación
Implementa un sistema de facturación con clases Cliente, Item y Factura. La factura debe
calcular el total.
class Cliente:
def __init__(self, nombre, ruc):
[Link] = nombre
[Link] = ruc
class Item:
def __init__(self, nombre, precio_unitario):
[Link] = nombre
self.precio_unitario = precio_unitario
class Factura:
def __init__(self, cliente):
[Link] = cliente
[Link] = []
def agregar_item(self, item, cantidad):
[Link]((item, cantidad))
def total(self):
return sum(item.precio_unitario * cant for item, cant in
[Link])
c = Cliente("Empresa X", "20123456789")
f = Factura(c)
f.agregar_item(Item("Mouse", 50), 2)
f.agregar_item(Item("Teclado", 120), 1)
print("Total de la factura:", [Link]())
Retos Prácticos (para resolver)
1. 1. Modela un sistema de inventario con clases Producto, Categoría y Almacén.
2. 2. Crea un juego simple con clases Personaje, Guerrero y Mago con métodos atacar().
3. 3. Diseña un sistema escolar con clases Profesor, Alumno y Curso.
4. 4. Implementa un sistema bancario con clases Cuenta, Ahorro y Corriente, aplicando
herencia.
5. 5. Desarrolla un sistema de biblioteca con clases Libro, Socio y Préstamo.