Data Analysis · Lección 16 de 19

Power BI y Tableau: Introducción

Python es la navaja suiza del análisis — flexible, potente, programable. Pero en el mundo corporativo, los gerentes y directores no van a abrir un Jupyter Notebook. Necesitan dashboards interactivos que puedan explorar solos, filtrar por región y mes, y compartir con un clic. Para eso existen Power BI y Tableau, las herramientas de Business Intelligence (BI) más usadas del planeta.

60–90 min Prerrequisitos: Lección 15 (Regresión y clasificación)

Concepto teórico

¿Qué es Business Intelligence?

Business Intelligence (BI) es el proceso de transformar datos crudos en información accionable para la toma de decisiones empresariales. Las herramientas de BI permiten crear dashboards, reportes automatizados y visualizaciones interactivas sin escribir código.

Analogía: Python es como tener un taller de carpintería: podés construir cualquier mueble, pero necesitás saber usar las herramientas. Power BI / Tableau son como un showroom de IKEA: los muebles ya están diseñados, los ves montados, y el cliente puede recorrerlos y elegir sin saber carpintería. Tu trabajo como analista es construir los "muebles" (dashboards) para que los "clientes" (gerentes) tomen decisiones.

Power BI vs Tableau vs Python

Aspecto	Power BI	Tableau	Python (matplotlib/seaborn)
Compañía	Microsoft	Salesforce	Open source
Precio	Gratis (Desktop) / $10/mes (Pro)	$75/mes	Gratis
Curva de aprendizaje	Media (drag & drop)	Media-baja	Alta (programar)
Interactividad	⭐⭐⭐ Filtros dinámicos	⭐⭐⭐ Exploración visual	⭐ Estáticos (sin plotly)
Datos grandes	Bueno (DirectQuery)	Excelente	Limitado por RAM
Automatización	Buena (scheduled refresh)	Buena	Excelente (scripts)
Integración SQL	Nativa	Nativa	Con librerías
ML / Análisis avanzado	Limitado	Limitado	⭐⭐⭐ Ilimitado
Uso en la industria	Corporaciones (Microsoft)	Consultoría, data teams	Data Science, ingeniería

¿Cuál aprender? La respuesta depende del mercado laboral de tu zona. En LATAM y empresas con ecosistema Microsoft (la mayoría), Power BI domina. En EE.UU. y empresas tech, Tableau es más común. Python es universal. Lo ideal: Python + una herramienta de BI (preferiblemente Power BI si estás en LATAM).

Conceptos clave de BI

Concepto	Qué es	Ejemplo
Dashboard	Página con múltiples visualizaciones interactivas	Panel de ventas mensual
KPI	Key Performance Indicator — métrica clave del negocio	Facturación, tasa de churn, NPS
Drill-down	Navegar de lo general a lo particular	País → Provincia → Ciudad
Slicer / Filtro	Control para filtrar datos dinámicamente	Dropdown de "Año" o "Región"
Medida (Measure)	Cálculo dinámico sobre los datos	`SUM(Ventas)`, `AVERAGE(Ticket)`
DAX	Lenguaje de fórmulas de Power BI	`CALCULATE(SUM(Ventas), Año=2024)`
Data Model	Relaciones entre tablas (como SQL JOINs)	Transacciones ↔ Clientes ↔ Productos
ETL	Extract, Transform, Load — pipeline de datos	Sacar de SQL → limpiar → cargar en BI

El flujo de trabajo BI

Conectar: vincular la herramienta con la fuente de datos (SQL, Excel, CSV, API).
Modelar: definir relaciones entre tablas (como los JOINs de SQL 07-08).
Transformar: limpiar y preparar datos (equivalente a pandas lecciones 04-06).
Visualizar: crear gráficos, KPIs, tablas y filtros interactivos.
Publicar: compartir el dashboard para que otros lo exploren.

En el trabajo real: el patrón más común es: (1) un Data Engineer prepara los datos en un data warehouse (SQL), (2) un Data Analyst construye los dashboards en Power BI/Tableau conectados a ese warehouse, (3) los gerentes consumen los dashboards diariamente. Python entra cuando necesitás análisis exploratorio profundo, ML, o automatizaciones que BI no puede hacer.

DAX: el lenguaje de Power BI

DAX (Data Analysis Expressions) es el lenguaje de fórmulas de Power BI. Si ya sabés SQL y pandas, DAX te va a resultar familiar:

