De Excel a pandas: el mapa mental

### La historia que nadie te cuenta: por qué pandas existe

En 2008, Wes McKinney trabajaba en AQR Capital Management, un hedge fund de Nueva York. Su día a día era abrir hojas de cálculo con miles de filas de datos financieros, hacer filtros, calcular ratios, y generar informes. Cada lunes repetía el mismo trabajo. Cada viernes descubría que alguien del equipo había usado una versión distinta de la hoja y los números no cuadraban. Y cada vez que un fichero (archivo) superaba las 500.000 filas, Excel se quedaba pensando durante minutos.

McKinney no creó pandas porque odiara Excel. Lo creó porque el trabajo que hacía con Excel — manipular tablas — era el trabajo correcto hecho con la herramienta equivocada para su tamaño. Lo cuenta él mismo: "la mayor parte de tu vida era mover datos en Excel, copiando y pegando valores especiales". No le sobraba la hoja de cálculo: le sobraba el copiar y pegar.

Esa es la clave para entender pandas: no es un sustituto de la hoja de cálculo. Es la hoja de cálculo que escala, que se automatiza, y que no miente cuando dos personas la abren a la vez.

Y aquí es donde entras tú. Si ya sabes usar una hoja de cálculo —filtrar, ordenar, hacer fórmulas, tablas dinámicas (pivot tables, es decir, resúmenes que agrupan datos por categorías)— entonces ya sabes el 80% de lo que pandas hace. Solo te falta el idioma. Esta lección es exactamente eso: un diccionario de traducción. En la columna izquierda, lo que ya sabes hacer en Excel o Google Sheets. En la derecha, cómo se dice en pandas.

### La analogía central: hoja de cálculo = DataFrame

Antes de traducir operaciones, necesitas traducir la estructura. Abre mentalmente una hoja de cálculo y mira lo que ves: una rejilla con filas y columnas. Cada columna tiene un nombre arriba (Producto, Precio, Fecha). Cada fila es un registro (una venta, un cliente, un pedido). Eso, en pandas, se llama DataFrame. Es exactamente la misma idea: una tabla rectangular con nombres de columna y datos organizados en filas.

La diferencia es dónde vive. En Excel, la tabla vive en un fichero .xlsx que abres con doble clic. En pandas, la tabla vive en la memoria RAM de Python y la manipulas con código. El resultado visual es el mismo —filas y columnas— pero el mecanismo de acceso cambia: en vez de hacer clic en una celda, escribes df["precio"]. En vez de arrastrar una fórmula, escribes df["total"] = df["precio"] * df["cantidad"].

• ▹Hoja de cálculo completa (el fichero .xlsx con todas sus pestañas) = no tiene equivalente directo; cada pestaña es un DataFrame independiente.
• ▹Una pestaña / hoja (la rejilla que ves) = un DataFrame — la tabla rectangular con filas y columnas.
• ▹Una columna (la B entera, de arriba abajo) = una Series — un array con nombre y tipo de dato.
• ▹Una fila (un registro horizontal) = una fila del DataFrame, accesible por su índice.
• ▹Una celda (B7) = un valor escalar dentro de una Series en una posición concreta.

### La tabla de equivalencias: 12 cosas que ya sabes hacer

Aquí está el mapa completo. Cada fila es una operación que ya dominas en la hoja de cálculo, con su traducción exacta a pandas. No intentes memorizarlo: úsalo como referencia. Vuelve a esta tabla cada vez que pienses "esto en Excel lo hago así... pero en pandas, ¿cómo era?".

Vamos a recorrer las más importantes con código real. No hace falta que las practiques todas ahora — las siguientes lecciones profundizan en cada una. Aquí el objetivo es que veas la forma, que reconozcas el patrón, y que dejes de sentir que pandas es algo nuevo. No lo es: es lo que ya sabías, escrito de otra manera.

### Abrir un fichero: el read_csv que sustituye al doble clic

En Excel, abrir un fichero es hacer doble clic. En pandas, es una línea de código. La ventaja: esa línea la puedes meter en un script que se ejecute solo cada lunes a las 7 de la mañana, sin que tú estés delante. El "doble clic automático" que ahorra horas cada semana.

