Python · Lección 21 de 27

Módulos externos (pip)

La biblioteca estándar cubre lo básico, pero el verdadero poder de Python viene de su ecosistema: más de 400,000 paquetes en PyPI que instalás con pip. Esta lección cubre pip, entornos virtuales y los paquetes que necesitás como Data Analyst.

70–90 min Prerrequisitos: 20 Módulos stdlib

Concepto teórico

¿Qué es pip?

pip (Package Installer for Python) es la herramienta oficial para instalar paquetes de PyPI (Python Package Index), el repositorio central con más de 400,000 paquetes. Viene incluido con Python 3.4+ — no necesitás instalarlo por separado.

Comando	Qué hace	Ejemplo
`pip install paquete`	Instala un paquete	`pip install pandas`
`pip install paquete==version`	Instala versión específica	`pip install pandas==2.1.0`
`pip install -U paquete`	Actualiza a la última	`pip install -U pandas`
`pip uninstall paquete`	Desinstala	`pip uninstall pandas`
`pip list`	Lista paquetes instalados	—
`pip freeze`	Lista con versiones exactas	Para `requirements.txt`
`pip install -r req.txt`	Instala desde archivo	`pip install -r requirements.txt`

Entornos virtuales (venv) — aislar proyectos

Cada proyecto puede necesitar versiones diferentes de los mismos paquetes. Un entorno virtual es una copia aislada de Python con sus propios paquetes, independiente del sistema. Es como tener una "burbuja" por proyecto.

# Crear entorno virtual
python -m venv .venv

# Activar (Windows)
.venv\Scripts\activate

# Activar (Mac/Linux)
source .venv/bin/activate

# Instalar paquetes dentro del entorno
pip install pandas numpy matplotlib

# Guardar dependencias
pip freeze > requirements.txt

# Otro desarrollador replica tu entorno:
pip install -r requirements.txt

Regla profesional: SIEMPRE usá entornos virtuales para proyectos. Nunca instales paquetes globalmente. Si dos proyectos necesitan versiones distintas de pandas, los entornos virtuales te salvan. En VS Code, la extensión de Python detecta el venv automáticamente.

requirements.txt — reproducibilidad

Un archivo requirements.txt lista todos los paquetes que tu proyecto necesita con sus versiones exactas. Es el contrato que garantiza que cualquiera pueda reproducir tu entorno:

pandas==2.1.4
numpy==1.26.2
matplotlib==3.8.2
scikit-learn==1.3.2
openpyxl==3.1.2
requests==2.31.0

¿Por qué versiones exactas? Porque una actualización menor de pandas puede romper tu código. Si tu script funciona con pandas 2.1.4, fijá esa versión. Cuando tengas tiempo de testear con la nueva versión, actualizá deliberadamente.

Los paquetes que todo Data Analyst necesita

Paquete	¿Para qué?	Instalar
`pandas`	DataFrames, limpieza, análisis tabular	`pip install pandas`
`numpy`	Arrays numéricos, operaciones vectorizadas	`pip install numpy`
`matplotlib`	Gráficos y visualizaciones	`pip install matplotlib`
`seaborn`	Visualizaciones estadísticas (sobre matplotlib)	`pip install seaborn`
`scikit-learn`	Machine Learning	`pip install scikit-learn`
`openpyxl`	Leer/escribir archivos Excel (.xlsx)	`pip install openpyxl`
`requests`	Consumir APIs HTTP	`pip install requests`
`sqlalchemy`	Conexión a bases de datos SQL	`pip install sqlalchemy`
`jupyter`	Notebooks interactivos	`pip install jupyter`

En el trabajo: cuando empezás en un equipo, lo primero que hacés es: git clone proyecto, python -m venv .venv, pip install -r requirements.txt. En 3 comandos tenés exactamente el mismo entorno que tus compañeros. Sin venv ni requirements, cada persona tiene versiones distintas y los bugs son imposibles de reproducir.

Cómo leer documentación de un paquete nuevo

Cuando encontrás un paquete nuevo, seguí esta secuencia:

