Python · Lección 27 de 27 · FINAL

Proyecto integrador: Gestión de cartera

Este es el cierre del track de Python. Vas a construir un sistema completo de gestión de cartera de clientes bancarios que combina TODO lo que aprendiste: tipos, variables, condicionales, bucles, funciones, clases, archivos, excepciones y análisis de datos.

120–180 min Prerrequisitos: TODAS las lecciones anteriores

El proyecto

Objetivo

Construir un sistema de gestión de cartera que permita: crear clientes, evaluar su perfil crediticio, registrar operaciones, persistir datos en archivos y generar reportes de análisis. Cada ejercicio construye una pieza del sistema, y al final se integran todas.

Contexto laboral: este tipo de sistema es una versión simplificada de lo que corre en un banco o fintech. Un analista de datos trabaja con datos de clientes, scores, transacciones y reportes. Lo que construimos acá con Python puro, después lo harías a mayor escala con pandas, SQL y dashboards.

Conceptos integrados

Lección	Concepto	Se usa en...
03-04	Tipos y variables	Modelado de datos del cliente
06	Condicionales	Evaluación crediticia, clasificación
08-15	Estructuras de datos	Listas de dicts, anidación
16-17	Bucles	Procesamiento de registros
18-19	Funciones	Modularización del pipeline
20	Módulos stdlib	datetime, json, collections
23	Regex	Validación de CUIT
24	Archivos	Persistencia CSV/JSON
25	Excepciones	Manejo robusto de errores
26	Clases	Modelado OOP del sistema

Construcción paso a paso

Paso 1: El modelo de datos

Empezamos definiendo la clase Cliente con todos sus atributos y métodos de negocio.

paso_01_modelo.pyPython

from dataclasses import dataclass, field
from datetime import datetime
import re

@dataclass
class Cliente:
    nombre: str
    cuit: str
    score: int
    ingreso: float
    ciudad: str = "Buenos Aires"
    activo: bool = True
    fecha_alta: str = field(default_factory=lambda: datetime.now().strftime("%Y-%m-%d"))
    
    def __post_init__(self):
        """Validar datos al crear."""
        if not re.match(r"^\d{2}-\d{8}-\d$", self.cuit):
            raise ValueError(f"CUIT inválido: {self.cuit}")
        if not 0 <= self.score <= 999:
            raise ValueError(f"Score fuera de rango: {self.score}")
        if self.ingreso < 0:
            raise ValueError(f"Ingreso negativo: {self.ingreso}")
    
    @property
    def categoria(self):
        if self.score >= 800: return "Excelente"
        if self.score >= 700: return "Premium"
        if self.score >= 600: return "Estándar"
        return "Básico"
    
    def puede_credito(self, cuota):
        ratio = cuota / self.ingreso if self.ingreso > 0 else float('inf')
        return self.score >= 650 and ratio <= 0.35 and self.activo
    
    def to_dict(self):
        return {
            "nombre": self.nombre, "cuit": self.cuit, "score": self.score,
            "ingreso": self.ingreso, "ciudad": self.ciudad,
            "activo": self.activo, "fecha_alta": self.fecha_alta
        }

# Probar
c1 = Cliente("García", "20-30123456-9", 720, 350000)
print(f"{c1.nombre}: {c1.categoria}")
print(f"¿Crédito de $85K? {c1.puede_credito(85000)}")

# Validación automática
try:
    malo = Cliente("Test", "abc", 720, 100000)
except ValueError as e:
    print(f"\n❌ Validación: {e}")

Hacé clic en ▶ Ejecutar

Paso 2: La cartera con persistencia

Un gestor que maneja la colección de clientes con lectura/escritura a JSON.

paso_02_cartera.pyPython

import json
from collections import Counter, defaultdict
from dataclasses import dataclass, field
from datetime import datetime
import re

@dataclass
class Cliente:
    nombre: str
    cuit: str
    score: int
    ingreso: float
    ciudad: str = "Buenos Aires"
    activo: bool = True
    fecha_alta: str = field(default_factory=lambda: datetime.now().strftime("%Y-%m-%d"))
    
    def __post_init__(self):
        if not re.match(r"^\d{2}-\d{8}-\d$", self.cuit):
            raise ValueError(f"CUIT inválido: {self.cuit}")
    
    @property
    def categoria(self):
        if self.score >= 800: return "Excelente"
        if self.score >= 700: return "Premium"
        if self.score >= 600: return "Estándar"
        return "Básico"
    
    def to_dict(self):
        return {"nombre": self.nombre, "cuit": self.cuit, "score": self.score,
                "ingreso": self.ingreso, "ciudad": self.ciudad,
                "activo": self.activo, "fecha_alta": self.fecha_alta}

