Python · Lección 26 de 27

Clases y objetos (intro)

La Programación Orientada a Objetos (OOP) te permite modelar conceptos del mundo real (clientes, cuentas, transacciones) como objetos con datos y comportamiento. Es el paradigma que usan pandas, scikit-learn y prácticamente todas las librerías de Python.

90–120 min Prerrequisitos: 18-19 Funciones, 25 Excepciones

Concepto teórico

¿Qué es una clase?

Una clase es un molde (template) para crear objetos. Define qué datos tiene (atributos) y qué puede hacer (métodos). Un objeto es una instancia concreta de esa clase — un caso particular con datos reales.

Analogía bancaria: la clase CuentaBancaria es el formulario de apertura de cuenta (el molde). Define que toda cuenta tiene titular, CBU, saldo y tipo. Un objeto es la cuenta real de García con su CBU específico y su saldo de $150,000. Del mismo molde podés crear miles de cuentas, cada una con datos distintos.

Sintaxis: class, init, self

class Cliente:
    def __init__(self, nombre, score, saldo=0):
        self.nombre = nombre    # atributo de instancia
        self.score = score
        self.saldo = saldo
    
    def es_premium(self):       # método
        return self.score >= 700
    
    def __str__(self):          # representación como string
        return f"Cliente({self.nombre}, score={self.score})"

# Crear instancias (objetos)
c1 = Cliente("García", 720, 150000)
c2 = Cliente("López", 680)
print(c1.nombre)        # "García"
print(c1.es_premium())  # True
print(c1)               # "Cliente(García, score=720)"

class NombreClase: — define la clase. PascalCase por convención.
__init__(self, ...) — el constructor. Se ejecuta automáticamente al crear un objeto. Recibe los datos iniciales y los guarda como atributos.
self — referencia al objeto actual. SIEMPRE es el primer parámetro de todo método. Permite acceder a los atributos del objeto.
self.atributo = valor — crea un atributo de instancia (cada objeto tiene su propia copia).

¿Por qué self? Porque cuando llamás c1.es_premium(), Python internamente lo traduce a Cliente.es_premium(c1). self es el objeto sobre el que estás operando. Sin self, el método no sabría a qué cuenta referirse.

Métodos especiales (dunder methods)

Python tiene métodos "mágicos" que empiezan y terminan con doble guión bajo (__):

Método	Cuándo se llama	Ejemplo
`__init__`	Al crear el objeto	`Cliente("García", 720)`
`__str__`	`print(obj)` o `str(obj)`	`print(c1)`
`__repr__`	Representación técnica	En el REPL o en listas
`__len__`	`len(obj)`	`len(mi_cartera)`
`__eq__`	`obj1 == obj2`	Comparar igualdad

Herencia básica

La herencia permite crear una clase nueva basada en otra existente. La clase hija hereda todos los atributos y métodos de la padre y puede agregar o sobreescribir funcionalidad:

class ClientePremium(Cliente):  # hereda de Cliente
    def __init__(self, nombre, score, saldo, beneficio):
        super().__init__(nombre, score, saldo)  # llamar al padre
        self.beneficio = beneficio
    
    def tasa_preferencial(self):  # método nuevo
        return 0.035

dataclass — clases de datos rápidas

Desde Python 3.7, @dataclass genera automáticamente __init__, __repr__, __eq__ y más. Ideal para clases que son básicamente "contenedores de datos":

from dataclasses import dataclass

@dataclass
class Transaccion:
    tipo: str
    monto: float
    cuenta: str
    fecha: str = "2025-01-01"  # default

¿Cuándo clases vs funciones? Usá funciones cuando tenés lógica que recibe datos y devuelve resultados. Usá clases cuando tenés un "objeto" con estado (datos que cambian) y comportamiento (métodos). Si solo necesitás agrupar datos sin comportamiento, usá dataclass o un diccionario.

En librerías de Python: un DataFrame de pandas es un objeto de la clase pd.DataFrame. .head(), .describe(), .groupby() son métodos. .shape, .columns son atributos. Un modelo de scikit-learn (RandomForestClassifier()) es un objeto con métodos .fit() y .predict(). Entender OOP te permite usar estas librerías con confianza.

Ejemplos explicados paso a paso

Ejemplo 1: Clase CuentaBancaria

ejemplo_01_cuenta.pyPython

class CuentaBancaria:
    """Representa una cuenta bancaria con operaciones básicas."""
    
    def __init__(self, titular, saldo_inicial=0):
        self.titular = titular
        self.saldo = saldo_inicial
        self.movimientos = []
    
    def depositar(self, monto):
        if monto <= 0:
            raise ValueError("Monto debe ser positivo")
        self.saldo += monto
        self.movimientos.append(f"+${monto:,}")
        return self.saldo
    
    def extraer(self, monto):
        if monto > self.saldo:
            raise ValueError(f"Saldo insuficiente (${self.saldo:,})")
        self.saldo -= monto
        self.movimientos.append(f"-${monto:,}")
        return self.saldo
    
    def __str__(self):
        return f"Cuenta de {self.titular}: ${self.saldo:,}"

