Instalar Pandas y tu primer DataFrame

### El problema: datos que no caben en tu cabeza

Imagina esto: tu jefa te pasa un CSV con 50.000 filas de transacciones del último trimestre. Necesita un resumen por categoría antes de las 5. Podrías abrir Excel, esperar 30 segundos a que cargue, hacer filtros manuales, copiar-pegar subtotales... o podrías escribir 5 líneas de Python y tenerlo en 2 segundos. Esa es la diferencia que marca Pandas.

Pandas es la librería que transformó Python de "un lenguaje de programación más" al estándar de facto para manipulación de datos. La creó en 2008 Wes McKinney, mientras trabajaba en un fondo de inversión cuantitativa, y lo hizo por la razón más honesta que existe: estaba harto. Harto de mover datos en Excel copiando y pegando, y harto de las limitaciones de R para lo que él necesitaba — series temporales, cruzar tablas, alinear fechas, rellenar huecos. Son sus palabras, no una interpretación.

Y aquí está el detalle que hace la historia buena: R también fue de donde sacó la idea. El DataFrame — una tabla con columnas con nombre y con tipo — ya existía en R, y lo que hizo McKinney fue traerlo a Python. No estaba compitiendo con R: le estaba robando lo mejor y arreglando lo que le molestaba. Casi todas las herramientas que vas a usar nacieron así.

Y el nombre, que tiene doble fondo: viene de "panel data", el término de econometría para los datos que siguen a los mismos sujetos a lo largo del tiempo — justo lo que McKinney manipulaba en el fondo — y a la vez es un juego con "pan-da-s" (panel data + Python data analysis). No tiene nada que ver con el animal, aunque el logo haya acabado siendo un oso panda en la cabeza de mucha gente.

Piensa en Pandas como Excel con superpoderes. En Excel tienes filas y columnas, puedes filtrar, ordenar, hacer fórmulas. Pandas hace exactamente lo mismo pero: sin límite de filas (bueno, hasta que se acabe la RAM), reproducible (un script que puedes ejecutar mil veces), automatizable (puede correr solo cada noche) y combinable con el resto del ecosistema Python. Eso es un DataFrame: una tabla en memoria con nombre de columnas, tipos de datos y un arsenal de métodos para transformarla.

### Paso 1: Instalar Pandas

Vamos al grano. Asegúrate de tener tu entorno virtual activado (lo creamos en la lección de instalación de Python). Si no lo recuerdas: un entorno virtual es como una habitación limpia donde instalas solo lo que necesitas para un proyecto, sin contaminar el Python del sistema.

1# Activar el entorno virtual (si no lo tienes activo)
2# En Windows:
3.venv\Scripts\activate
4# En Mac/Linux:
5source .venv/bin/activate
6
7# Instalar Pandas (incluye NumPy como dependencia)
8pip install pandas==3.0.2
9
10# Verificar la instalación
11python -c "import pandas; print(pandas.__version__)"
12# Salida esperada: 3.0.2

Sobre la versión que acabas de clavar. Fíjate en que hemos instalado una versión concreta y no "la última". Eso es a propósito: si mañana sale una versión nueva que cambia algo, tu código sigue funcionando igual. Es la misma idea del requirements.txt que vas a ver al final de la lección.

Cuando instalas Pandas, pip también instala NumPy automáticamente (es una dependencia). NumPy es la librería de cálculo numérico sobre la que Pandas está construida. No necesitas saberlo todo sobre NumPy ahora, pero es bueno saber que está ahí debajo haciendo el trabajo pesado.

### Paso 2: Tu primer DataFrame — el "Hola Mundo" de Pandas

Un DataFrame es una tabla. Punto. Tiene filas (registros) y columnas (campos), igual que una tabla SQL o una hoja Excel. La diferencia es que vive en la memoria de Python y puedes manipularlo con código. Vamos a crear uno desde cero:

1import pandas as pd
2
3# Crear un DataFrame desde un diccionario
4ventas = pd.DataFrame({
5    'producto': ['Laptop', 'Mouse', 'Teclado', 'Monitor', 'Webcam'],
6    'categoria': ['Electrónica', 'Periféricos', 'Periféricos', 'Electrónica', 'Periféricos'],
7    'precio': [1200, 25, 45, 350, 60],
8    'unidades_vendidas': [150, 2000, 800, 300, 500]
9})
10
11# Ver las primeras filas
12print(ventas)
13print(f"\nForma: {ventas.shape}")  # (filas, columnas)
14print(f"Columnas: {list(ventas.columns)}")

La convención universal es importar pandas como pd. Verás esto en el 99% del código Python de datos del mundo. Es como decir "a partir de ahora, cuando diga pd me refiero a pandas". Menos tecleo, mismo resultado.

