Clases y programación orientada a objetos

📐 Fundamento

class Pupusa:
    """Representa una pupusa con sabor y precio."""

    # --- atributo de clase (compartido por todas las instancias) ---
    impuesto = 0.13

    # --- constructor ---
    def __init__(self, sabor, precio):
        # atributos de instancia (uno por objeto)
        self.sabor = sabor
        self.precio = precio

    # --- métodos de instancia ---
    def precio_con_iva(self):
        return self.precio * (1 + self.impuesto)

    def __str__(self):
        return f"Pupusa de {self.sabor} (${self.precio:.2f})"

Las piezas:

• class Pupusa: — declaración. Convención: nombre de clase en CamelCase (Pupusa, MiClase, ProcesadorDePagos).
• Docstring opcional pero recomendado.
• __init__ — el constructor. Se llama al crear: Pupusa("queso", 0.50) → llama a __init__(self, "queso", 0.50).
• self — referencia al objeto actual. Primer parámetro de cada método, automáticamente.
• Atributos de instancia: self.algo = .... Cada objeto tiene los suyos.
• Atributos de clase: definidos al nivel de la clase, compartidos. Buenos para constantes.
• Métodos: funciones definidas adentro de la clase. Reciben self.
• __str__ — método especial: lo que devuelve str(obj) y print(obj).

Crear y usar:

p = Pupusa("queso", 0.50)
print(p.sabor)             # "queso"
print(p.precio_con_iva())  # 0.5650
print(p)                    # "Pupusa de queso ($0.50)"

p.metodo() es azúcar sintáctica para Pupusa.metodo(p). Por eso self aparece como primer parámetro.

Métodos especiales (dunder)

__init__, __str__ son métodos especiales (también llamados dunder methods — double underscore). Definirlos cambia cómo Python interactúa con tu objeto.

Implementarlos bien hace que tus objetos se sientan nativos en Python.

📐 Fundamento

Encapsulamiento = los detalles internos de una clase no deberían depender de los detalles de fuera. La clase expone métodos y oculta datos privados.

Convenciones de visibilidad en Python:

Python no tiene private/public reales como Java o C++. El lenguaje confía en el programador. La filosofía: "Todos somos adultos consintientes".

class CuentaBancaria:
    def __init__(self, saldo_inicial):
        self._saldo = saldo_inicial      # no toques esto desde afuera

    def depositar(self, monto):
        if monto <= 0:
            raise ValueError("Monto debe ser positivo")
        self._saldo += monto

    def retirar(self, monto):
        if monto > self._saldo:
            raise ValueError("Saldo insuficiente")
        self._saldo -= monto

    def saldo(self):
        return self._saldo

Por qué esconder _saldo: mañana podés cambiar la representación interna (un int → un Decimal, o guardar en disco) sin que nadie afuera tenga que cambiar nada.

Properties

A veces querés que un atributo se vea como atributo pero ejecute código:

class Carro:
    def __init__(self, km):
        self._km = km

    @property
    def km(self):
        return self._km

    @km.setter
    def km(self, valor):
        if valor < self._km:
            raise ValueError("Los km no pueden bajar")
        self._km = valor

c = Carro(0)
c.km = 100        # llama al setter
print(c.km)       # llama al getter
c.km = 50         # ValueError

Útil para validar al setear o calcular al consultar. Mantenés sintaxis simple (c.km) con lógica detrás.

📐 Fundamento

Herencia = una clase hereda atributos y métodos de otra. Modela la relación "X es un Y".

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

    def comer(self):
        print(f"{self.nombre} come")

    def hablar(self):
        print(f"{self.nombre} hace ruido")


class Perro(Animal):
    def hablar(self):
        # sobrescribe el método de Animal
        print(f"{self.nombre} ladra: ¡guau!")


class Gato(Animal):
    def hablar(self):
        print(f"{self.nombre} maúlla: miau")


a = Perro("Rex")
a.comer()      # "Rex come"  (heredado de Animal)
a.hablar()     # "Rex ladra: ¡guau!"  (sobrescrito en Perro)

class Perro(Animal): — Perro hereda de Animal.

Beneficios:

1. Reutilización: no escribís comer en cada subclase.
2. Polimorfismo: podés tener una lista de animales y llamar hablar() a cada uno; ejecuta el método específico de su clase real.

super()

Cuando una subclase quiere extender un método del padre (no reemplazarlo):

class PerroEntrenado(Perro):
    def __init__(self, nombre, comandos):
        super().__init__(nombre)         # llama al __init__ del padre
        self.comandos = comandos

    def hablar(self):
        super().hablar()                  # primero el ladrido normal
        print(f"  (sabe: {', '.join(self.comandos)})")

super() referencia a la clase padre. Pattern muy común en __init__: inicializás lo del padre y agregás lo tuyo.

Herencia múltiple

Python permite heredar de varias clases:

class Volador:
    def volar(self):
        print(f"{self.nombre} vuela")


