Python · Lección 20 de 27

Módulos de la biblioteca estándar

Python viene con "baterías incluidas": una colección enorme de módulos listos para usar sin instalar nada. Esta lección cubre los 6 que vas a usar todos los días como analista: math, datetime, random, json, os y collections.

90–120 min Prerrequisitos: 18 Funciones básicas

Concepto teórico

¿Qué es un módulo y cómo se importa?

Un módulo es un archivo .py que contiene funciones, clases y variables que podés reutilizar. La biblioteca estándar (stdlib) son los módulos que vienen con Python — no necesitás instalar nada con pip. Hay tres formas de importar:

import math                    # importar el módulo completo → math.sqrt()
from math import sqrt, pi     # importar solo lo que necesitás → sqrt()
from math import sqrt as raiz # importar con alias → raiz()

Convención PEP 8: los imports van SIEMPRE al inicio del archivo, uno por línea, agrupados en 3 bloques: (1) stdlib, (2) terceros (pandas, numpy), (3) propios. Separados por una línea en blanco.

math — funciones matemáticas

Función	Qué hace	Ejemplo	Resultado
`math.sqrt(x)`	Raíz cuadrada	`sqrt(144)`	`12.0`
`math.ceil(x)`	Redondeo hacia arriba	`ceil(3.1)`	`4`
`math.floor(x)`	Redondeo hacia abajo	`floor(3.9)`	`3`
`math.log(x)`	Logaritmo natural (ln)	`log(math.e)`	`1.0`
`math.log10(x)`	Logaritmo base 10	`log10(1000)`	`3.0`
`math.pi`	Constante π	`math.pi`	`3.14159...`
`math.e`	Constante e (Euler)	`math.e`	`2.71828...`
`math.pow(x, y)`	x elevado a y (float)	`pow(2, 10)`	`1024.0`
`math.factorial(n)`	Factorial de n	`factorial(5)`	`120`

Uso en finanzas: math.log() se usa para calcular retornos logarítmicos en series financieras: retorno = math.log(precio_hoy / precio_ayer). math.ceil() sirve para redondear cuotas hacia arriba (nunca le cobrás de menos al banco). math.sqrt() aparece en cálculos de volatilidad y desvío estándar.

datetime — fechas y horas

El módulo datetime es fundamental para análisis de datos. Los campos de fecha aparecen en CADA dataset (fecha de transacción, fecha de alta, fecha de vencimiento). Sus clases principales:

datetime.datetime — fecha + hora: 2025-03-15 10:30:00
datetime.date — solo fecha: 2025-03-15
datetime.timedelta — diferencia entre fechas: 30 days

Los métodos clave: .now() (fecha actual), .strftime(formato) (fecha → string), .strptime(string, formato) (string → fecha), y aritmética con timedelta.

Error común: confundir strftime (format → convierte fecha a string) con strptime (parse → convierte string a fecha). El truco: format tiene f, parse tiene p.

random — números aleatorios

Útil para simulaciones, muestreo, y generación de datos de prueba:

Función	Qué hace	Ejemplo
`random.randint(a, b)`	Entero aleatorio entre a y b (incluidos)	`randint(1, 100)`
`random.random()`	Float entre 0.0 y 1.0	`random()`
`random.uniform(a, b)`	Float entre a y b	`uniform(100, 200)`
`random.choice(seq)`	Elemento aleatorio de una secuencia	`choice(["A","B","C"])`
`random.sample(seq, k)`	k elementos sin repetición	`sample(range(100), 5)`
`random.shuffle(lista)`	Mezcla in-place	`shuffle(mi_lista)`
`random.seed(n)`	Fija la semilla (reproducibilidad)	`seed(42)`

Reproducibilidad con seed: si fijás random.seed(42) antes de generar números, SIEMPRE obtenés la misma secuencia. Esto es crítico en ciencia de datos: si tu análisis depende de aleatoriedad, necesitás que sea reproducible. En sklearn: train_test_split(X, y, random_state=42) usa este mismo principio.

json — leer y escribir JSON

JSON (JavaScript Object Notation) es el formato estándar de las APIs web. En Python, JSON se mapea directamente a diccionarios y listas:

json.dumps(dict) — dict/list → string JSON (con indent=2 para formato legible)
json.loads(string) — string JSON → dict/list
json.dump(dict, archivo) — dict → archivo JSON
json.load(archivo) — archivo JSON → dict

os — interacción con el sistema operativo

Para manejar archivos, carpetas y rutas. Los más usados: os.path.exists(), os.listdir(), os.getcwd(), os.path.join(), os.makedirs().