### Anatomía de un DataFrame

### Operaciones básicas: seleccionar, filtrar, agregar

Ahora que tienes una tabla en memoria, vamos a hacer con ella lo que harías en SQL: seleccionar columnas, filtrar filas y calcular agregados. La sintaxis es distinta pero la lógica es la misma.

1import pandas as pd
2
3ventas = pd.DataFrame({
4    'producto': ['Laptop', 'Mouse', 'Teclado', 'Monitor', 'Webcam'],
5    'categoria': ['Electrónica', 'Periféricos', 'Periféricos', 'Electrónica', 'Periféricos'],
6    'precio': [1200, 25, 45, 350, 60],
7    'unidades_vendidas': [150, 2000, 800, 300, 500]
8})
9
10# SELECCIONAR una columna (como SELECT columna FROM tabla)
11print(ventas['producto'])
12
13# FILTRAR filas (como WHERE)
14caros = ventas[ventas['precio'] > 100]
15print(caros)
16
17# AGREGAR (como GROUP BY + SUM)
18por_categoria = ventas.groupby('categoria')['precio'].mean()
19print(por_categoria)
20
21# Crear columna calculada
22ventas['ingresos'] = ventas['precio'] * ventas['unidades_vendidas']
23print(ventas[['producto', 'ingresos']].sort_values('ingresos', ascending=False))

### Inspeccionar tus datos: los primeros 30 segundos

Cada vez que cargues un dataset nuevo (y lo harás cientos de veces), lo primero es inspeccionarlo. Estos son los 5 métodos que ejecutarás SIEMPRE antes de hacer nada más:

1# Los 5 métodos de inspección que usarás siempre
2# Ojo: en un cuaderno Jupyter basta escribir df.head() y se muestra sola.
3# En un script hay que poner print() — un script solo escribe lo que le mandas.
4df = ventas
5
6# 1. Primeras filas — ¿qué pinta tienen los datos?
7print(df.head())
8
9# 2. Forma — ¿cuántas filas y columnas?
10print(f"Shape: {df.shape}")
11
12# 3. Tipos de dato — ¿los números son números?
13print(df.dtypes)
14
15# 4. Resumen estadístico — ¿hay valores raros?
16print(df.describe())
17
18# 5. Nulos — ¿falta información?
19print(df.isnull().sum())

### DataFrame vs Series: la diferencia clave

Un DataFrame es una tabla (2D). Una Series es una columna (1D). Cuando seleccionas una sola columna de un DataFrame, obtienes una Series. Cuando seleccionas varias, obtienes otro DataFrame. Es como la diferencia entre una fila de Excel y la hoja entera.

1# Esto devuelve una Series (1D)
2precios = ventas['precio']
3print(type(precios))  # <class 'pandas.core.series.Series'>
4
5# Esto devuelve un DataFrame (2D)
6subset = ventas[['producto', 'precio']]
7print(type(subset))  # <class 'pandas.core.frame.DataFrame'>
8
9# Las Series tienen métodos numéricos directos
10print(f"Media: {precios.mean()}")
11print(f"Máximo: {precios.max()}")
12print(f"Suma: {precios.sum()}")

### El fichero requirements.txt

En un proyecto real, no instalas dependencias a mano cada vez. Creas un archivo requirements.txt que lista todas las librerías con sus versiones. Cualquier persona del equipo puede replicar tu entorno con un solo comando.

1# Crear el requirements.txt
2echo "pandas==3.0.2" > requirements.txt
3
4# En el futuro, instalar todo de golpe:
5pip install -r requirements.txt
6
7# Para exportar TODO lo que tienes instalado:
8pip freeze > requirements.txt

### Resumen: lo que te llevas de aquí

1. Un DataFrame son tres cosas: índice, columnas y datos. Cada columna es una Series, y una Series es lo que obtienes al seleccionar una sola columna. Si te acuerdas de esto, la mitad de los errores de pandas se explican solos: casi siempre es que tenías una Series donde creías tener un DataFrame, o al revés.

2. Lo que sabes de SQL se traduce casi entero. Seleccionar es df["columna"], filtrar es df[df["col"] > x], agrupar y agregar es df.groupby("col")["otra"].mean(). La lógica es la misma; solo cambia cómo se escribe.

3. Los cinco comandos de inspección van siempre primero, antes de calcular nada: .head(), .shape, .dtypes, .describe() y .isnull().sum(). Son treinta segundos y te ahorran presentar un informe con una columna de números que en realidad era texto.

4. Pandas lo carga todo en memoria. Es su gran ventaja — por eso es rápido — y su límite. Con ficheros de más de uno o dos gigas, toca otra herramienta.