Pandas en Python: la guía para analizar datos desde cero

Qué es y por qué se usa tanto

Pandas es la librería que convierte a Python en una herramienta de análisis de datos. Sin ella, trabajar con una tabla en Python sería un ejercicio de bucles y listas; con ella, es casi tan directo como en Excel pero sin sus límites.

Lo que la hace estándar es la combinación de tres cosas: maneja volúmenes que Excel no aguanta, todo queda escrito y por lo tanto es reproducible, y se conecta con el resto del ecosistema (gráficos, modelos, bases de datos).

import pandas as pd

Ese pd es una convención universal. Todo el código de pandas que veas en internet lo usa, así que conviene adoptarla.

El DataFrame: una tabla con superpoderes

Un DataFrame es la estructura central de pandas: filas, columnas con nombre y un tipo de dato por columna. Es una hoja de cálculo dentro de Python.

Una columna sola es una Serie. Un DataFrame es un conjunto de Series que comparten el mismo índice.

Para leer datos:

df = pd.read_csv("ventas.csv")
df = pd.read_excel("ventas.xlsx", sheet_name="Enero")

Un detalle que resuelve el 90 por ciento de los problemas al leer archivos de la región: si el CSV viene con punto y coma o con acentos rotos, se arregla con parámetros.

df = pd.read_csv("ventas.csv", sep=";", encoding="latin-1")

Lo primero que se hace siempre

df.head()        # las primeras 5 filas
df.shape         # cuántas filas y columnas
df.info()        # tipos de dato y cuántos nulos hay
df.describe()    # estadísticas de las columnas numéricas
df.columns       # los nombres de las columnas

Todo esto se puede ejecutar sin instalar nada desde Google Colab, que ya trae pandas listo.

Este bloque lo corro siempre antes de cualquier análisis, y en ese orden. info() es el más importante de los cinco: te dice de un vistazo si una columna que debería ser número quedó como texto, y cuántos valores faltan.

Ese chequeo de tipos evita el error más común del análisis en Python: intentar sumar una columna que pandas leyó como texto porque tenía un símbolo de moneda o una coma.

Seleccionar y filtrar

df["ciudad"]                    # una columna
df[["ciudad", "total"]]         # varias columnas

df[df["total"] > 1000]                          # filtro simple
df[(df["ciudad"] == "Lima") & (df["total"] > 1000)]   # dos condiciones

Dos reglas que hay que memorizar de los filtros con varias condiciones: se usa & para "y" y | para "o" (no las palabras and y or), y cada condición va entre paréntesis. Olvidar los paréntesis es el error número uno y produce un mensaje que no ayuda nada.

Para seleccionar por etiqueta o por posición están loc e iloc:

• loc trabaja con nombres: df.loc[0, "ciudad"].
• iloc trabaja con posiciones: df.iloc[0, 2] es la primera fila, tercera columna.

La forma de recordarlo: la i de iloc es de index, o sea posición numérica.

Agrupar: el equivalente a la tabla dinámica

df.groupby("ciudad")["total"].sum()

df.groupby("ciudad").agg({
    "total": "sum",
    "id_pedido": "count"
})

El primero suma las ventas por ciudad. El segundo calcula dos cosas a la vez: la suma del total y el conteo de pedidos, por ciudad.

Es exactamente la misma lógica del GROUP BY de SQL y de una tabla dinámica de Excel. Si entiendes uno, entiendes los tres: cambia la sintaxis, no el concepto.

Y para contar categorías hay un atajo que se usa constantemente:

df["ciudad"].value_counts()

Devuelve cuántas veces aparece cada valor, ordenado de mayor a menor. Es lo primero que corro sobre cualquier columna categórica que no conozco.

Unir tablas con merge

resultado = pd.merge(pedidos, clientes, on="id_cliente", how="left")

Es el JOIN de SQL con otro nombre. El parámetro how acepta los mismos valores: inner, left, right y outer, con exactamente el mismo comportamiento.

Y la misma advertencia: si la columna de unión tiene valores repetidos en la tabla derecha, las filas se multiplican. Compara df.shape antes y después del merge. Si el número de filas creció, tienes duplicados.

Para apilar tablas con las mismas columnas, en vez de unirlas por una llave, se usa pd.concat([df1, df2]).

Limpiar: nulos y duplicados

df.isnull().sum()          # cuántos nulos por columna
df.dropna()                # elimina filas con nulos
df["ciudad"].fillna("Sin dato")   # rellena los nulos

df.duplicated().sum()      # cuántas filas duplicadas
df.drop_duplicates()       # las elimina

Sobre los nulos, la decisión importa más que el comando: eliminar filas con nulos parece limpio y puede sesgar el análisis. Si los clientes sin teléfono son justamente los que compran por otro canal, eliminarlos te deja con una muestra que no representa a nadie.

Antes de decidir, mira por qué faltan. Si faltan al azar, eliminar es aceptable. Si faltan por un motivo, ese motivo es información y hay que conservarla, aunque sea rellenando con una categoría explícita.

Y una cosa que confunde al inicio: casi todas estas funciones devuelven un DataFrame nuevo en vez de modificar el original. Si escribes df.dropna() sin asignar el resultado, no pasa nada. Hay que hacer df = df.dropna().

Preguntas frecuentes

Escrito por

Gera Flores (Miss Yera)

Consultora y experta en IA

Agenda 30 min con Gera Ver bio completa