# Crear y usar
cuenta = CuentaBancaria("García", 100000)
print(cuenta)

cuenta.depositar(50000)
cuenta.extraer(30000)
cuenta.depositar(80000)
print(f"\nDespués de operaciones: {cuenta}")
print(f"Movimientos: {cuenta.movimientos}")

# Intentar extraer más del saldo
try:
    cuenta.extraer(500000)
except ValueError as e:
    print(f"\n❌ {e}")

Hacé clic en ▶ Ejecutar

Ejemplo 2: Clase Cliente con métodos de negocio

ejemplo_02_cliente.pyPython

class Cliente:
    SCORE_PREMIUM = 700
    
    def __init__(self, nombre, score, ingreso, ciudad="BsAs"):
        self.nombre = nombre
        self.score = score
        self.ingreso = ingreso
        self.ciudad = ciudad
    
    def es_premium(self):
        return self.score >= self.SCORE_PREMIUM
    
    def categoria(self):
        if self.score >= 800: return "Excelente"
        if self.score >= 700: return "Bueno"
        if self.score >= 600: return "Regular"
        return "Bajo"
    
    def puede_tomar_credito(self, cuota):
        ratio = cuota / self.ingreso
        return ratio <= 0.35 and self.score >= 650
    
    def __str__(self):
        emoji = "⭐" if self.es_premium() else "  "
        return f"{emoji} {self.nombre} | {self.categoria()} ({self.score}) | ${self.ingreso:,}"

# Crear varios clientes
clientes = [
    Cliente("García", 720, 350000),
    Cliente("López", 680, 250000, "Córdoba"),
    Cliente("Pérez", 810, 500000),
    Cliente("Sosa", 590, 180000),
]

print("=== Cartera ===")
for c in clientes:
    print(f"  {c}")

# Filtrar premium
premium = [c for c in clientes if c.es_premium()]
print(f"\nPremium: {[c.nombre for c in premium]}")

# Evaluar crédito
cuota = 85000
print(f"\n¿Puede tomar cuota ${cuota:,}?")
for c in clientes:
    resultado = "✅" if c.puede_tomar_credito(cuota) else "❌"
    print(f"  {resultado} {c.nombre}")

Hacé clic en ▶ Ejecutar

Ejemplo 3: Herencia — ClientePremium

ejemplo_03_herencia.pyPython

class Cuenta:
    def __init__(self, titular, saldo=0):
        self.titular = titular
        self.saldo = saldo
    
    def depositar(self, monto):
        self.saldo += monto
    
    def __str__(self):
        return f"{self.titular}: ${self.saldo:,}"

class CuentaPremium(Cuenta):
    """Cuenta con beneficios adicionales."""
    
    def __init__(self, titular, saldo=0, tasa_rendimiento=0.003):
        super().__init__(titular, saldo)  # llamar al __init__ del padre
        self.tasa_rendimiento = tasa_rendimiento
    
    def aplicar_rendimiento(self):
        interes = self.saldo * self.tasa_rendimiento
        self.saldo += interes
        return interes
    
    def __str__(self):
        return f"⭐ {super().__str__()} (Premium, TEM: {self.tasa_rendimiento:.1%})"

# Cuenta normal vs Premium
normal = Cuenta("López", 100000)
premium = CuentaPremium("García", 500000, 0.005)

print(f"Normal: {normal}")
print(f"Premium: {premium}")

# Solo la premium tiene rendimiento
interes = premium.aplicar_rendimiento()
print(f"\nRendimiento: +${interes:,}")
print(f"Nuevo saldo: {premium}")

# isinstance: verificar tipo
print(f"\n¿premium es Cuenta? {isinstance(premium, Cuenta)}")       # True
print(f"¿premium es CuentaPremium? {isinstance(premium, CuentaPremium)}")  # True
print(f"¿normal es CuentaPremium? {isinstance(normal, CuentaPremium)}")    # False

Hacé clic en ▶ Ejecutar

Ejemplo 4: dataclass — clases de datos rápidas

ejemplo_04_dataclass.pyPython

from dataclasses import dataclass, field

@dataclass
class Transaccion:
    tipo: str
    monto: float
    cuenta: str
    fecha: str = "2025-03-15"

# Se crea sin escribir __init__ ni __repr__
t1 = Transaccion("deposito", 50000, "001-12345")
t2 = Transaccion("extraccion", 20000, "001-12345")
t3 = Transaccion("deposito", 80000, "001-12345", "2025-03-16")