collections — estructuras de datos especializadas

Ya viste Counter, defaultdict y namedtuple. Son las herramientas de collections que usás constantemente en análisis de datos.

Ejemplos explicados paso a paso

Ejemplo 1: math para cálculos financieros

ejemplo_01_math.pyPython

import math

# Raíz cuadrada — volatilidad anualizada
varianza_diaria = 0.0004
vol_diaria = math.sqrt(varianza_diaria)
vol_anual = vol_diaria * math.sqrt(252)  # 252 días hábiles
print(f"Volatilidad diaria: {vol_diaria:.4f}")
print(f"Volatilidad anual: {vol_anual:.2%}")

# Redondeo bancario: ceil para cuotas (nunca cobrar de menos)
monto = 157333.33
print(f"\nCuota exacta: ${monto:,.2f}")
print(f"ceil: ${math.ceil(monto):,}")     # 157334
print(f"floor: ${math.floor(monto):,}")   # 157333
print(f"round: ${round(monto):,}")        # 157333

# Logaritmo — retorno logarítmico
precio_ayer = 5200
precio_hoy = 5350
retorno_log = math.log(precio_hoy / precio_ayer)
print(f"\nGGAL: ${precio_ayer:,} → ${precio_hoy:,}")
print(f"Retorno log: {retorno_log:.4f} ({retorno_log*100:.2f}%)")

# Factorial y combinatoria
n, k = 10, 3
combinaciones = math.factorial(n) // (math.factorial(k) * math.factorial(n - k))
print(f"\nC({n},{k}) = {combinaciones} combinaciones posibles")

Hacé clic en ▶ Ejecutar

Ejemplo 2: datetime — fechas en el mundo real

ejemplo_02_datetime.pyPython

from datetime import datetime, date, timedelta

# Fecha y hora actual
ahora = datetime.now()
print(f"Ahora: {ahora}")
print(f"Formateado: {ahora.strftime('%d/%m/%Y %H:%M')}")
print(f"Solo fecha: {ahora.date()}")
print(f"Año: {ahora.year}, Mes: {ahora.month}, Día: {ahora.day}")

# Parsear fecha desde string (formato argentino)
fecha_str = "15/01/2025"
fecha = datetime.strptime(fecha_str, "%d/%m/%Y")
print(f"\nParseado: '{fecha_str}' → {fecha}")

# Aritmética de fechas con timedelta
vencimiento = fecha + timedelta(days=30)
print(f"Fecha + 30 días: {vencimiento.strftime('%d/%m/%Y')}")

# Diferencia entre fechas
alta = date(2020, 3, 15)
hoy = date.today()
antiguedad = hoy - alta
print(f"\nAlta: {alta}")
print(f"Antigüedad: {antiguedad.days} días ({antiguedad.days // 365} años)")

# Vencimientos de cuotas
print(f"\nVencimientos mensuales:")
fecha_base = date(2025, 1, 15)
for i in range(1, 7):
    venc = fecha_base + timedelta(days=30 * i)
    print(f"  Cuota {i}: {venc.strftime('%d/%m/%Y')}")

Hacé clic en ▶ Ejecutar

Ejemplo 3: random — simulaciones y muestreo

ejemplo_03_random.pyPython

import random

# Fijar semilla para reproducibilidad
random.seed(42)

# Generar datos de prueba (simulación de clientes)
nombres = ["García", "López", "Martínez", "Pérez", "Fernández",
           "Sosa", "Luna", "Rodríguez", "Díaz", "Torres"]
ciudades = ["BsAs", "Córdoba", "Rosario", "Mendoza", "Tucumán"]

clientes = []
for _ in range(8):
    cliente = {
        "nombre": random.choice(nombres),
        "ciudad": random.choice(ciudades),
        "score": random.randint(400, 900),
        "saldo": round(random.uniform(10000, 500000), 2),
    }
    clientes.append(cliente)

print("=== Clientes simulados ===")
for c in clientes:
    print(f"  {c['nombre']:<12} {c['ciudad']:<10} Score:{c['score']} ${c['saldo']:>10,.0f}")

# Muestreo: seleccionar 3 clientes al azar para auditoría
muestra = random.sample(clientes, 3)
print(f"\nMuestra para auditoría:")
for c in muestra:
    print(f"  {c['nombre']}")

# Simulación Monte Carlo simplificada: retornos de inversión
random.seed(123)
capital = 100000
retornos = [random.gauss(0.005, 0.03) for _ in range(12)]  # media 0.5%, desvío 3%
saldo = capital
for i, r in enumerate(retornos, 1):
    saldo *= (1 + r)
