Programación orientada a objetos: clases y encapsulamiento

class Producto:
    def __init__(self, codigo, nombre, precio, stock=0):
        if precio <= 0:
            raise ValueError("el precio debe ser positivo")
        self.codigo = codigo
        self.nombre = nombre
        self.precio = precio
        self._stock = stock

    @property
    def stock(self):
        return self._stock

    def vender(self, cantidad):
        if cantidad <= 0:
            raise ValueError("cantidad inválida")
        if cantidad > self._stock:
            raise ValueError(f"solo hay {self._stock} unidades de {self.nombre}")
        self._stock -= cantidad
        return cantidad * self.precio

    def reponer(self, cantidad):
        if cantidad <= 0:
            raise ValueError("cantidad inválida")
        self._stock += cantidad

    def necesita_reorden(self, minimo=10):
        return self._stock < minimo


arroz = Producto("B07", "Arroz 5 lb", 4.25, 12)
print("Venta:", arroz.vender(5))
print("¿Reordenar?", arroz.necesita_reorden())
arroz.reponer(20)
print("Stock:", arroz.stock)
assert arroz.stock == 27
try:
    arroz.vender(100)
except ValueError as e:
    print("Rechazado:", e)

Venta: 21.25
¿Reordenar? True
Stock: 27
Rechazado: solo hay 27 unidades de Arroz 5 lb

class Estudiante:
    def __init__(self, nombre, carnet):
        self.nombre = nombre
        self.carnet = carnet
        self._notas = []

    def agregar_nota(self, nota):
        if not 0 <= nota <= 10:
            raise ValueError(f"nota fuera de rango: {nota}")
        self._notas.append(nota)

    def promedio(self):
        if not self._notas:
            return 0
        return round(sum(self._notas) / len(self._notas), 2)

    def aprobado(self, minimo=6):
        return self.promedio() >= minimo

    def __str__(self):
        estado = "aprobado" if self.aprobado() else "en riesgo"
        return f"{self.carnet} {self.nombre}: {self.promedio()} ({estado})"


e = Estudiante("Carla", "2026-0412")
for n in [7.5, 5.0, 8.0]:
    e.agregar_nota(n)
print(e)
try:
    e.agregar_nota(11)
except ValueError as err:
    print("Error:", err)

2026-0412 Carla: 6.83 (aprobado)
Error: nota fuera de rango: 11

"aprobado" if condicion else "en riesgo" es una expresión condicional: un if/else en una sola línea que produce un valor.

1. Atributo de clase: saldo = 0 fuera de __init__ lo comparten todas las cuentas; el estado de cada cuenta debe ir en self.
2. titular = titular asigna a una variable local que desaparece; debe ser self.titular.
3. depositar(monto) no recibe self: al llamar c.depositar(50), Python pasa dos argumentos y da TypeError. Además saldo dentro es local.
4. retirar no valida: permite saldo negativo e imprime “exitoso” siempre.

class Cuenta:
    def __init__(self, titular):
        self.titular = titular          # (2) guardar en el objeto
        self._saldo = 0                 # (1) estado por instancia

    @property
    def saldo(self):
        return self._saldo

    def depositar(self, monto):         # (3) self como primer parámetro
        if monto <= 0:
            raise ValueError("monto inválido")
        self._saldo += monto

    def retirar(self, monto):
        if monto <= 0 or monto > self._saldo:    # (4) validar antes de cambiar
            raise ValueError("retiro no permitido")
        self._saldo -= monto


c = Cuenta("Ana")
c.depositar(100)
c.retirar(40)
print(c.titular, c.saldo)

Ana 60