class Cartera:
    ARCHIVO = "cartera.json"
    
    def __init__(self):
        self.clientes = []
        self._cargar()
    
    def _cargar(self):
        try:
            with open(self.ARCHIVO, "r", encoding="utf-8") as f:
                datos = json.load(f)
            self.clientes = [Cliente(**d) for d in datos]
        except (FileNotFoundError, json.JSONDecodeError):
            self.clientes = []
    
    def _guardar(self):
        with open(self.ARCHIVO, "w", encoding="utf-8") as f:
            json.dump([c.to_dict() for c in self.clientes], f, indent=2, ensure_ascii=False)
    
    def agregar(self, cliente):
        if any(c.cuit == cliente.cuit for c in self.clientes):
            raise ValueError(f"CUIT {cliente.cuit} ya existe")
        self.clientes.append(cliente)
        self._guardar()
    
    def buscar(self, cuit):
        for c in self.clientes:
            if c.cuit == cuit:
                return c
        return None
    
    def total_saldos(self):
        return sum(c.ingreso for c in self.clientes)
    
    def por_ciudad(self):
        grupos = defaultdict(list)
        for c in self.clientes:
            grupos[c.ciudad].append(c)
        return dict(grupos)
    
    def reporte(self):
        print(f"{'═'*55}")
        print(f"  REPORTE DE CARTERA — {len(self.clientes)} clientes")
        print(f"{'═'*55}")
        for c in sorted(self.clientes, key=lambda x: x.score, reverse=True):
            emoji = "🟢" if c.activo else "🔴"
            print(f"  {emoji} {c.nombre:<14} {c.categoria:<10} Score:{c.score} ${c.ingreso:>10,}")
        print(f"{'─'*55}")
        cats = Counter(c.categoria for c in self.clientes)
        print(f"  Categorías: {dict(cats)}")
        print(f"  Ingreso total: ${self.total_saldos():,.0f}")
    
    def __len__(self):
        return len(self.clientes)

# Construir la cartera
cartera = Cartera()
cartera.agregar(Cliente("García", "20-30123456-9", 720, 350000))
cartera.agregar(Cliente("López", "27-28765432-1", 680, 250000, "Córdoba"))
cartera.agregar(Cliente("Pérez", "20-40123456-7", 810, 500000))
cartera.agregar(Cliente("Sosa", "23-25123456-3", 590, 180000, "Rosario"))
cartera.agregar(Cliente("Martínez", "20-35123456-5", 645, 280000, "Córdoba"))

cartera.reporte()

Hacé clic en ▶ Ejecutar

Paso 3: Análisis y generación de reporte de negocio

paso_03_analisis.pyPython

from collections import Counter, defaultdict
from dataclasses import dataclass, field
from datetime import datetime

@dataclass
class Cliente:
    nombre: str
    score: int
    ingreso: float
    ciudad: str
    activo: bool = True
    
    @property
    def categoria(self):
        if self.score >= 800: return "Excelente"
        if self.score >= 700: return "Premium"
        if self.score >= 600: return "Estándar"
        return "Básico"

# Cargar datos simulados
clientes = [
    Cliente("García", 720, 350000, "BsAs"),
    Cliente("López", 680, 250000, "Córdoba"),
    Cliente("Pérez", 810, 500000, "BsAs"),
    Cliente("Sosa", 590, 180000, "Rosario"),
    Cliente("Martínez", 645, 280000, "Córdoba"),
    Cliente("Fernández", 750, 420000, "BsAs"),
    Cliente("Luna", 520, 150000, "Mendoza"),
    Cliente("Rodríguez", 700, 310000, "BsAs", False),
]

# === ANÁLISIS ===
print(f"{'═'*50}")
print(f"  ANÁLISIS DE CARTERA — {datetime.now().strftime('%d/%m/%Y')}")
print(f"{'═'*50}")

# 1. Estadísticas generales
activos = [c for c in clientes if c.activo]
scores = [c.score for c in activos]
ingresos = [c.ingreso for c in activos]