print(t1)  # __repr__ automático
print(t2)

# Comparación automática (__eq__)
t4 = Transaccion("deposito", 50000, "001-12345")
print(f"\n¿t1 == t4? {t1 == t4}")  # True (mismos datos)

# Usar en lista
transacciones = [t1, t2, t3]
total_depositos = sum(t.monto for t in transacciones if t.tipo == "deposito")
print(f"\nTotal depósitos: ${total_depositos:,}")

# dataclass con campo calculado
@dataclass
class ClienteData:
    nombre: str
    score: int
    saldo: float
    
    @property
    def categoria(self):
        if self.score >= 700: return "Premium"
        return "Estándar"

c = ClienteData("García", 720, 150000)
print(f"\n{c.nombre}: {c.categoria}")

Hacé clic en ▶ Ejecutar

Ejemplo 5: Clase Cartera — colección de cuentas

ejemplo_05_cartera.pyPython

class Cartera:
    def __init__(self, nombre):
        self.nombre = nombre
        self.cuentas = []
    
    def agregar(self, titular, saldo):
        self.cuentas.append({"titular": titular, "saldo": saldo})
    
    def total(self):
        return sum(c["saldo"] for c in self.cuentas)
    
    def promedio(self):
        if not self.cuentas:
            return 0
        return self.total() / len(self.cuentas)
    
    def top(self, n=3):
        return sorted(self.cuentas, key=lambda c: c["saldo"], reverse=True)[:n]
    
    def __len__(self):
        return len(self.cuentas)
    
    def __str__(self):
        return f"Cartera '{self.nombre}': {len(self)} cuentas, ${self.total():,}"

# Usar
cartera = Cartera("Sucursal Centro")
cartera.agregar("García", 150000)
cartera.agregar("López", 320000)
cartera.agregar("Martínez", 45000)
cartera.agregar("Pérez", 890000)
cartera.agregar("Fernández", 72000)

print(cartera)
print(f"Promedio: ${cartera.promedio():,.0f}")
print(f"len(): {len(cartera)}")

print(f"\nTop 3:")
for c in cartera.top(3):
    print(f"  {c['titular']}: ${c['saldo']:,}")

Hacé clic en ▶ Ejecutar

Referencia rápida

Concepto	Sintaxis	Significado
Definir clase	`class MiClase:`	PascalCase por convención
Constructor	`def __init__(self, ...):`	Inicializa atributos
Atributo	`self.nombre = valor`	Dato de cada instancia
Método	`def metodo(self, ...):`	Función del objeto
Instanciar	`obj = MiClase(args)`	Crear un objeto
Herencia	`class Hija(Padre):`	Hija hereda de Padre
super()	`super().__init__(...)`	Llamar al padre
__str__	`def __str__(self):`	Para print(obj)
__len__	`def __len__(self):`	Para len(obj)
@dataclass	`@dataclass class X:`	Auto-genera __init__/__repr__/__eq__
@property	`@property def x(self):`	Atributo calculado

Ejercicios

Nivel 1 · Básico

Ejercicio 1: Clase Producto

Creá una clase Producto con nombre y precio. Instanciá un producto e imprimilo. Debe incluir Notebook.

ejercicio_01.pyDebe incluir "Notebook"

# Definí clase Producto:

p = Producto("Notebook", 920000)
print(f"{p.nombre}: ${p.precio:,}")

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 2: Método y str

Agregá un método con_iva() que devuelva precio*1.21, y __str__ que muestre nombre y precio. Debe incluir 1113200.

ejercicio_02.pyDebe incluir "1113200"

# Clase Producto con con_iva() y __str__:

p = Producto("Notebook", 920000)
print(p)
print(f"Con IVA: ${p.con_iva():,.0f}")

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 3: Clase CuentaSimple

Creá CuentaSimple con titular y saldo. Métodos depositar() y extraer(). Debe incluir 120000.

ejercicio_03.pyDebe incluir "120000"

# Definí CuentaSimple:

c = CuentaSimple("García", 100000)
c.depositar(50000)
c.extraer(30000)
print(f"Saldo: ${c.saldo:,}")

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 4: Lista de objetos

Creá 4 instancias de Cliente(nombre, score), guardalas en lista, filtrá premium (score>=700) e imprimí. Debe incluir Premium.

ejercicio_04.pyDebe incluir "Premium"

class Cliente:
    def __init__(self, nombre, score):
        self.nombre = nombre
        self.score = score
    def es_premium(self):
        return self.score >= 700

clientes = [
    Cliente("García", 720), Cliente("López", 680),
    Cliente("Pérez", 810), Cliente("Sosa", 590),
]

# Filtrá premium e imprimí:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 5: Herencia básica

