Fundamentos de Python

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.

  • Principiante
  • 4 min de lectura
  • 1 ejemplo ejecutable

¿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).

Del banco al código
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 intereses
super().__init__(owner, balance)📋 Rellena primero el formulario de la cuenta normal
account.month_end()📅 La misma petición, cada cuenta responde a su manera
Las reglas comunes en la clase base, las diferencias en la subclase.
En una frase

La 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

  1. BankAccount posee el saldo y valida depósitos.
  2. SavingsAccount reutiliza el contrato base.
  3. SavingsAccount sobrescribe month_end para aplicar interés.
  4. El bucle usa todos los objetos mediante la misma interfaz.
Consejo: Prefiere composición cuando un objeto solo usa otro; usa herencia únicamente si el hijo sustituye correctamente al padre.

¿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

Ejecutar código →
main.py
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})")
Obtén un botón Run para este ejemplo

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

Ejecutar código →

reunir estado y comportamiento y controlar el acceso.

encapsulation.py
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

Ejecutar código →

mostrar una interfaz útil y ocultar detalles innecesarios.

abstraction.py
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

Ejecutar código →

especializar una clase solo ante una verdadera relación «es un».

inheritance.py
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

Ejecutar código →

usar la misma operación con objetos distintos y comportamiento apropiado.

polymorphism.py
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.

  1. Cambia los datos de entrada y predice el resultado antes de ejecutar.
  2. Añade una comprobación para datos vacíos o no válidos.
  3. Pasa el proceso a una función aparte y pruébala con varios conjuntos de datos.
Ejecutar en el compilador de Python →

Errores comunes

Olvidar llamar a super().__init__

Sin él, la preparación del padre nunca se ejecuta y faltan atributos como owner.

Problema
class SavingsAccount(BankAccount):
    def __init__(self, owner, balance, rate):
        self.interest_rate = rate
Solución
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().

Problema
account._balance = -500
Solución
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