print(f"\nSimulación 12 meses: ${capital:,} → ${saldo:,.0f} ({(saldo/capital-1)*100:+.1f}%)")

Hacé clic en ▶ Ejecutar

Ejemplo 4: json — serializar y parsear datos

ejemplo_04_json.pyPython

import json

# Dict → JSON string
cliente = {
    "nombre": "García",
    "edad": 35,
    "score": 720,
    "activo": True,
    "productos": ["Cuenta", "Tarjeta"],
    "saldo": None  # None → null en JSON
}

# Serializar (dict → string JSON)
json_str = json.dumps(cliente, indent=2, ensure_ascii=False)
print("=== Dict → JSON ===")
print(json_str)

# Deserializar (string JSON → dict)
json_input = '{"ticker": "GGAL", "precio": 5200, "variacion": -1.5}'
datos = json.loads(json_input)
print(f"\n=== JSON → Dict ===")
print(f"Ticker: {datos['ticker']}")
print(f"Precio: ${datos['precio']:,}")
print(f"Tipo: {type(datos)}")

# Lista de dicts → JSON (como una API devolvería)
cartera = [
    {"ticker": "GGAL", "cantidad": 100, "precio": 5200},
    {"ticker": "YPF", "cantidad": 50, "precio": 28000},
    {"ticker": "PAMP", "cantidad": 200, "precio": 3100},
]
print(f"\n=== Cartera como JSON ===")
print(json.dumps(cartera, indent=2))

# Calcular valor total
total = sum(a["cantidad"] * a["precio"] for a in cartera)
print(f"\nValor total cartera: ${total:,}")

Hacé clic en ▶ Ejecutar

Ejemplo 5: os y collections combinados

ejemplo_05_os_collections.pyPython

import os
from collections import Counter, defaultdict, namedtuple

# os: información del sistema
print(f"Directorio actual: {os.getcwd()}")
print(f"Separador de rutas: '{os.sep}'")

# os.path: construir rutas de forma portable
ruta = os.path.join("datos", "clientes", "2025", "q1.csv")
print(f"Ruta construida: {ruta}")
print(f"Nombre archivo: {os.path.basename(ruta)}")
print(f"Directorio: {os.path.dirname(ruta)}")
print(f"¿Extensión? {os.path.splitext(ruta)}")

# Counter: contar frecuencias (repaso)
transacciones = ["compra", "venta", "compra", "compra", "venta",
                 "transferencia", "compra", "venta"]
freq = Counter(transacciones)
print(f"\nFrecuencias: {dict(freq)}")
print(f"Top 2: {freq.most_common(2)}")

# defaultdict: agrupar (repaso)
ops = [("García", 50000), ("López", 30000), ("García", 45000),
       ("López", 60000), ("Pérez", 80000)]
por_cliente = defaultdict(list)
for nombre, monto in ops:
    por_cliente[nombre].append(monto)
print(f"\nPor cliente: {dict(por_cliente)}")

# namedtuple: registros legibles
Cotizacion = namedtuple("Cotizacion", ["ticker", "precio", "variacion"])
ggal = Cotizacion("GGAL", 5200, -1.5)
print(f"\n{ggal.ticker}: ${ggal.precio:,} ({ggal.variacion:+.1f}%)")

Hacé clic en ▶ Ejecutar

Referencia rápida

Módulo	Funciones clave	Uso principal
`math`	`sqrt ceil floor log pi e factorial`	Cálculos matemáticos y financieros
`datetime`	`now strftime strptime timedelta`	Fechas, vencimientos, antigüedad
`random`	`randint choice sample seed gauss`	Simulaciones, muestreo, datos de prueba
`json`	`dumps loads dump load`	Serializar/parsear datos JSON/APIs
`os`	`path.join listdir getcwd makedirs`	Archivos, rutas, sistema
`collections`	`Counter defaultdict namedtuple`	Conteo, agrupación, registros

Formato datetime	Significado	Ejemplo
`%d`	Día (01-31)	`15`
`%m`	Mes (01-12)	`03`
`%Y`	Año 4 dígitos	`2025`
`%H`	Hora 24h	`14`
`%M`	Minutos	`30`
`%A`	Día de la semana	`Saturday`

Ejercicios

Nivel 1 · Básico

Ejercicio 1: math.ceil para cuotas

Un préstamo de $157,000 se divide en 6 cuotas. Usá math.ceil() para redondear la cuota hacia arriba. Debe incluir 26167.

ejercicio_01.pyDebe incluir "26167"

import math
capital = 157000
cuotas = 6

# Calculá y redondeá:

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 2: Fecha actual formateada