README / Getting Started: ejemplo mínimo de uso
API Reference: lista de funciones con parámetros
Examples / Tutorials: casos de uso reales
Changelog: qué cambió en cada versión

Tip: en el intérprete de Python, help(pandas.read_csv) muestra la documentación completa de cualquier función. dir(objeto) lista todos los métodos disponibles. Son tus herramientas de exploración rápida.

Ejemplos explicados paso a paso

Ejemplo 1: pandas — primer contacto

Pandas está disponible en Pyodide (este editor). Podés probarlo directamente.

ejemplo_01_pandas.pyPython

import pandas as pd

# Crear DataFrame desde lista de diccionarios
clientes = [
    {"nombre": "García", "score": 720, "saldo": 150000},
    {"nombre": "López", "score": 680, "saldo": 320000},
    {"nombre": "Martínez", "score": 590, "saldo": 45000},
    {"nombre": "Pérez", "score": 810, "saldo": 890000},
    {"nombre": "Fernández", "score": 645, "saldo": 72000},
]
df = pd.DataFrame(clientes)
print(df)

print(f"\n=== Estadísticas ===")
print(f"Filas: {len(df)}")
print(f"Saldo total: ${df['saldo'].sum():,}")
print(f"Saldo promedio: ${df['saldo'].mean():,.0f}")
print(f"Score máximo: {df['score'].max()}")

# Filtrar
aprobados = df[df["score"] >= 650]
print(f"\nAprobados (score >= 650):")
print(aprobados[["nombre", "score"]])

Hacé clic en ▶ Ejecutar

Ejemplo 2: numpy — operaciones vectorizadas

ejemplo_02_numpy.pyPython

import numpy as np

# Array desde lista
saldos = np.array([150000, 320000, 45000, 890000, 72000])

# Operaciones vectorizadas (sin for loops!)
print(f"Saldos: {saldos}")
print(f"Con 5% interés: {saldos * 1.05}")
print(f"En USD (÷1150): {np.round(saldos / 1150, 2)}")

# Estadísticas
print(f"\nMedia: ${np.mean(saldos):,.0f}")
print(f"Mediana: ${np.median(saldos):,.0f}")
print(f"Desvío: ${np.std(saldos):,.0f}")
print(f"Percentil 75: ${np.percentile(saldos, 75):,.0f}")

# Filtrado booleano (como pandas)
grandes = saldos[saldos > 100000]
print(f"\nSaldos > $100K: {grandes}")

# Generar datos: 100 retornos normales
np.random.seed(42)
retornos = np.random.normal(loc=0.005, scale=0.02, size=100)
print(f"\nSimulación 100 retornos:")
print(f"  Media: {np.mean(retornos):.4f}")
print(f"  Desvío: {np.std(retornos):.4f}")
print(f"  Min: {np.min(retornos):.4f}")
print(f"  Max: {np.max(retornos):.4f}")

Hacé clic en ▶ Ejecutar

Ejemplo 3: pandas + numpy combinados

ejemplo_03_pd_np.pyPython

import pandas as pd
import numpy as np

# Crear DataFrame con datos generados
np.random.seed(42)
n = 100
df = pd.DataFrame({
    "cliente_id": range(1, n + 1),
    "score": np.random.randint(400, 900, n),
    "ingreso": np.random.uniform(50000, 800000, n).round(0),
    "antiguedad_meses": np.random.randint(1, 120, n),
})

print(f"Shape: {df.shape}")
print(f"\nPrimeras 5 filas:")
print(df.head())

print(f"\n=== Estadísticas ===")
print(df.describe().round(0))

# Crear columna derivada
df["categoria"] = np.where(df["score"] >= 700, "Premium", "Estándar")
print(f"\nConteo por categoría:")
print(df["categoria"].value_counts())

Hacé clic en ▶ Ejecutar

Ejemplo 4: json + requests simulado (consumir API)

ejemplo_04_api.pyPython

import json

# Simulamos respuesta de API (en tu PC usarías requests.get())
# import requests
# response = requests.get("https://api.banco.com/clientes/12345")
# data = response.json()