print(f"\nEstadísticas generales:")
print(f"  Total clientes: {len(clientes)} ({len(activos)} activos)")
print(f"  Score promedio: {sum(scores)/len(scores):.0f}")
print(f"  Score máx/mín: {max(scores)}/{min(scores)}")
print(f"  Ingreso total: ${sum(ingresos):,.0f}")
print(f"  Ingreso promedio: ${sum(ingresos)/len(ingresos):,.0f}")

# 2. Distribución por categoría
print(f"\n📈 Distribución por categoría:")
cats = Counter(c.categoria for c in activos)
for cat, n in cats.most_common():
    barra = "█" * (n * 5)
    pct = n / len(activos) * 100
    print(f"  {cat:<12} {n} ({pct:4.0f}%) {barra}")

# 3. Análisis por ciudad
print(f"\n🏙️ Análisis por ciudad:")
por_ciudad = defaultdict(list)
for c in activos:
    por_ciudad[c.ciudad].append(c)

for ciudad, lista in sorted(por_ciudad.items()):
    ing_prom = sum(c.ingreso for c in lista) / len(lista)
    sc_prom = sum(c.score for c in lista) / len(lista)
    print(f"  {ciudad:<12} {len(lista)} clientes | Score prom: {sc_prom:.0f} | Ingreso prom: ${ing_prom:,.0f}")

# 4. Oportunidades de cross-sell
cuota_prueba = 80000
print(f"\n💰 Oportunidad crédito (cuota ${cuota_prueba:,}):")
elegibles = [c for c in activos if c.score >= 650 and cuota_prueba / c.ingreso <= 0.35]
print(f"  Elegibles: {len(elegibles)}/{len(activos)}")
for c in elegibles:
    ratio = cuota_prueba / c.ingreso * 100
    print(f"    {c.nombre} ({c.categoria}, ratio {ratio:.0f}%)")

print(f"\n{'═'*50}")

Hacé clic en ▶ Ejecutar

Referencia rápida del proyecto

Componente	Concepto Python	Archivo/Clase
Modelo de datos	`@dataclass`, validación, `@property`	`Cliente`
Colección	Lista de objetos, `__len__`	`Cartera`
Persistencia	`json.load/dump`, `with open`	`_cargar/_guardar`
Validación	`raise ValueError`, regex	`__post_init__`
Análisis	`Counter`, `defaultdict`, comprehensions	`reporte()`
Búsqueda	Iteración, `.get()`	`buscar()`

Ejercicios del proyecto

Nivel 1 · Básico

Ejercicio 1: Crear la clase Cliente

Creá un @dataclass Cliente con nombre, score e ingreso. Agregá @property categoria. Creá 2 instancias. Debe incluir Premium.

ejercicio_01.pyDebe incluir "Premium"

from dataclasses import dataclass

# Creá Cliente con @property categoria:

c = Cliente("García", 720, 350000)
print(f"{c.nombre}: {c.categoria}")

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 2: Lista de clientes con estadísticas

Creá 5 clientes, guardalos en lista, calculá score promedio e ingreso total. Debe incluir promedio.

ejercicio_02.pyDebe incluir "promedio"

from dataclasses import dataclass

@dataclass
class Cliente:
    nombre: str
    score: int
    ingreso: float

clientes = [
    Cliente("García", 720, 350000),
    Cliente("López", 680, 250000),
    Cliente("Pérez", 810, 500000),
    Cliente("Sosa", 590, 180000),
    Cliente("Martínez", 645, 280000),
]

# Calculá estadísticas:

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 3: Filtrar y ordenar

De la lista anterior, filtrá los que tienen score >= 650 y ordenalos por ingreso descendente. Debe incluir Pérez.

ejercicio_03.pyDebe incluir "Pérez"

from dataclasses import dataclass

@dataclass
class Cliente:
    nombre: str
    score: int
    ingreso: float

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

# Filtrá score >= 650 y ordená por ingreso desc:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 4: Validación con regex y excepciones

Agregá validación de CUIT en __post_init__. Probá con CUITs válidos e inválidos. Debe incluir inválido.

ejercicio_04.pyDebe incluir "inválido"

from dataclasses import dataclass
import re

@dataclass
class Cliente:
    nombre: str
    cuit: str
    score: int
    
    def __post_init__(self):
        pass  # validá CUIT con regex

# Probá:
for cuit in ["20-30123456-9", "abc-123", "27-28765432-1"]:
    try:
        c = Cliente("Test", cuit, 700)
        print(f"  ✅ {cuit}")
    except ValueError as e:
        print(f"  ❌ {e}")

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 5: Persistencia JSON