Imprimí la fecha actual en formato argentino dd/mm/yyyy usando strftime. Debe incluir /.

ejercicio_02.pyDebe incluir "/"

from datetime import datetime

# Imprimí fecha actual dd/mm/yyyy:

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 3: random.choice

Usá random.seed(42) y random.choice() para elegir un ticker de ["GGAL","YPF","PAMP","MELI"]. Imprimí el elegido. Debe incluir el nombre del ticker.

ejercicio_03.pyReproducible con seed(42)

import random
random.seed(42)
tickers = ["GGAL", "YPF", "PAMP", "MELI"]

# Elegí uno al azar:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 4: Calcular antigüedad en días

Un cliente se dio de alta el "15/03/2020". Parseá la fecha con strptime, calculá los días de antigüedad respecto a hoy e imprimí. Debe incluir días.

ejercicio_04.pyDebe incluir "días"

from datetime import datetime

fecha_alta_str = "15/03/2020"

# Parseá y calculá antigüedad:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 5: json.dumps con formato

Creá un dict de cotización (ticker, precio, volumen, fecha) y convertilo a JSON con indent=2. Debe incluir "ticker" (con comillas, formato JSON).

ejercicio_05.pyDebe incluir "ticker"

import json

cotizacion = {
    "ticker": "GGAL",
    # completá
}

# Convertí a JSON e imprimí:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 6: Generar vencimientos mensuales

Desde date(2025, 1, 10), generá 6 vencimientos mensuales (sumando 30 días cada vez) e imprimí en formato dd/mm/yyyy. Debe incluir 10/03/2025.

ejercicio_06.pyDebe incluir "10/03/2025"

from datetime import date, timedelta

primera_cuota = date(2025, 1, 10)

# Generá 6 vencimientos:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 7: Simulación con random y seed

Con seed(123), simulá 12 meses de retornos con random.gauss(0.005, 0.02) sobre capital $100,000. Imprimí saldo final. Debe incluir Final.

ejercicio_07.pyDebe incluir "Final"

import random
random.seed(123)
capital = 100000

# Simulá 12 meses:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 8: Parsear JSON de API simulada

Dado un string JSON, parsealo, extraé los datos y calculá el valor total de la cartera. Debe incluir 2120000.

ejercicio_08.pyDebe incluir "2120000"

import json

json_str = '[{"ticker":"GGAL","cantidad":100,"precio":5200},{"ticker":"YPF","cantidad":50,"precio":28000}]'

# Parseá y calculá valor total:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 9: Generar dataset de prueba

Con seed(0), generá 5 clientes con nombre aleatorio de una lista, score entre 400-900, saldo entre 10K-500K. Guardá como lista de dicts. Debe incluir score.

ejercicio_09.pyDebe incluir "score"

import random
random.seed(0)
nombres = ["García", "López", "Martínez", "Pérez", "Fernández"]

# Generá 5 clientes aleatorios:

Hacé clic en ▶ Ejecutar

Nivel 4 · Desafío

Ejercicio 10: Reporte completo con todos los módulos

Combiná math, datetime, random, json y collections: (1) generá 10 transacciones aleatorias (seed 42) con fecha, tipo, monto, (2) contá tipos con Counter, (3) calculá estadísticas con math, (4) serializá a JSON, (5) imprimí reporte con fecha formateada. Debe incluir REPORTE.

ejercicio_10_desafio.pyDebe incluir "REPORTE"

import math, json, random
from datetime import datetime, timedelta
from collections import Counter

random.seed(42)
tipos = ["compra", "venta", "transferencia"]
base = datetime(2025, 1, 1)

# Generá 10 transacciones y armá reporte:
print("=== REPORTE DE TRANSACCIONES ===")

Hacé clic en ▶ Ejecutar

Resumen y conexión

math: sqrt, ceil, floor, log, pi — cálculos matemáticos y financieros.
datetime: now, strftime/strptime, timedelta — fechas, vencimientos, antigüedad.
random: randint, choice, sample, seed — simulaciones reproducibles y muestreo.
json: dumps/loads — serializar y parsear datos para APIs y archivos.
os: path.join, listdir, getcwd — manejar archivos y rutas.
collections: Counter, defaultdict, namedtuple — estructuras de datos especializadas.
Imports al inicio del archivo, uno por línea, agrupados (stdlib → terceros → propios).

En la siguiente lección (21 · Módulos de pip) vas a aprender a instalar paquetes externos como pandas, numpy y requests — el ecosistema que hace de Python el lenguaje #1 para datos.

Recursos: Python Standard Library

Hecho con ❤️ por Rodri Gonzalez