1import pandas as pd
2
3# Abrir un CSV (lo mas comun)
4df = pd.read_csv('ventas_julio.csv')
5
6# Abrir un Excel (pestana concreta)
7df = pd.read_excel('informe.xlsx', sheet_name='Resumen')
8
9# Ver las primeras 5 filas — equivalente a mirar la hoja al abrirla
10print(df.head())

### Filtrar filas: el autofiltro con superpoderes

En Excel activas el autofiltro, haces clic en la flechita de la columna y seleccionas los valores que quieres ver. En pandas, escribes la condición directamente. La ventaja no es solo que es más rápido: es que la condición queda escrita. Mañana puedes leerla y saber exactamente qué filtro aplicaste. En Excel, si cierras y abres, el filtro sigue activo pero no hay rastro de por qué lo pusiste.

1import pandas as pd
2
3ventas = pd.DataFrame({
4    'producto': ['Laptop', 'Mouse', 'Teclado', 'Monitor', 'Webcam'],
5    'precio': [1200, 25, 45, 350, 60],
6    'categoría': ['Electrónica', 'Periféricos', 'Periféricos', 'Electrónica', 'Periféricos']
7})
8
9# Filtro simple: productos que cuestan mas de 100
10caros = ventas[ventas['precio'] > 100]
11print(caros)
12
13# Filtro con varias condiciones (AND): caros Y de Electrónica
14caros_elec = ventas[(ventas['precio'] > 100) & (ventas['categoría'] == 'Electrónica')]
15print(caros_elec)

### Columna con fórmula: la celda arrastrada se convierte en una línea

En Excel escribes una fórmula en una celda (=B2*C2) y la arrastras hacia abajo para que se aplique a todas las filas. Ese gesto de arrastrar — esa repetición fila a fila — en pandas no existe. Escribes la operación una vez y se aplica a toda la columna de golpe. Se llama operación vectorizada: en vez de decir "haz esto para la fila 1, ahora para la 2, ahora para la 3...", dices "haz esto para TODAS" y pandas lo ejecuta internamente de forma optimizada.

1import pandas as pd
2
3ventas = pd.DataFrame({
4    'producto': ['Laptop', 'Mouse', 'Teclado'],
5    'precio': [1200, 25, 45],
6    'unidades': [150, 2000, 800]
7})
8
9# En Excel: =B2*C2 y arrastrar. En pandas: una linea.
10ventas['ingresos'] = ventas['precio'] * ventas['unidades']
11
12# Otra formula: porcentaje sobre el total
13ventas['pct_ingresos'] = (ventas['ingresos'] / ventas['ingresos'].sum()) * 100
14
15print(ventas)

### SUMAR.SI y CONTAR.SI: no son lo mismo que un groupby

Aquí conviene ser precisos, porque es la traducción que más se explica mal. Un SUMAR.SI responde una pregunta — "¿cuánto vendimos de Periféricos?" — y devuelve un número. Su traducción exacta es df.loc[df["categoria"] == "Periféricos", "ingresos"].sum(). El groupby es lo que obtienes cuando arrastras ese SUMAR.SI por una columna con todas las categorías: la respuesta para cada una, de una vez. Y eso, en la hoja, tiene otro nombre — es la tabla dinámica —.

¿Por qué importa la distinción? Porque cuando pases de la hoja a pandas vas a escribir groupby donde antes tenías veinte celdas con SUMAR.SI, y conviene que sepas que no has traducido veinte fórmulas: has sustituido la columna entera por una línea. Es una mejora, no una traducción literal.

La analogía perfecta: imagina que tienes un montón de facturas en la mesa. Las separas en montones por cliente (eso es el groupby). Luego, a cada montón le calculas el total (eso es el .sum()). Primero divides, luego calculas. Dividir-aplicar-combinar: ese es el patrón.