Operación	pandas	SQL	DAX (Power BI)
Sumar	`df["Ventas"].sum()`	`SUM(Ventas)`	`SUM(Tabla[Ventas])`
Promedio	`df["Ventas"].mean()`	`AVG(Ventas)`	`AVERAGE(Tabla[Ventas])`
Contar	`df["ID"].nunique()`	`COUNT(DISTINCT ID)`	`DISTINCTCOUNT(Tabla[ID])`
Filtrar	`df[df["Año"]==2024]`	`WHERE Año=2024`	`CALCULATE(..., Tabla[Año]=2024)`
% del total	`v/v.sum()*100`	Window function	`DIVIDE(SUM(...), CALCULATE(SUM(...), ALL(...)))`

Ejercicios prácticos: preparar datos para BI con Python

Como Data Analyst, tu trabajo frecuentemente incluye preparar los datos que luego se visualizan en Power BI o Tableau. Estos ejercicios simulan ese flujo.

Ejemplo 1: Preparar un dataset limpio para dashboard

Limpiar y transformar datos crudos en un formato listo para importar en Power BI.

ejemplo_01_prep_bi.pyPython

import pandas as pd
import numpy as np

np.random.seed(42)
n = 500

# Datos crudos "sucios"
df = pd.DataFrame({
    "fecha": pd.date_range("2024-01-01", periods=n, freq="D"),
    "sucursal": np.random.choice(["CABA", "Rosario", "Córdoba", " mendoza ", "TUCUMAN"], n),
    "canal": np.random.choice(["Web", "app", "SUCURSAL", "web"], n),
    "monto": np.abs(np.random.normal(15000, 8000, n)).round(0),
    "producto": np.random.choice(["Cuenta", "Tarjeta", "Préstamo", "Seguro"], n, p=[0.4,0.3,0.2,0.1])
})
df.loc[np.random.choice(n, 20, replace=False), "monto"] = np.nan

# === LIMPIEZA para BI ===
# 1. Normalizar strings
df["sucursal"] = df["sucursal"].str.strip().str.title()
df["canal"] = df["canal"].str.strip().str.title()

# 2. Rellenar nulos con mediana
df["monto"] = df["monto"].fillna(df["monto"].median())

# 3. Crear columnas de fecha (para slicers en BI)
df["anio"] = df["fecha"].dt.year
df["mes"] = df["fecha"].dt.month
df["mes_nombre"] = df["fecha"].dt.strftime("%b")
df["trimestre"] = df["fecha"].dt.quarter
df["dia_semana"] = df["fecha"].dt.day_name()

print("=== Dataset listo para Power BI ===")
print(f"Filas: {len(df)}, Columnas: {len(df.columns)}")
print(f"Nulos restantes: {df.isna().sum().sum()}")
print(f"\nColumnas: {list(df.columns)}")
print(f"\nSucursales: {sorted(df['sucursal'].unique())}")
print(f"Canales: {sorted(df['canal'].unique())}")
print(f"\nPrimeras filas:")
print(df.head())

Hacé clic en ▶ Ejecutar

Ejemplo 2: Crear tabla de métricas agregadas (KPIs)

Calcular las métricas que un dashboard mostraría como KPIs y tablas resumen.

ejemplo_02_kpis.pyPython

import pandas as pd
import numpy as np

np.random.seed(42)
n = 500
df = pd.DataFrame({
    "Fecha": pd.date_range("2024-01-01", periods=n, freq="D"),
    "Sucursal": np.random.choice(["CABA","Rosario","Córdoba","Mendoza"], n),
    "Canal": np.random.choice(["Web","App","Sucursal"], n),
    "Monto": np.abs(np.random.normal(15000, 8000, n)).round(0),
    "Producto": np.random.choice(["Cuenta","Tarjeta","Préstamo"], n)
})
df["Mes"] = df["Fecha"].dt.to_period("M")

# KPIs globales
print("=" * 50)
print("KPIs GLOBALES (como se verían en un dashboard)")
print("=" * 50)
print(f"  Facturación total:   ${df['Monto'].sum():>12,.0f}")
print(f"  Ticket promedio:     ${df['Monto'].mean():>12,.0f}")
print(f"  Operaciones totales: {len(df):>12,}")
print(f"  Ticket mediano:      ${df['Monto'].median():>12,.0f}")

# Tabla para gráfico de barras: ventas por sucursal
print(f"\n{'='*50}")
print("VENTAS POR SUCURSAL")
print(f"{'='*50}")
suc = df.groupby("Sucursal").agg(
    Total=("Monto","sum"),
    Operaciones=("Monto","count"),
    Ticket_Prom=("Monto","mean")
).round(0)
suc["Participacion_%"] = round(suc["Total"] / suc["Total"].sum() * 100, 1)
print(suc.sort_values("Total", ascending=False))