Creá funciones guardar_clientes(lista, archivo) y cargar_clientes(archivo) que serialicen/deserialicen a JSON. Debe incluir guardados.

ejercicio_05.pyDebe incluir "guardados"

import json

clientes = [
    {"nombre": "García", "score": 720, "ingreso": 350000},
    {"nombre": "López", "score": 680, "ingreso": 250000},
]

# Funciones guardar y cargar:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 6: Agrupar por categoría con Counter

Clasifica cada cliente en su categoría y contá cuántos hay en cada una con Counter. Debe incluir most_common.

ejercicio_06.pyDebe incluir "most_common"

from collections import Counter

scores = [720, 680, 810, 590, 645, 750, 520, 700]

def clasificar(score):
    if score >= 800: return "Excelente"
    if score >= 700: return "Premium"
    if score >= 600: return "Estándar"
    return "Básico"

# Contá categorías:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 7: Evaluación crediticia modular

Creá funciones de validación separadas: validar_edad(), validar_score(), validar_ratio(). Combinalas en evaluar(). Debe incluir APROBADO.

ejercicio_07.pyDebe incluir "APROBADO"

# Funciones de validación:

def evaluar(nombre, edad, score, ingreso, cuota):
    pass  # combiná las validaciones

# Probá:
resultado = evaluar("García", 35, 720, 350000, 85000)
print(resultado)

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 8: Cargar CSV crudo y procesar

Dado un CSV como string multilínea, parsealo, limpiá los datos, filtrá errores y generá estadísticas. Debe incluir procesados.

ejercicio_08.pyDebe incluir "procesados"

csv_data = """nombre,score,ingreso
García,720,$350,000
López,abc,$250,000
Pérez,810,$500,000
,590,$180,000
Martínez,645,"""

# Pipeline: parsear → limpiar → validar → estadísticas

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 9: Análisis por ciudad con defaultdict

Agrupá clientes por ciudad, calculá ingreso promedio y score promedio por ciudad. Debe incluir BsAs.

ejercicio_09.pyDebe incluir "BsAs"

from collections import defaultdict

clientes = [
    {"nombre": "García", "score": 720, "ingreso": 350000, "ciudad": "BsAs"},
    {"nombre": "López", "score": 680, "ingreso": 250000, "ciudad": "Córdoba"},
    {"nombre": "Pérez", "score": 810, "ingreso": 500000, "ciudad": "BsAs"},
    {"nombre": "Sosa", "score": 590, "ingreso": 180000, "ciudad": "Rosario"},
    {"nombre": "Martínez", "score": 645, "ingreso": 280000, "ciudad": "Córdoba"},
]

# Agrupá y analizá:

Hacé clic en ▶ Ejecutar

Nivel 4 · Desafío

Ejercicio 10: Sistema completo integrado

Construí el sistema completo: clase Cliente con validación, clase Cartera con agregar/buscar/reporte, persistencia JSON, manejo de errores. Cargá 5 clientes, generá reporte con estadísticas, categorías y oportunidades de cross-sell. Debe incluir SISTEMA COMPLETO.

ejercicio_10_desafio.pyDebe incluir "SISTEMA COMPLETO"

import json, re
from dataclasses import dataclass, field
from datetime import datetime
from collections import Counter, defaultdict

# Construí el sistema completo:

print("=== SISTEMA COMPLETO ===")

Hacé clic en ▶ Ejecutar

Resumen final del track Python

27 lecciones completadas — de "¿qué es Python?" hasta un sistema completo con clases, archivos y análisis.
Fundamentos: tipos, variables, operadores, condicionales, bucles, funciones (lecciones 1-19).
Estructuras: listas, tuplas, diccionarios, sets y sus métodos (lecciones 8-15).
Profesional: módulos, scope, regex, archivos, excepciones, OOP (lecciones 20-26).
Integración: este proyecto combina todo en un sistema real de gestión de datos.

🎉 ¡Felicitaciones! Completaste el track de Python. Ahora tenés las bases sólidas para el siguiente paso: SQL (para consultar bases de datos) y Data Analysis (para usar pandas, numpy, matplotlib y todo el ecosistema de análisis).

El código que escribiste en estas 27 lecciones — con funciones, clases, archivos y manejo de errores — es exactamente el tipo de código que vas a escribir como Data Analyst en un banco, fintech o consultora. La diferencia es la escala: en vez de 5 clientes, van a ser 5 millones. Para eso está pandas.

Próximos pasos: Track de SQL →

Hecho con ❤️ por Rodri Gonzalez