# Simulación de la respuesta
api_response = json.dumps({
    "status": "ok",
    "data": {
        "id": 12345,
        "nombre": "García",
        "cuentas": [
            {"tipo": "CA$", "saldo": 150000},
            {"tipo": "CA USD", "saldo": 5000}
        ]
    }
})

# Parsear JSON → dict
data = json.loads(api_response)

# Procesar
print(f"Status: {data['status']}")
print(f"Cliente: {data['data']['nombre']}")
print(f"\nCuentas:")
for cta in data["data"]["cuentas"]:
    print(f"  {cta['tipo']}: ${cta['saldo']:,}")

total = sum(c["saldo"] for c in data["data"]["cuentas"] if c["tipo"] == "CA$")
print(f"Total ARS: ${total:,}")

# En tu PC, el flujo real sería:
# response = requests.get(url, headers={"Authorization": "Bearer TOKEN"})
# if response.status_code == 200:
#     data = response.json()
#     procesar(data)
print("\n(En tu PC: pip install requests, luego requests.get(url).json())")

Hacé clic en ▶ Ejecutar

Ejemplo 5: Explorar paquetes con help() y dir()

ejemplo_05_explorar.pyPython

import pandas as pd
import numpy as np

# dir(): listar todo lo disponible en un módulo/objeto
print("=== Métodos de un DataFrame ===")
df = pd.DataFrame({"a": [1, 2, 3]})
metodos = [m for m in dir(df) if not m.startswith("_")]
print(f"Total métodos públicos: {len(metodos)}")
print(f"Primeros 15: {metodos[:15]}")

# type(): verificar qué tipo es algo
print(f"\nTipo de df: {type(df)}")
print(f"Tipo de df['a']: {type(df['a'])}")
print(f"Tipo de np.array([1]): {type(np.array([1]))}")

# Inspeccionar un método específico
print(f"\n=== Ayuda de pd.DataFrame.describe ===")
# help(df.describe)  # Descomentá para ver la doc completa

# Verificar versiones instaladas
print(f"\npandas: {pd.__version__}")
print(f"numpy: {np.__version__}")

# Bonus: listar todos los módulos de la stdlib disponibles
import sys
print(f"\nMódulos cargados: {len(sys.modules)}")

Hacé clic en ▶ Ejecutar

Referencia rápida

Comando pip	Acción
`pip install pandas`	Instalar paquete
`pip install pandas==2.1.4`	Versión específica
`pip install -U pandas`	Actualizar
`pip uninstall pandas`	Desinstalar
`pip list`	Ver instalados
`pip freeze > requirements.txt`	Exportar dependencias
`pip install -r requirements.txt`	Instalar desde archivo

Comando venv	Acción
`python -m venv .venv`	Crear entorno virtual
`.venv\Scripts\activate` (Win)	Activar
`source .venv/bin/activate` (Mac/Linux)	Activar
`deactivate`	Desactivar

Ejercicios

Nivel 1 · Básico

Ejercicio 1: Crear DataFrame

Creá un DataFrame con 3 productos (nombre, precio, stock) e imprimilo. Debe incluir Notebook.

ejercicio_01.pyDebe incluir "Notebook"

import pandas as pd

# Creá el DataFrame:

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 2: Array de numpy

Creá un array np.array([100, 200, 300, 400, 500]) y multiplicalo por 1.21 (IVA). Debe incluir 121.

ejercicio_02.pyDebe incluir "121"

import numpy as np
precios = np.array([100, 200, 300, 400, 500])

# Multiplicá por 1.21:

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 3: Estadísticas con numpy

Dado np.array([150000,320000,45000,890000,72000]), calculá media, mediana y desvío. Debe incluir 295400.

ejercicio_03.pyDebe incluir "295400"

import numpy as np
saldos = np.array([150000, 320000, 45000, 890000, 72000])

# Calculá estadísticas:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 4: DataFrame con filtrado