# Tabla para gráfico temporal: tendencia mensual
print(f"\n{'='*50}")
print("TENDENCIA MENSUAL")
print(f"{'='*50}")
mensual = df.groupby("Mes").agg(Total=("Monto","sum"), Ops=("Monto","count")).round(0)
print(mensual.head(6))

Hacé clic en ▶ Ejecutar

Ejemplo 3: Crear el modelo de datos (tablas relacionadas)

En BI necesitás un modelo estrella: una tabla de hechos (transacciones) y tablas de dimensiones (clientes, productos, fechas). Python las prepara.

ejemplo_03_modelo.pyPython

import pandas as pd
import numpy as np

np.random.seed(42)

# Tabla de DIMENSIÓN: Sucursales
dim_sucursales = pd.DataFrame({
    "Sucursal_ID": [1, 2, 3, 4],
    "Nombre": ["CABA", "Rosario", "Córdoba", "Mendoza"],
    "Zona": ["Centro", "Litoral", "Interior", "Cuyo"],
    "Gerente": ["García", "López", "Pérez", "Sosa"]
})

# Tabla de DIMENSIÓN: Productos
dim_productos = pd.DataFrame({
    "Producto_ID": [1, 2, 3],
    "Nombre": ["Cuenta", "Tarjeta", "Préstamo"],
    "Categoría": ["Pasivo", "Activo", "Activo"],
    "Comisión_%": [0.5, 2.0, 5.0]
})

# Tabla de HECHOS: Transacciones
fact_txn = pd.DataFrame({
    "Txn_ID": range(1, 201),
    "Fecha": pd.date_range("2024-01-01", periods=200, freq="D"),
    "Sucursal_ID": np.random.choice([1,2,3,4], 200),
    "Producto_ID": np.random.choice([1,2,3], 200),
    "Monto": np.abs(np.random.normal(15000, 8000, 200)).round(0).astype(int)
})

print("=== MODELO ESTRELLA para BI ===")
print(f"\nTabla de Hechos: fact_txn ({len(fact_txn)} filas)")
print(fact_txn.head())
print(f"\nDimensión Sucursales ({len(dim_sucursales)} filas)")
print(dim_sucursales)
print(f"\nDimensión Productos ({len(dim_productos)} filas)")
print(dim_productos)

# Relaciones (en BI se configuran con drag & drop)
print(f"\n=== Relaciones ===")
print("  fact_txn.Sucursal_ID → dim_sucursales.Sucursal_ID")
print("  fact_txn.Producto_ID → dim_productos.Producto_ID")
print("\nEn Power BI, estas relaciones se crean")
print("arrastrando una columna sobre otra en el Model View.")

Hacé clic en ▶ Ejecutar

Tip profesional — Modelo Estrella: es el estándar de la industria de BI. Una tabla central de hechos (transacciones, ventas, eventos) rodeada de tablas de dimensiones (clientes, productos, fechas, sucursales). Las dimensiones enriquecen los hechos. Cada relación es 1-a-muchos: un producto tiene muchas transacciones.

Ejemplo 4: Simular cálculos DAX con pandas

ejemplo_04_dax_pandas.pyPython

import pandas as pd
import numpy as np

np.random.seed(42)
df = pd.DataFrame({
    "Sucursal": np.random.choice(["CABA","Rosario","Córdoba"], 100),
    "Mes": np.random.choice(["Enero","Febrero","Marzo"], 100),
    "Monto": np.abs(np.random.normal(15000, 5000, 100)).round(0).astype(int)
})

# Equivalente a DAX: CALCULATE(SUM(Monto), Sucursal="CABA")
total_caba = df[df["Sucursal"]=="CABA"]["Monto"].sum()
print(f"DAX: CALCULATE(SUM(Monto), Sucursal='CABA')")
print(f"pandas: df[df['Sucursal']=='CABA']['Monto'].sum()")
print(f"Resultado: ${total_caba:,}\n")

# Equivalente a DAX: DIVIDE(SUM, CALCULATE+ALL) → participación
total_global = df["Monto"].sum()
participacion = df.groupby("Sucursal")["Monto"].sum() / total_global * 100
print(f"DAX: DIVIDE(SUM(...), CALCULATE(SUM(...), ALL(Sucursal)))")
print(f"pandas: groupby().sum() / total * 100")
print(participacion.round(1))