1import pandas as pd
2
3ventas = pd.DataFrame({
4    'producto': ['Laptop', 'Mouse', 'Teclado', 'Monitor', 'Webcam'],
5    'categoría': ['Electrónica', 'Periféricos', 'Periféricos', 'Electrónica', 'Periféricos'],
6    'ingresos': [180000, 50000, 36000, 105000, 30000]
7})
8
9# SUMAR.SI de UNA categoría: un filtro + suma -> devuelve UN número
10total_perifericos = ventas.loc[ventas['categoría'] == 'Periféricos', 'ingresos'].sum()
11print(f"Total Periféricos: {total_perifericos}")
12
13# CONTAR.SI de UNA categoría: cuántas filas cumplen la condición
14conteo_perifericos = (ventas['categoría'] == 'Periféricos').sum()
15print(f"Productos en Periféricos: {conteo_perifericos}")
16
17# groupby: TODAS las categorías de golpe (esto es la tabla dinámica, no el SUMAR.SI)
18total_por_cat = ventas.groupby('categoría')['ingresos'].sum()
19print(total_por_cat)

### BUSCARV: el merge que hace lo mismo sin romperse

BUSCARV (VLOOKUP en inglés) es la función que más dolores de cabeza causa en Excel. Tienes una tabla de ventas con códigos de producto, y otra tabla con los nombres y categorías de cada producto. Quieres cruzarlas: que cada venta tenga al lado el nombre del producto. En Excel, escribes un BUSCARV que busca el código en la otra tabla y trae la columna que necesitas. Funciona... hasta que alguien inserta una columna en medio y el índice numérico apunta al sitio equivocado.

En pandas, esa operación se llama merge (unir). Es el equivalente directo del JOIN de SQL: le dices "junta estas dos tablas por la columna que tienen en común" y pandas empareja las filas automáticamente. Sin índices numéricos que se rompan, sin fórmulas que se arrastren, sin errores silenciosos.

1import pandas as pd
2
3# Tabla de ventas (solo tiene el codigo del producto)
4ventas = pd.DataFrame({
5    'cod_producto': ['A01', 'B02', 'A01', 'C03'],
6    'cantidad': [5, 3, 2, 7]
7})
8
9# Tabla de productos (tiene nombre y precio)
10productos = pd.DataFrame({
11    'cod_producto': ['A01', 'B02', 'C03'],
12    'nombre': ['Laptop', 'Mouse', 'Teclado'],
13    'precio': [1200, 25, 45]
14})
15
16# BUSCARV = merge con how='left': conserva todas las filas de la izquierda
17resultado = pd.merge(ventas, productos, on='cod_producto', how='left')
18print(resultado)

### Tabla dinámica: pivot_table es la misma idea

La tabla dinámica de Excel es, posiblemente, la herramienta de análisis más potente que tiene un no-programador. Arrastras campos a filas, columnas y valores, y obtienes un resumen cruzado de tus datos. En pandas, esa misma operación se llama pivot_table, y funciona con la misma lógica: le dices qué campo va en las filas (index), cuál en las columnas (columns) y qué cálculo quieres en los valores (values + aggfunc).

1import pandas as pd
2
3ventas = pd.DataFrame({
4    'mes': ['Ene', 'Ene', 'Feb', 'Feb', 'Mar', 'Mar'],
5    'categoría': ['Electrónica', 'Periféricos', 'Electrónica', 'Periféricos', 'Electrónica', 'Periféricos'],
6    'ingresos': [50000, 20000, 55000, 22000, 48000, 25000]
7})
8
9# Tabla dinamica: ingresos por mes (filas) y categoria (columnas)
10tabla = ventas.pivot_table(
11    values='ingresos',
12    index='mes',
13    columns='categoría',
14    aggfunc='sum'
15)
16print(tabla)

### Tres ventajas que la hoja de cálculo no puede darte

Si pandas hiciera lo mismo que Excel y nada más, no tendría sentido aprenderlo. Las ventajas reales no son las que esperas. No es "pandas es mejor": es que resuelve tres problemas que la hoja de cálculo, por su naturaleza, no puede resolver.