Creá un DataFrame de 5 clientes, filtrá los que tienen score >= 700 e imprimí solo sus nombres. Debe incluir Premium.

ejercicio_04.pyDebe incluir "Premium"

import pandas as pd
import numpy as np

df = pd.DataFrame({
    "nombre": ["García","López","Martínez","Pérez","Sosa"],
    "score": [720, 680, 590, 810, 750],
})

# Filtrá y clasificá:
df["categoria"] = np.where(df["score"] >= 700, "Premium", "Estándar")

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 5: describe() del DataFrame

Generá un DataFrame con 50 valores aleatorios de score (400-900) usando numpy. Mostrá describe(). Debe incluir mean.

ejercicio_05.pyDebe incluir "mean"

import pandas as pd
import numpy as np
np.random.seed(42)

# Generá DataFrame con 50 scores aleatorios:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 6: value_counts()

Creá un DataFrame con 20 transacciones de tipo aleatorio ("compra","venta","transferencia"). Mostrá value_counts(). Debe incluir compra.

ejercicio_06.pyDebe incluir "compra"

import pandas as pd
import numpy as np
np.random.seed(42)

tipos = ["compra", "venta", "transferencia"]

# Generá 20 transacciones aleatorias:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 7: groupby básico

Creá un DataFrame con clientes, ciudad y saldo. Agrupá por ciudad y mostrá el saldo promedio. Debe incluir BsAs.

ejercicio_07.pyDebe incluir "BsAs"

import pandas as pd

df = pd.DataFrame({
    "nombre": ["García","López","Martínez","Pérez","Fernández"],
    "ciudad": ["BsAs","Córdoba","BsAs","BsAs","Córdoba"],
    "saldo": [150000, 320000, 45000, 890000, 72000],
})

# Agrupá por ciudad:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 8: Operaciones vectorizadas

Creá un array de 10 precios con numpy. Aplicá descuento 15% vectorizado y calculá el ahorro total. Debe incluir Ahorro.

ejercicio_08.pyDebe incluir "Ahorro"

import numpy as np
np.random.seed(42)

precios = np.random.uniform(1000, 50000, 10).round(0)

# Aplicá descuento 15% y calculá ahorro:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 9: Escribir y leer requirements.txt simulado

Creá una lista de paquetes con versiones y generá un string con formato requirements.txt. Debe incluir pandas.

ejercicio_09.pyDebe incluir "pandas"

paquetes = [
    ("pandas", "2.1.4"),
    ("numpy", "1.26.2"),
    ("scikit-learn", "1.3.2"),
    ("matplotlib", "3.8.2"),
]

# Generá requirements.txt como string:

Hacé clic en ▶ Ejecutar

Nivel 4 · Desafío

Ejercicio 10: Pipeline con pandas + numpy

Generá un DataFrame de 100 clientes (seed 42) con score, ingreso y ciudad aleatorios. Agregá columna "categoria" (Premium/Estándar), agrupá por ciudad y mostrá estadísticas. Debe incluir PIPELINE.

ejercicio_10_desafio.pyDebe incluir "PIPELINE"

import pandas as pd
import numpy as np
np.random.seed(42)

ciudades = ["BsAs", "Córdoba", "Rosario", "Mendoza"]

# Generá 100 clientes y procesá:
print("=== PIPELINE DE DATOS ===")

Hacé clic en ▶ Ejecutar

Resumen y conexión

pip install paquete instala desde PyPI. pip freeze > requirements.txt guarda dependencias.
SIEMPRE usá entornos virtuales (python -m venv .venv) para aislar proyectos.
pandas para DataFrames y análisis tabular. numpy para arrays y operaciones vectorizadas.
requests para consumir APIs. openpyxl para Excel. matplotlib/seaborn para gráficos.
help() y dir() son tus herramientas de exploración de cualquier paquete.

En la siguiente lección (22 · Scope de variables) vas a entender cómo Python maneja la visibilidad de las variables: local, enclosing, global y built-in.

Recursos: PyPI · pandas docs · numpy docs

Hecho con ❤️ por Rodri Gonzalez