# Equivalente a DAX: TOTALYTD
print(f"\nDAX: TOTALYTD(SUM(Monto), Fechas)")
print(f"pandas: groupby('Mes').sum().cumsum()")
mensual = df.groupby("Mes")["Monto"].sum()
print(f"Mensual:\n{mensual}")
print(f"\nAcumulado YTD:\n{mensual.cumsum()}")

Hacé clic en ▶ Ejecutar

Ejemplo 5: Crear un mock dashboard con Python

ejemplo_05_mock_dashboard.pyPython

import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd

np.random.seed(42)
df = pd.DataFrame({
    "Mes": pd.date_range("2024-01-01", periods=12, freq="MS"),
    "CABA": np.random.normal(90000, 15000, 12).astype(int),
    "Rosario": np.random.normal(65000, 10000, 12).astype(int),
    "Córdoba": np.random.normal(50000, 8000, 12).astype(int)
})
meses = [d.strftime("%b") for d in df["Mes"]]

fig, axes = plt.subplots(2, 2, figsize=(12, 9))
fig.suptitle("Dashboard Ejecutivo — Ventas 2024", fontsize=15, fontweight="bold")

# 1. KPIs (simulados como texto)
axes[0,0].axis("off")
total = df[["CABA","Rosario","Córdoba"]].sum().sum()
axes[0,0].text(0.5, 0.8, "FACTURACIÓN TOTAL", ha="center", fontsize=11, color="gray")
axes[0,0].text(0.5, 0.5, f"${total:,.0f}", ha="center", fontsize=28, fontweight="bold", color="#2196F3")
axes[0,0].text(0.5, 0.25, f"Ticket Promedio: ${total/12/3:,.0f}", ha="center", fontsize=11, color="gray")

# 2. Tendencia mensual
for col, color in [("CABA","#2196F3"),("Rosario","#4CAF50"),("Córdoba","#FF9800")]:
    axes[0,1].plot(meses, df[col], "o-", label=col, linewidth=2, markersize=4, color=color)
axes[0,1].set_title("Tendencia Mensual"); axes[0,1].legend(fontsize=8)
axes[0,1].grid(True, alpha=0.3); axes[0,1].tick_params(axis="x", rotation=45)

# 3. Barras por sucursal
totales = df[["CABA","Rosario","Córdoba"]].sum()
axes[1,0].bar(totales.index, totales.values, color=["#2196F3","#4CAF50","#FF9800"])
axes[1,0].set_title("Total por Sucursal")
for i, (v) in enumerate(totales.values):
    axes[1,0].text(i, v+5000, f"${v:,.0f}", ha="center", fontsize=8, fontweight="bold")

# 4. Composición (pie)
axes[1,1].pie(totales.values, labels=totales.index, autopct="%1.0f%%",
              colors=["#2196F3","#4CAF50","#FF9800"], startangle=90)
axes[1,1].set_title("Participación de Mercado")

plt.tight_layout()
plt.show()
print("Este dashboard se replica en Power BI con drag & drop")

Hacé clic en ▶ Ejecutar

Referencia rápida

Concepto BI	Equivalente Python
Dashboard	`fig, axes = plt.subplots()`
Slicer / Filtro	`df[df["col"]==val]`
Medida (SUM)	`df["col"].sum()`
Drill-down	`groupby(["nivel1","nivel2"])`
Modelo estrella	`pd.merge(hechos, dimensión)`
DAX CALCULATE	`df[filtro]["col"].sum()`
Scheduled Refresh	Cron job / script programado

Ejercicios

Nivel 1 · Básico

Ejercicio 1: Limpiar strings para BI

Normalizá la columna Ciudad: strip + title. Imprimí los valores únicos. Debe incluir Caba.

ejercicio_01.pyDebe incluir "Caba"

import pandas as pd

df = pd.DataFrame({"Ciudad": [" caba ", "ROSARIO", " córdoba", "Caba", "rosario "]})

# Normalizar y mostrar únicos

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 2: Crear columnas de fecha

A partir de una columna de fecha, extraé año, mes y trimestre. Imprimí las columnas. Debe incluir Trimestre.

ejercicio_02.pyDebe incluir "Trimestre"

import pandas as pd

df = pd.DataFrame({"Fecha": pd.date_range("2024-01-01", periods=10, freq="M")})

# Crear: Anio, Mes, Trimestre

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 3: KPIs básicos

Calculá: total de ventas, ticket promedio y cantidad de operaciones. Debe incluir Total.