class Pajaro(Animal, Volador):
    pass


pato = Pajaro("Donald")
pato.comer()      # de Animal
pato.volar()      # de Volador

Cuidado. Herencia múltiple puede llevar al diamond problem (cuando dos padres tienen métodos del mismo nombre). Python lo resuelve con MRO (Method Resolution Order — algoritmo C3 linearization). Por defecto andá fácil — usá herencia múltiple solo cuando la jerarquía es clara.

📐 Fundamento

Polimorfismo = "muchas formas". El mismo código funciona con objetos de tipos distintos, siempre que respeten la misma interfaz.

animales = [Perro("Rex"), Gato("Mishi"), Pajaro("Donald")]

for a in animales:
    a.hablar()      # cada uno usa SU método

Duck typing — Python lo lleva al extremo. "If it walks like a duck and quacks like a duck, it's a duck."

class Robot:
    def __init__(self, nombre):
        self.nombre = nombre
    def hablar(self):
        print(f"{self.nombre}: BEEP")

# Robot NO hereda de Animal
animales = [Perro("Rex"), Robot("R2D2")]
for a in animales:
    a.hablar()       # funciona perfectamente

A Python no le importa el tipo, solo si tiene .hablar(). Esa flexibilidad es muy poderosa pero requiere disciplina (los errores aparecen en runtime, no compilando).

Para añadir rigor: Protocols (Python 3.8+) y abstract base classes (abc) declaran formalmente qué métodos debe tener un tipo. Lo dejamos para profundizar en la siguiente materia.

📐 Fundamento

Para clases que son principalmente contenedores de datos, hay una forma más limpia: @dataclass.

from dataclasses import dataclass

@dataclass
class Producto:
    nombre: str
    precio: float
    stock: int = 0           # default opcional

p = Producto("Pupusa de queso", 0.50, 100)
print(p)                      # Producto(nombre='Pupusa...', precio=0.5, stock=100)
print(p == Producto("Pupusa de queso", 0.50, 100))   # True

@dataclass genera automáticamente:

• __init__ con los campos.
• __repr__ legible.
• __eq__ que compara por valor.
• Opcionalmente: __hash__, <, etc.

Equivalente a esto, escrito a mano:

class Producto:
    def __init__(self, nombre, precio, stock=0):
        self.nombre = nombre
        self.precio = precio
        self.stock = stock
    def __repr__(self):
        return f"Producto({self.nombre!r}, {self.precio}, {self.stock})"
    def __eq__(self, other):
        return (self.nombre, self.precio, self.stock) == (other.nombre, ...)

Mucho más limpio con @dataclass. Para entidades simples (Producto, Cliente, Pedido, Coordenada) — usá dataclasses.

Opciones útiles:

@dataclass(frozen=True)        # inmutable; hashable; no podés modificar campos
@dataclass(order=True)          # genera <, >, etc.

📐 Fundamento

Aparte de los métodos de instancia (con self), hay otros tipos:

class Pupusa:
    impuesto = 0.13
    
    def __init__(self, sabor, precio):
        self.sabor = sabor
        self.precio = precio

    @classmethod
    def desde_string(cls, s):
        """Constructor alternativo: 'queso:0.50' → Pupusa('queso', 0.50)"""
        sabor, precio = s.split(":")
        return cls(sabor, float(precio))

    @staticmethod
    def es_sabor_valido(sabor):
        """No usa self ni cls."""
        return sabor in {"queso", "revuelta", "frijol", "chicharron"}


p = Pupusa.desde_string("queso:0.50")     # constructor alternativo
Pupusa.es_sabor_valido("queso")            # True (sin instancia)

• @classmethod: recibe cls (la clase) en vez de self. Útil para constructores alternativos o cuando la operación es de la clase, no del objeto.
• @staticmethod: no recibe ni self ni cls. Es como una función "encerrada" en la clase por organización.

Convención: si tu staticmethod no usa nada de la clase, probablemente debería ser una función suelta, no un método.

📐 Fundamento

Tradicionalmente la OOP se resume en cuatro principios:

1. Encapsulamiento. Datos y operaciones que los manipulan, juntos. Detalles internos ocultos.
2. Herencia. Reutilizar código mediante "es un". Cuidado con jerarquías profundas — son frágiles.
3. Polimorfismo. Mismo código, distintos comportamientos según el tipo.
4. Abstracción. Modelar las cosas con la complejidad necesaria y ocultar el resto.

Crítica moderna. OOP fue dogma en los 90-2000. Hoy se reconoce que:

• Composición > herencia. Tener un objeto adentro de otro suele ser mejor que heredar de él.
• Inmutabilidad simplifica concurrencia. Programación funcional ganó terreno.
• No todo es objeto. Funciones puras, dataclasses simples, módulos — a veces alcanzan.

Conclusión pragmática: usá OOP cuando el problema lo justifique. No metas clases para procesos lineales simples — un script con funciones es más legible.