Conceptos básicos de análisis de datos

10 ejemplos para empezar con el análisis de datos: 7 básicos y 3 intermedios.

Prerrequisitos

• Python 3.14.0 con pandas 2.2+ y NumPy instalados.
• Configuración rápida: uv pip install "pandas>=2.2" "numpy>=2.0" "pyarrow>=18"

Ejemplos básicos

1. Creación de arrays de NumPy

Crea un array numérico homogéneo y ejecuta operaciones matemáticas vectorizadas.

import numpy as np
 
sales = np.array([120, 340, 280, 410], dtype=np.int32)
bonus = sales * 0.1
print(bonus.dtype, bonus.sum())

• Los arrays de NumPy almacenan un dtype por eje; mezclar tipos fuerza la conversión.
• Las operaciones vectorizadas evitan bucles de Python y se ejecutan en C compilado.
• dtype controla la memoria y la precisión; selecciónalo deliberadamente.

Relacionado: Arrays de NumPy - dtypes y broadcasting

2. Series y DataFrame de pandas

Encapsula datos etiquetados en estructuras de pandas.

import pandas as pd
 
revenue = pd.Series([120, 340, 280], index=["Jan", "Feb", "Mar"], name="revenue")
df = pd.DataFrame({"region": ["East", "West", "East"], "revenue": revenue.values})
print(df.dtypes)

• Una Series es una sola columna con un índice.
• Un DataFrame es una tabla de Series alineadas que comparten el mismo índice.
• .dtypes revela si las columnas son numéricas, de cadena o categóricas.

Relacionado: Series y DataFrames de pandas - construcción y selección

3. Leer CSV e inspeccionar

Carga un archivo y prodúcelo antes de transformarlo.

import pandas as pd
from io import StringIO
 
csv = "date,region,revenue\n2025-01-01,East,120\n2025-01-02,West,340\n"
df = pd.read_csv(StringIO(csv), parse_dates=["date"])
print(df.info())
print(df.isna().sum())

• parse_dates almacena las fechas como dtypes correctos, no como cadenas.
• info() muestra recuentos no nulos y uso de memoria.
• Cuenta los valores faltantes por columna antes de agregar.

Relacionado: Limpieza y transformación de datos - valores faltantes y dtypes

4. Seleccionar filas y columnas

Utiliza indexación basada en etiquetas y en posición.

import pandas as pd
 
df = pd.DataFrame({"region": ["East", "West", "East"], "revenue": [120, 340, 280]})
east = df.loc[df["region"] == "East", ["region", "revenue"]]
first_row = df.iloc[0]

• .loc selecciona por etiquetas; .iloc selecciona por posición entera.
• Las máscaras booleanas filtran filas sin copiar todo el marco cuando es posible.
• Asigna siempre los resultados filtrados a una nueva variable o usa .copy() si vas a mutar.

Relacionado: Series y DataFrames de pandas - reglas de indexación

5. Manejar valores faltantes

Elimina o rellena huecos explícitamente.

import pandas as pd
import numpy as np
 
df = pd.DataFrame({"revenue": [120, np.nan, 280]})
filled = df["revenue"].fillna(df["revenue"].median())
dropped = df.dropna(subset=["revenue"])

• fillna con una estadística está bien para la exploración; documenta la política para producción.
• dropna elimina filas; verifica que no estés sesgando las agregaciones.
• pandas 2.x utiliza dtypes anulables (Int64) cuando necesitas enteros con NA.

Relacionado: Limpieza y transformación de datos - correcciones de dtype

6. Agregación GroupBy

Resume por categoría con split-apply-combine.

import pandas as pd
 
df = pd.DataFrame({"region": ["East", "West", "East"], "revenue": [120, 340, 280]})
summary = (
    df.groupby("region", observed=True)["revenue"]
    .agg(["sum", "mean", "count"])
    .reset_index()
)

• groupby divide las filas, aplica una función por grupo y combina los resultados.
• observed=True omite los niveles categóricos no utilizados en pandas 2.x.
• .reset_index() convierte la clave del grupo de nuevo en una columna normal.

Relacionado: GroupBy y agregación - tablas dinámicas

7. Fusionar dos tablas

Combina conjuntos de datos en una clave compartida.

import pandas as pd
 
orders = pd.DataFrame({"order_id": [1, 2], "region": ["East", "West"]})
revenue = pd.DataFrame({"order_id": [1, 2], "amount": [120, 340]})
merged = orders.merge(revenue, on="order_id", how="inner", validate="one_to_one")

• how="inner" mantiene solo las claves coincidentes; documenta lo que eliminas.
• validate detecta uniones accidentales de muchos a muchos de forma temprana.
• Comprueba los recuentos de filas antes y después de cada fusión.

Relacionado: Joins y fusiones - detección de duplicados

Ejemplos intermedios

8. Remuestrear una serie temporal

Agrega datos diarios a totales mensuales.

import pandas as pd
 
idx = pd.date_range("2025-01-01", periods=90, freq="D", tz="UTC")
df = pd.DataFrame({"revenue": range(90)}, index=idx)
monthly = df["revenue"].resample("ME").sum()

• Los índices de fecha y hora permiten la agrupación consciente del calendario a través de .resample.
• Almacena las marcas de tiempo en UTC; convierte a hora local solo para visualización.
• "ME" es la frecuencia de fin de mes en pandas moderno.

Relacionado: Series temporales - ventanas móviles y zonas horarias

9. Escaneo perezoso de Polars

Retrasa el trabajo y deja que el planificador de consultas optimice la E/S.

import polars as pl
 
lf = pl.scan_parquet("sales.parquet")
result = (
    lf.filter(pl.col("region") == "East")
    .group_by("month")
    .agg(pl.col("revenue").sum().alias("total"))
    .collect()
)
print(result)

• Los marcos perezosos de Polars empujan los filtros hacia abajo antes de leer todas las columnas.
• .collect() ejecuta el plan; mantén la lógica perezosa hasta que necesites datos materializados.
• Polars 1.x utiliza el diseño de memoria Apache Arrow para operaciones de columna rápidas.

Relacionado: Polars - patrones de evaluación perezosa

10. dtypes eficientes en memoria

Reduce un marco amplio antes de que agote la RAM.

import pandas as pd
 
df = pd.read_csv("large.csv", dtype={"region": "category", "units": "int32"})
df["revenue"] = pd.to_numeric(df["revenue"], downcast="float")
print(df.memory_usage(deep=True).sum() / 1e6, "MB")

• category almacena cadenas repetidas una vez, ideal para columnas de baja cardinalidad.
• downcast elige el dtype numérico más pequeño que se ajusta a tus valores.
• Mide con memory_usage(deep=True) después de cada carga pesada.

Relacionado: Rendimiento y memoria - fragmentación y Arrow

Versiones de la pila: Esta página se escribió para Python 3.14.0 (estable 3.14, mantenimiento 3.13), FastAPI 0.115+, Django 5.2, Flask 3.1, Pydantic 2, PyTorch 2.6+, pandas 2.2+, Polars 1.x, ruff 0.9+ y uv 0.6+.