¿Qué beneficio principal aporta encapsular comportamiento en una clase?

La encapsulación mantiene estado y reglas juntos, reduciendo lógica dispersa y errores de consistencia.

Python

POO en Python: clases, objetos y encapsulación orientada al dominio

Aprende a modelar entidades de negocio con clases, atributos y métodos, evitando clases anémicas y mejorando cohesión.

¿Cuánto sabes de Python?

📘 Teoría

1) Clase vs objeto: plano y instancia

La clase describe el modelo; el objeto representa un caso concreto de ese modelo.

`class Cuenta:` define estructura y reglas comunes. `cuenta_ana = Cuenta(...)` crea una instancia con estado propio.

Dos objetos de la misma clase comparten comportamiento, pero no necesariamente valores de atributos.

Piensa primero qué invariantes debe respetar la entidad antes de escribir métodos.

Definición e instanciación básica

class Cuenta:
    def __init__(self, titular: str, saldo: float = 0.0) -> None:
        self.titular = titular
        self.saldo = saldo


cuenta_ana = Cuenta('Ana', 100.0)
cuenta_luis = Cuenta('Luis', 50.0)
print(cuenta_ana.saldo, cuenta_luis.saldo)

2) Encapsulación: proteger reglas dentro de métodos

Los métodos deben hacer cumplir reglas del negocio, no solo modificar atributos sin control.

Si cualquier parte del sistema puede cambiar `saldo` directamente, se rompe la consistencia del dominio.

Métodos como `depositar` o `retirar` son puntos de control para validar entradas.

La encapsulación reduce errores y hace más explícitas las operaciones permitidas.

Valida reglas dentro de métodos, no fuera.
Evita estados imposibles desde el constructor.
Mantén métodos cortos y orientados al dominio.
Lanza excepciones claras en violaciones de regla.

Métodos con validación de negocio

class Cuenta:
    def __init__(self, titular: str, saldo: float = 0.0) -> None:
        self.titular = titular
        self.saldo = saldo

    def depositar(self, cantidad: float) -> None:
        if cantidad <= 0:
            raise ValueError('La cantidad debe ser positiva')
        self.saldo += cantidad

    def retirar(self, cantidad: float) -> None:
        if cantidad <= 0:
            raise ValueError('La cantidad debe ser positiva')
        if cantidad > self.saldo:
            raise ValueError('Saldo insuficiente')
        self.saldo -= cantidad

3) Métodos especiales útiles (`repr`, `str`)

Representaciones legibles facilitan debugging y logging.

`__repr__` debería describir el objeto de forma útil para desarrolladores.

`__str__` puede orientarse más a salida amigable para usuario/CLI.

Una buena representación acelera diagnóstico cuando inspeccionas objetos en logs o consola.

Representación útil de entidad

class Producto:
    def __init__(self, sku: str, precio: float) -> None:
        self.sku = sku
        self.precio = precio

    def __repr__(self) -> str:
        return f'Producto(sku={self.sku!r}, precio={self.precio})'


print(Producto('KB-001', 39.9))

1 1) Clase vs objeto: plano y instancia 2 2) Encapsulación: proteger reglas dentro de métodos 3 3) Métodos especiales útiles (`__repr__`, `__str__`)