ejercicio_03.pyDebe incluir "Total"

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

df = pd.DataFrame({"Monto": np.random.normal(15000, 5000, 100).astype(int)})

# 3 KPIs

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 4: Participación por sucursal (%)

Calculá qué % del total representa cada sucursal. Debe incluir %.

ejercicio_04.pyDebe incluir "%"

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

df = pd.DataFrame({
    "Sucursal": np.random.choice(["CABA","Rosario","Córdoba"], 100),
    "Monto": np.random.normal(15000, 5000, 100).astype(int)
})

# Participación % por sucursal

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 5: Modelo estrella — crear dimensiones

Creá una tabla de dimensión de sucursales y hacé merge con la tabla de hechos. Debe incluir Zona.

ejercicio_05.pyDebe incluir "Zona"

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

hechos = pd.DataFrame({
    "Txn_ID": range(1, 11),
    "Suc_ID": np.random.choice([1,2,3], 10),
    "Monto": np.random.randint(5000, 25000, 10)
})

# Crear dim_sucursales con Suc_ID, Nombre, Zona
# Hacer merge

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 6: Simular CALCULATE de DAX

Calculá la suma de Monto solo para Sucursal="CABA" (equivalente a DAX CALCULATE). Debe incluir un número.

ejercicio_06.pyDebe incluir un número

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

df = pd.DataFrame({
    "Sucursal": np.random.choice(["CABA","Rosario","Córdoba"], 50),
    "Monto": np.random.randint(5000, 30000, 50)
})

# CALCULATE(SUM(Monto), Sucursal="CABA")

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 7: Acumulado YTD (Year-to-Date)

Calculá la facturación mensual y el acumulado YTD con .cumsum(). Debe incluir YTD.

ejercicio_07.pyDebe incluir "YTD"

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

df = pd.DataFrame({
    "Fecha": pd.date_range("2024-01-01", periods=180, freq="D"),
    "Monto": np.random.normal(15000, 5000, 180).astype(int)
})
df["Mes"] = df["Fecha"].dt.to_period("M")

# Mensual + YTD acumulado

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 8: Tabla resumen para heatmap BI

Creá una pivot_table Sucursal × Mes que un heatmap de Power BI usaría. Imprimí la tabla. Debe incluir Enero.

ejercicio_08.pyDebe incluir "Enero"

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

df = pd.DataFrame({
    "Sucursal": np.random.choice(["CABA","Rosario","Córdoba"], 90),
    "Mes": np.random.choice(["Enero","Febrero","Marzo"], 90),
    "Monto": np.random.randint(5000, 30000, 90)
})

# Pivot table: Sucursal × Mes

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 9: Variación mes a mes (%)

Calculá el crecimiento porcentual mes a mes. Imprimí la variación. Debe incluir var.

ejercicio_09.pyDebe incluir "var"

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

mensual = pd.Series([45000, 52000, 48000, 61000, 58000, 72000],
                    index=["Ene","Feb","Mar","Abr","May","Jun"])

# pct_change() para variación %

Hacé clic en ▶ Ejecutar

Nivel 4 · Desafío

Ejercicio 10: Dashboard mock con 4 gráficos

Creá un dashboard de 4 subplots simulando un dashboard de BI: KPI card, tendencia, barras y torta. Imprimí Dashboard BI.

ejercicio_10_desafio.pyDebe imprimir "Dashboard BI"

import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
np.random.seed(42)

meses = ["Ene","Feb","Mar","Abr","May","Jun"]
sucursales = ["CABA","Rosario","Córdoba"]
datos = {s: np.random.randint(30000, 80000, 6) for s in sucursales}

# fig, axes = plt.subplots(2, 2, figsize=(12, 9))
# KPI card + tendencia + barras + torta

Hacé clic en ▶ Ejecutar

Resumen y conexión

Power BI (Microsoft) y Tableau (Salesforce) son las herramientas de BI líderes para crear dashboards interactivos.
Python prepara los datos; BI los presenta. Son complementarios, no competidores.
Conceptos clave: KPIs, slicers, drill-down, modelo estrella, DAX.
Todo lo que hiciste en pandas (groupby, pivot, merge) se traduce directamente a conceptos de BI.
El mercado laboral valora Python + herramienta de BI. Si estás en LATAM, priorizá Power BI.

En la siguiente lección (17 · Integración SQL + Python) vas a aprender a conectar Python directamente con bases de datos SQL — el puente entre los dos mundos que ya dominás.

Hecho con ❤️ por Rodri Gonzalez