39 · Series: arrays 1D etiquetados
Una Series de pandas es un array NumPy con un índice adjunto — las etiquetas habilitan aritmética consciente de alineación, acceso basado en etiquetas y los métodos de conveniencia que hacen rápido el análisis exploratorio.
Una `pd.Series` es un ndarray NumPy más un **índice** — un array de etiquetas adjunto a cada valor. El índice habilita dos cosas que NumPy no puede hacer: acceso basado en etiquetas (`s.loc['alice']` en lugar de `s[0]`) y **aritmética alineada por índice** (sumar dos Series las alinea por etiqueta antes de computar, insertando `NaN` para cualquier etiqueta que aparezca solo en una de las dos). Esa alineación automática es lo que previene los silenciosos errores de 'fila desfasada' que plagan las pipelines de arrays simples.
Sin esto:
Sin entender la indexación de Series, combinar dos datasets por posición de fila en lugar de por etiqueta es un bug sutil y devastador — predicciones del modelo alineadas a las muestras equivocadas, etiquetas de clase adjuntas a los features incorrectos. La distinción `.loc` / `.iloc` es también la puerta de entrada para entender la indexación de DataFrame, y toda sesión de depuración en Pandas eventualmente vuelve a '¿cuál debería usar aquí?'
Una Series es la estructura de datos 1D fundamental de pandas. Piensa en ella como un array NumPy con una capa adicional: cada valor tiene una etiqueta (el índice). La etiqueta puede ser un string, un entero, una fecha — cualquier cosa hashable. Esta capa de etiquetas es lo que hace que las estructuras de datos de pandas sean diferentes de los arrays NumPy simples.
Cuando haces aritmética sobre dos arrays NumPy, NumPy los alinea por posición — el elemento 0 se empareja con el elemento 0. Cuando haces aritmética sobre dos Series, pandas los alinea por etiqueta — el valor etiquetado 'alice' en la primera Series se empareja con el valor etiquetado 'alice' en la segunda. Si una etiqueta aparece solo en una Series, el resultado para esa etiqueta es NaN. Este diseño previene toda una clase de bugs silenciosos.
Las Series tienen dos APIs de indexación:
.loc[etiqueta]— búsqueda basada en etiqueta. Usa la etiqueta tal como está escrita en el índice..iloc[i]— búsqueda basada en posición entera. Siempre 0-based, siempre por posición, independientemente de lo que contenga el índice.
Usar .loc en una Series con índice entero se ve igual que .iloc, lo cual es una trampa común. En caso de duda, sé explícito: usa .loc cuando quieras decir 'buscar por etiqueta' y .iloc cuando quieras decir 'buscar por posición'.
Python (in browser)
`pd.Series(dict)` crea una Series con las claves del dict como índice. `.idxmax()` devuelve la **etiqueta** del valor máximo — no la posición — que es exactamente lo que necesitas cuando el índice contiene nombres significativos como identificadores de modelos o nombres de features.
Python runs entirely in your browser via Pyodide (~6 MB on first Run, cached after).
Python (in browser)
`.loc['alice']` siempre encuentra a Alice independientemente de su posición en el índice. `.iloc[0]` siempre encuentra la posición 0 independientemente de la etiqueta. Cuando el índice es `['carol', 'alice', 'bob']`, `.iloc[0]` devuelve la puntuación de Carol — un bug silencioso si esperabas Alice. Siempre usa el accessor correcto según la intención.
Python runs entirely in your browser via Pyodide (~6 MB on first Run, cached after).
Python (in browser)
La alineación de índices es el superpoder de pandas y su mayor peligro. La inserción automática de `NaN` te dice exactamente dónde falta datos — nunca empareja silenciosamente las filas incorrectas. En una pipeline de ML en producción, un `NaN` inesperado después de una operación aritmética es casi siempre señal de una discrepancia de clave entre dos datasets.
Python runs entirely in your browser via Pyodide (~6 MB on first Run, cached after).
Python (in browser)
`s.isna().sum()` es el primer comando a ejecutar sobre cualquier columna de un nuevo dataset — te dice cuántos datos faltan. `.fillna(s.mean())` es la estrategia de imputación más simple (imputación por la media). `.dropna()` es apropiado cuando tienes suficientes datos para descartar filas; `.fillna()` es mejor cuando cada fila es valiosa.
Python runs entirely in your browser via Pyodide (~6 MB on first Run, cached after).
Python (in browser)
`.value_counts()` es el comando principal para verificar la **distribución de clases** antes de entrenar un clasificador. Una distribución desequilibrada (p. ej., 950 'cat' vs 50 'dog') te indica que debes aplicar ponderación de clases o sobremuestreo antes de ajustar — descubrir esto después del entrenamiento es costoso.
Python runs entirely in your browser via Pyodide (~6 MB on first Run, cached after).
Una Series `s` tiene índice `['b', 'a', 'c']` y valores `[10, 20, 30]`. ¿Qué devuelve `s.iloc[0]`?
- Una `pd.Series` es un ndarray NumPy más un índice. El índice habilita el acceso basado en etiquetas (`.loc`) y la aritmética consciente de alineación.
- `.loc[etiqueta]` busca por etiqueta; `.iloc[i]` busca por posición entera. Dan el mismo resultado solo cuando el índice es el `RangeIndex` por defecto.
- Sumar dos Series las alinea primero por etiqueta — los pares faltantes se convierten en `NaN`. Verifica `.isna().sum()` después de cualquier merge o aritmética para detectar huecos inesperados.
- `s.fillna(valor)` reemplaza `NaN` con una constante o valor computado; `s.dropna()` los elimina. `s.value_counts()` es la verificación de distribución de clases más rápida.
Cada columna de un DataFrame es una Series. `model.feature_importances_` de un árbol de scikit-learn es a menudo una Series con los nombres de los features como índice — `.sort_values(ascending=False)` muestra inmediatamente qué features importan más. `.value_counts()` es la primera verificación estándar sobre la columna objetivo para detectar desequilibrio de clases antes del entrenamiento.
Si lo quitas: Sin entender la distinción `.loc` / `.iloc`, combinar predicciones con etiquetas de verdad de referencia por posición de fila es un error fácil — especialmente después de ordenar o filtrar un DataFrame, lo que cambia el orden posicional sin cambiar las etiquetas. La alineación basada en etiquetas es la red de seguridad que hace reproducibles las pipelines de datos de pandas.