1. 01.Tamaño. Excel tiene un límite físico: 1.048.576 filas. Punto. Si tu fichero tiene un millón cien mil registros (algo normal en logs de un sitio web, transacciones de un mes en un e-commerce, o eventos de una app), Excel no lo abre. pandas sí, hasta donde aguante la RAM de tu ordenador (computadora). Eso suele ser entre 5 y 50 millones de filas dependiendo del número de columnas.
2. 02.Reproducibilidad. Cuando haces un análisis en Excel — filtros, fórmulas, copiar-pegar, un gráfico — el resultado final no deja rastro del proceso. Si alguien te pregunta "¿cómo llegaste a ese número?", tienes que acordarte. En pandas, el proceso ES el código. Puedes leerlo, auditarlo, y ejecutarlo de nuevo mañana con datos nuevos y obtener el mismo resultado. Eso se llama reproducibilidad, y es lo que separa un análisis serio de una intuición con forma de número.
3. 03.Automatización. El informe del lunes que tardas 45 minutos en preparar a mano — abrir el CSV, filtrar, calcular, formatear, enviar — en pandas es un script que se ejecuta solo con un programador de tareas (cron en Mac y Linux, Programador de tareas en Windows). Escribes el proceso una vez. A partir de ahí, cada lunes a las 7:00 el informe está listo sin que tú hagas nada. Tu lunes empieza 45 minutos antes.

### Cuando la hoja de cálculo sigue siendo la respuesta correcta

Y ahora la parte que muchos cursos de Python omiten por orgullo: hay situaciones donde la hoja de cálculo es la herramienta correcta y pandas no. Ignorar esto no te hace mejor analista; te hace alguien que tarda 20 minutos en escribir un script para algo que se resuelve en 30 segundos con doble clic.

• ▹Exploración rápida y puntual. Tu jefe te pasa un CSV de 200 filas y quiere una respuesta en 5 minutos. Abrir Excel, echar un ojo, filtrar dos cosas y responder es más rápido que abrir un Jupyter Notebook. Si la pregunta es única y no se va a repetir, la hoja gana.
• ▹Compartir con personas no técnicas. El director financiero no va a ejecutar un script de Python. Le pasas un Excel con colores, una pestaña de resumen y un gráfico, y lo entiende en 10 segundos. pandas es para ti; el Excel formateado es para él.
• ▹Presupuesto cero de infraestructura. No necesitas instalar nada. No necesitas Python, ni pip, ni un entorno virtual. Cualquier ordenador del mundo tiene un programa que abre hojas de cálculo. Eso tiene un valor enorme cuando el contexto es una pyme sin equipo técnico.
• ▹Edición manual de datos pequeños. Si tienes que corregir 15 celdas a mano porque los datos vinieron mal, hacerlo en Excel es sensato. Escribir un script que detecte y corrija esos 15 errores concretos es sobreingeniería si no se va a repetir.

### El patrón mental: pregunta antes de herramienta

Antes de abrir Excel o escribir import pandas, hazte estas cuatro preguntas. La respuesta te dice qué herramienta usar:

1. 01.¿Se va a repetir? Si es un informe semanal o un cálculo que harás cada mes, pandas. Si es una pregunta puntual que no volverá, la hoja.
2. 02.¿Cuántas filas tiene? Menos de 100.000 y no se repite: la hoja funciona bien. Más de 500.000: pandas o SQL, sin discusión.
3. 03.¿Alguien más va a usar el resultado? Si es para ti, lo que sea más rápido. Si es para un equipo, necesitas reproducibilidad: pandas con un script versionado.
4. 04.¿Necesito auditar el proceso? Si alguien puede preguntarte "¿cómo llegaste a ese número?" y necesitas poder demostrarlo, el código es tu única opción. Una hoja de cálculo no deja rastro fiable del proceso.

Estas cuatro preguntas te van a ahorrar horas de trabajo innecesario. Un buen analista no es el que usa la herramienta más compleja: es el que usa la correcta para cada situación. Y a veces, la correcta es una hoja de cálculo con tres fórmulas.

### Resumen: tu mapa de traducción en una frase

Todo lo que haces en una hoja de cálculo tiene un nombre en pandas. La estructura es la misma (tabla con filas y columnas). Las operaciones son las mismas (filtrar, ordenar, calcular, agrupar, cruzar). Lo que cambia es el medio: en vez de ratón y fórmulas arrastradas, usas código. Y ese código te da tres cosas que la hoja no puede: escala para millones de filas, reproducibilidad para que cualquiera repita tu trabajo, y automatización para que el trabajo se haga solo.

En las siguientes lecciones vas a profundizar en cada una de estas operaciones: leer ficheros de distintos formatos, seleccionar y filtrar con precisión, crear columnas calculadas, agrupar con groupby, y combinar tablas con merge. Esta lección es tu mapa. Las siguientes son el terreno.