La programación orientada a objetos en Python
En esta lección vas a conocer la encapsulación, la herencia, la sobrescritura de métodos y el polimorfismo con un ejemplo de cuenta bancaria en Python.
¿Qué es la programación orientada a objetos en Python?
El problema
Cuando un programa crece, muchas partes necesitan los mismos tipos de objetos con pequeñas diferencias: una cuenta normal y una de ahorro, un gato y un perro. Copiar clases y cambiar unas líneas duplica el código, y comprobar el tipo con if en todas partes hace que cada tipo nuevo sea un gran cambio.
Imagínalo así
La programación orientada a objetos funciona como las cuentas de un mismo banco. Cada cuenta guarda su saldo detrás del mostrador (encapsulamiento). Una cuenta de ahorro es una cuenta normal con una función extra (herencia). Cuando el banco les dice 'fin de mes' a todas las cuentas, cada una hace su propia versión (polimorfismo).
self._balance🔒 El dinero detrás del mostrador: cámbialo solo con deposit()class SavingsAccount(BankAccount):🏦 Una cuenta de ahorro es una cuenta, más interesessuper().__init__(owner, balance)📋 Rellena primero el formulario de la cuenta normalaccount.month_end()📅 La misma petición, cada cuenta responde a su maneraLa programación orientada a objetos organiza un programa en clases cuyos objetos mantienen privados sus datos (encapsulación), reutilizan otras clases (herencia) y responden a la misma llamada a su manera (polimorfismo).
La POO modela un sistema como objetos que colaboran. Cada objeto combina estado y operaciones válidas, facilitando responsabilidades claras en aplicaciones grandes.
Los cuatro principios fundamentales
- Encapsulación: reunir estado y comportamiento y controlar el acceso.
- Abstracción: mostrar una interfaz útil y ocultar detalles innecesarios.
- Herencia: especializar una clase solo ante una verdadera relación «es un».
- Polimorfismo: usar la misma operación con objetos distintos y comportamiento apropiado.
Diseño del ejemplo
- BankAccount posee el saldo y valida depósitos.
- SavingsAccount reutiliza el contrato base.
- SavingsAccount sobrescribe month_end para aplicar interés.
- El bucle usa todos los objetos mediante la misma interfaz.
¿Cuándo se usa?
- Varios tipos de objetos que comparten casi todo el comportamiento: tipos de cuenta, figuras, personajes de juegos.
- Código que más adelante debe funcionar con tipos nuevos sin reescribirse.
- Proteger datos que deben seguir siendo válidos, como un saldo que nunca puede ser negativo.
Cuándo no hace falta
- Scripts pequeños con unas pocas funciones: las clases y la herencia añaden una estructura que no necesitas.
- Cadenas de herencia profundas (A de B de C de D): son difíciles de seguir; mejor la composición.
Ejemplo básico
class BankAccount:
def __init__(self, owner, balance=0):
self.owner = owner
self._balance = float(balance)
@property
def balance(self):
return self._balance
def deposit(self, amount):
if amount <= 0:
raise ValueError("Deposit must be positive")
self._balance += amount
def month_end(self):
return "No interest"
class SavingsAccount(BankAccount):
def __init__(self, owner, balance, interest_rate):
super().__init__(owner, balance)
self.interest_rate = interest_rate
def month_end(self):
self._balance *= 1 + self.interest_rate
return "Interest applied"
accounts = [
BankAccount("Ada", 100),
SavingsAccount("Lin", 200, 0.05),
]
accounts[0].deposit(50)
for account in accounts:
status = account.month_end()
print(f"{account.owner}: {account.balance:.2f} ({status})")
Resultado de la ejecución
Ada: 150.00 (No interest)
Lin: 210.00 (Interest applied)
Los cuatro principios de POO en la práctica
Estos ejemplos muestran cómo Python aplica encapsulación, abstracción, herencia y polimorfismo en código cotidiano.
Encapsulación
reunir estado y comportamiento y controlar el acceso.
class BankAccount:
def __init__(self, balance=0):
# Double underscores prevent accidental direct access.
self.__balance = balance
@property
def balance(self):
# Expose read access without exposing mutation.
return self.__balance
def deposit(self, amount):
# Keep validation next to the state it protects.
if amount <= 0:
raise ValueError("Amount must be positive")
self.__balance += amount
account = BankAccount(100)
account.deposit(50)
print(account.balance) # 150
Abstracción
mostrar una interfaz útil y ocultar detalles innecesarios.
from abc import ABC, abstractmethod
class PaymentMethod(ABC):
@abstractmethod
def pay(self, amount):
# Callers know what pay does, not how each provider does it.
pass
class CreditCard(PaymentMethod):
def pay(self, amount):
# The concrete class hides its payment implementation.
return f"Paid ${amount:.2f} by card"
payment = CreditCard()
print(payment.pay(25))
Herencia
especializar una clase solo ante una verdadera relación «es un».
class Employee:
def __init__(self, name):
self.name = name
def describe(self):
return self.name
class Developer(Employee):
def __init__(self, name, language):
# Reuse initialization from the parent class.
super().__init__(name)
self.language = language
def describe(self):
# Extend inherited behavior instead of duplicating it.
return f"{super().describe()} writes {self.language}"
print(Developer("Ada", "Python").describe())
Polimorfismo
usar la misma operación con objetos distintos y comportamiento apropiado.
class EmailNotification:
def send(self, message):
return f"Email: {message}"
class SmsNotification:
def send(self, message):
return f"SMS: {message}"
def notify(channels, message):
for channel in channels:
# The same call selects behavior from each concrete object.
print(channel.send(message))
channels = [EmailNotification(), SmsNotification()]
notify(channels, "Order shipped")
Explicación del código
La clase BankAccount encapsula el saldo en el atributo _balance y solo permite cambiarlo mediante métodos controlados como deposit(). La clase SavingsAccount hereda todos esos métodos y sobrescribe month_end() para añadir los intereses. El bucle llama al mismo método en las dos cuentas, pero Python elige al ejecutar la versión adecuada para cada tipo de objeto. Eso es el polimorfismo.
Cambia los valores y ejecuta el programa en el compilador Python online de CodeUtility sin instalar Python.
Ejercicios de práctica
Prueba a modificar el código siguiendo las ideas de abajo. Cambiar el código y ver el resultado te ayudará a entender la lección mucho mejor que solo leerla.
- Cambia los datos de entrada y predice el resultado antes de ejecutar.
- Añade una comprobación para datos vacíos o no válidos.
- Pasa el proceso a una función aparte y pruébala con varios conjuntos de datos.
Errores comunes
Olvidar llamar a super().__init__
Sin él, la preparación del padre nunca se ejecuta y faltan atributos como owner.
class SavingsAccount(BankAccount):
def __init__(self, owner, balance, rate):
self.interest_rate = rate
class SavingsAccount(BankAccount):
def __init__(self, owner, balance, rate):
super().__init__(owner, balance)
self.interest_rate = rate
Cambiar directamente datos protegidos
Asignar _balance desde fuera se salta las comprobaciones de deposit().
account._balance = -500
account.deposit(50)
¿Terminaste esta lección?
Márcala como aprendida para seguir tu progreso.
Practica con un reto
Usa lo que cubre esta lección para resolver un problema real. Cada reto se ejecuta en el navegador, con pruebas al instante y una revisión de IA.
Todos los retos