Creá CuentaAhorro(Cuenta) que herede de una Cuenta base y agregue método aplicar_interes(tasa). Debe incluir 103000.

ejercicio_05.pyDebe incluir "103000"

class Cuenta:
    def __init__(self, titular, saldo=0):
        self.titular = titular
        self.saldo = saldo

# Creá CuentaAhorro que herede:

ca = CuentaAhorro("García", 100000)
ca.aplicar_interes(0.03)
print(f"Saldo: ${ca.saldo:,}")

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 6: dataclass

Creá un @dataclass Cotizacion con ticker, precio, variacion. Creá 3 instancias e imprimí la de mayor precio. Debe incluir YPF.

ejercicio_06.pyDebe incluir "YPF"

from dataclasses import dataclass

# Definí el dataclass:

cots = [
    Cotizacion("GGAL", 5200, 1.5),
    Cotizacion("YPF", 28000, -0.8),
    Cotizacion("PAMP", 3100, 2.1),
]
top = max(cots, key=lambda c: c.precio)
print(f"Mayor precio: {top}")

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 7: Cuenta con validación y excepciones

Agregá validación al extraer(): si el monto > saldo, lanzá ValueError. Probá con try/except. Debe incluir insuficiente.

ejercicio_07.pyDebe incluir "insuficiente"

# Clase con validación:

c = CuentaSegura("García", 50000)
try:
    c.extraer(100000)
except ValueError as e:
    print(f"Error: {e}")

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 8: len y str custom

Creá clase Cartera que guarde cuentas en una lista. Implementá __len__ y __str__. Debe incluir 3 cuentas.

ejercicio_08.pyDebe incluir "3 cuentas"

# Creá Cartera con __len__ y __str__:

c = Cartera()
c.agregar("García", 150000)
c.agregar("López", 320000)
c.agregar("Pérez", 890000)
print(c)
print(f"len: {len(c)}")

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 9: @property para campos calculados

Creá Empleado con nombre, sueldo_bruto y un @property sueldo_neto que descuente 31%. Debe incluir neto.

ejercicio_09.pyDebe incluir "neto"

# Creá Empleado con @property:

e = Empleado("García", 950000)
print(f"Bruto: ${e.sueldo_bruto:,}")
print(f"neto: ${e.sueldo_neto:,.0f}")

Hacé clic en ▶ Ejecutar

Nivel 4 · Desafío

Ejercicio 10: Sistema bancario completo con OOP

Creá clases Banco, Cliente y Cuenta. El banco tiene clientes, cada cliente tiene cuentas. Implementá: agregar cliente, abrir cuenta, depositar, y un reporte general. Debe incluir BANCO.

ejercicio_10_desafio.pyDebe incluir "BANCO"

# Diseñá el sistema con 3 clases:

# Probá:
# banco = Banco("Galicia")
# banco.agregar_cliente("García")
# banco.abrir_cuenta("García", 150000)
# banco.reporte()
print("=== BANCO ===")

Hacé clic en ▶ Ejecutar

Resumen y conexión

Una clase es un molde (class), un objeto es una instancia con datos reales.
__init__ inicializa atributos. self referencia al objeto actual.
__str__ define cómo se muestra con print(). __len__ para len().
Herencia (class Hija(Padre)) permite reutilizar y extender. super() llama al padre.
@dataclass genera constructores y repr automáticos para clases de datos.
Usá clases cuando tenés objetos con estado + comportamiento. Funciones para lógica pura.

En la última lección (27 · Proyecto integrador) vas a combinar TODO lo aprendido en un proyecto completo de gestión de datos.

Recursos: Python docs — Classes · dataclasses

Hecho con ❤️ por Rodri Gonzalez

Clases y objetos (intro)

Concepto teórico

¿Qué es una clase?

Sintaxis: class, __init__, self

Métodos especiales (dunder methods)

Herencia básica

dataclass — clases de datos rápidas

Ejemplos explicados paso a paso

Ejemplo 1: Clase CuentaBancaria

Ejemplo 2: Clase Cliente con métodos de negocio

Ejemplo 3: Herencia — ClientePremium

Ejemplo 4: dataclass — clases de datos rápidas

Ejemplo 5: Clase Cartera — colección de cuentas

Referencia rápida

Ejercicios

Ejercicio 1: Clase Producto

Ejercicio 2: Método y __str__

Ejercicio 3: Clase CuentaSimple

Ejercicio 4: Lista de objetos

Ejercicio 5: Herencia básica

Ejercicio 6: dataclass

Ejercicio 7: Cuenta con validación y excepciones

Ejercicio 8: __len__ y __str__ custom

Ejercicio 9: @property para campos calculados

Ejercicio 10: Sistema bancario completo con OOP

Resumen y conexión

Sintaxis: class, init, self

Ejercicio 2: Método y str

Ejercicio 8: len y str custom