Cómo leer y procesar hojas de Excel con pandas y openpyxl: desde cero a pro

Si te dedicas al análisis de datos o necesitas automatizar tareas repetitivas en hojas de cálculo, combinar Python con Excel es una jugada ganadora para acelerar tu flujo de trabajo. Excel sigue siendo la herramienta reina en muchísimas empresas, y aprender a evitar que Excel convierta números en fechas, mientras que Python te da potencia, flexibilidad y un ecosistema de librerías pensado para datos. En esta guía vas a ver, con todo detalle, cómo leer y procesar hojas de Excel con pandas y openpyxl, cuándo usar cada una y cómo sacarles el máximo partido en situaciones reales.

Más allá de abrir un archivo y mirar un par de celdas, aquí vas a aprender a cargar hojas y rangos concretos, filtrar, transformar y guardar resultados, formatear celdas con estilos avanzados, crear libros y hojas nuevas, generar reportes automatizados y hasta levantar gráficos o pequeños dashboards. Iremos desde lo básico hasta ejemplos prácticos, con código listo para adaptar, y con recomendaciones de rendimiento y buenas prácticas para evitar cuellos de botella y errores típicos.

Preparación del entorno y librerías necesarias

Antes de ponerte manos a la obra, asegúrate de tener instalada una versión reciente de Python; se recomienda Python 3.7 o superior para garantizar compatibilidad con las librerías que usaremos. Para comprobar tu versión, puedes lanzar el siguiente comando en la terminal.

python --version

Para manipular Excel en Python, las bibliotecas clave que vas a usar son pandas y openpyxl; cada una cubre necesidades distintas. Con pip puedes instalarlas en un momento y comenzar a experimentar.

pip install pandas openpyxl

Si prefieres gestionar dependencias con un gestor como Poetry, también puedes instalar ambos paquetes con comandos simples, por ejemplo poetry add pandas y poetry add openpyxl, lo que te ayuda a mantener un entorno reproducible por proyecto sin dolores de cabeza.

Leer libros, hojas y celdas con openpyxl

La biblioteca openpyxl trabaja directamente sobre archivos .xlsx, permitiéndote abrir libros, manipular hojas y leer/escribir celdas con precisión. Es ideal cuando necesitas control fino del formato, aplicar estilos, fórmulas y trabajar con la estructura de Excel como tal.

from openpyxl import load_workbook

# Cargar un archivo Excel
workbook = load_workbook("example.xlsx")

# Ver nombres de hojas disponibles
print(workbook.sheetnames)

Una vez abierto el libro, puedes seleccionar una hoja por nombre y consultar valores concretos. Este enfoque es útil cuando quieres inspeccionar celdas puntuales o recorrer rangos sin convertir todo a una estructura tabular.

# Seleccionar una hoja concreta
sheet = workbook

# Leer el valor de una celda
valor = sheet.value
print(f"Valor de A1: {valor}")

Para iterar por filas o rangos, iter_rows es tu aliado. Puedes acotar filas y columnas y procesar cada celda. Si solo lees, activar el modo read-only reduce memoria y mejora la velocidad en archivos grandes.

# Recorrer las primeras 10 filas
for fila in sheet.iter_rows(min_row=1, max_row=10):
    valores = 
    print(" ".join(valores))

Leer y escribir datos con pandas de forma eficiente

Si tu objetivo es análisis y manipulación de datos, pandas es tu mejor baza. Convierte las hojas de Excel en DataFrames (tablas muy potentes) para filtrar, agregar, transformar y exportar resultados más rápido que con bucles manuales.

import pandas as pd

# Leer un Excel a DataFrame
df = pd.read_excel("datos.xlsx")

# Ver las primeras filas
print(df.head())

La función read_excel permite cargar hojas específicas, columnas concretas o saltar filas iniciales (muy útil para archivos con encabezados complejos o notas). Esto te da control y rendimiento porque evitas traer datos que no necesitas.

# Hoja específica
df = pd.read_excel("datos.xlsx", sheet_name="Hoja2")

# Importar solo ciertas columnas (por etiqueta de Excel o nombre de columna)
df = pd.read_excel("datos.xlsx", usecols=)  # Por letras

# Omitir filas del principio
df = pd.read_excel("datos.xlsx", skiprows=4)

Cuando termines de transformar tu DataFrame, lo puedes volcar a Excel con un solo método. Pasar index=False evita escribir el índice como columna adicional, algo muy común cuando preparas informes para negocio.

# Guardar el DataFrame en Excel
 df.to_excel("datos_procesados.xlsx", index=False)

Cuándo usar pandas y cuándo openpyxl

Aunque se complementan, no atacan el mismo problema: pandas brilla en el procesamiento masivo (filtrado, agregaciones, joins, limpieza), mientras que openpyxl manda en el formato (estilos, bordes, anchos, fórmulas, gráficos, creación/eliminación de hojas, etc.). Elegir bien te ahorra tiempo.

Si necesitas modificar miles de celdas con una regla sencilla (por ejemplo, sumar un 10% a una columna), con pandas lo harás en una línea; en openpyxl requerirás recorrer celdas con bucles y gestionar referencias. En cambio, si quieres aplicar un formato corporativo, estilos o añadir gráficos dentro del Excel final, openpyxl es lo suyo.

Una estrategia muy útil es combinar ambas: procesa con pandas y, una vez generada la tabla final, usa openpyxl para pulir el acabado profesional (negritas, cabeceras centradas, colores, formatos numéricos, etc.). Así tienes rendimiento y un resultado listo para presentar.

Operaciones habituales con pandas: selección, filtrado y modificaciones

Con pandas, la selección por columnas y el filtrado condicional son pan comido. Esto te permite transformar datasets grandes con operaciones vectorizadas sin escribir bucles, logrando código más legible y rápido.

import pandas as pd

archivo_excel = "ejemplo_excel.xlsx"
df = pd.read_excel(archivo_excel)

# Selección de columnas
df_col = df]

# Filtrado por condición
filtrado = df > 10]

# Nuevas columnas y transformaciones
df = df * 2
df = df.apply(lambda x: x + 5)

# Guardar resultado
df.to_excel("resultado_excel.xlsx", index=False)

Para inspeccionar solo una parte, puedes usar .head() o el indexado .iloc cuando necesitas filas/columnas por posición. Además, al exportar, pandas soporta múltiples formatos (CSV, parquet, etc.), lo que te abre opciones más allá de Excel. También es habitual complementar pandas con guías sobre operaciones aritméticas en Excel cuando se migra lógica entre ambos entornos.

Lectura y edición con openpyxl: de celdas a rangos

Si el foco es el documento Excel como tal, openpyxl te permite crear libros, añadir hojas, renombrarlas y eliminar las que no necesitas. Este control detallado es esencial cuando debes adaptarte al layout de una plantilla o mantener fórmulas existentes.

from openpyxl import Workbook, load_workbook

# Crear un libro nuevo
ewb = Workbook()
ws = ewb.active
ws.title = "Hoja Principal"
ewb.save("nuevo.xlsx")

# Cargar y manipular un libro existente
wb = load_workbook("datos_openpyxl.xlsx")
wb.create_sheet("Nueva Hoja")
del wb
wb.save("datos_openpyxl.xlsx")

Acceder a celdas individuales o a rangos es directo. También puedes leer, cambiar valores y escribir de vuelta. Para cambios masivos, usar rangos y tener clara la estructura del Excel te facilitará el trabajo.

ws = wb
celda = ws
print(celda.value)

# Modificar valores
ws = "Nuevo Nombre"

# Recorrer un rango
for fila in ws:
    for c in fila:
        print(c.value)

Aplicar estilos, formatos y números con openpyxl

Una de las ventajas de openpyxl es que puedes vestir tu reporte con fuentes, bordes, rellenos y alineaciones, además de formatos numéricos (como dos decimales). Esto es clave para reportes que verán personas no técnicas.

from openpyxl.styles import Font, Border, Side, PatternFill, Alignment

ws = wb

# Estilos
fuente = Font(name="Arial", size=12, bold=True, color="FF000000")
borde = Border(left=Side(style="thin"), right=Side(style="thin"),
               top=Side(style="thin"), bottom=Side(style="thin"))
relleno = PatternFill(start_color="FFFF0000", end_color="FFFF0000", fill_type="solid")

# Aplicar a una celda
c = ws
c.font = fuente
c.border = borde
c.fill = relleno
c.alignment = Alignment(horizontal="center", vertical="center")
c.number_format = "0.00"  # Dos decimales

wb.save("datos_openpyxl.xlsx")

También puedes introducir fórmulas de Excel directamente en las celdas, que se recalcularán cuando el archivo se abra en Excel. Ten en cuenta los errores más comunes en fórmulas de Excel, que suelen aparecer al mezclar datos generados por código y lógica de hoja de cálculo.

ws.value = "=SUM(A1:B1)"
wb.save("datos_openpyxl.xlsx")

Gráficos y visualizaciones simples en Excel con openpyxl

Para completar un informe, a veces necesitas incluir un gráfico dentro del propio libro. Con openpyxl puedes crear gráficos de barras, líneas u otros a partir de rangos de datos y colocarlos en una ubicación concreta.

from openpyxl.chart import BarChart, Reference

chart = BarChart()
datos = Reference(ws, min_col=1, min_row=1, max_col=2, max_row=5)
chart.add_data(datos, titles_from_data=False)
ws.add_chart(chart, "E1")
wb.save("datos_openpyxl.xlsx")

Automatización de reportes: combinar pandas y openpyxl

Una receta muy útil es procesar datos con pandas (totales, medias, agrupaciones) y volcar resultados a un nuevo libro, que luego decoras con openpyxl para entregar un reporte con buen formato. Este patrón escala bien para reportes periódicos.

import pandas as pd
from openpyxl import Workbook
from openpyxl.styles import Font, Alignment

# Leer ventas
ventas = pd.read_excel("ventas.xlsx")

# Agregaciones
por_producto = ventas.groupby("Producto").sum()
promedio = ventas.mean()

# Crear libro de reporte
wb = Workbook()
ws = wb.active
ws.title = "Reporte de Ventas"

# Cabeceras
ws = "Producto"
ws = "Total Ventas"
ws = "Promedio Ventas Mensual"

enc = Font(bold=True)
for celda in ("A1", "B1", "C1"):
    ws.font = enc
    ws.alignment = Alignment(horizontal="center")

# Datos
fila = 2
for producto, total in por_producto.items():
    ws = producto
    ws = total
    ws = promedio
    fila += 1

wb.save("reporte_ventas.xlsx")

Si además quieres dar coherencia visual, añade bordes finos y formatos numéricos a las columnas de importes. Así tu informe queda listo para ser compartido sin retoques manuales en Excel; y si necesitas automatizar el relleno, puedes apoyarte en técnicas para rellenar datos automáticamente según patrones.

Procesos típicos: filtrar, transformar y guardar con pandas

Un caso habitual es filtrar por una condición y guardar el resultado en un nuevo archivo. Esto se hace en unas pocas líneas con pandas y resulta ideal para pipelines de limpieza o preparación de datos para equipos de negocio.

import pandas as pd

df = pd.read_excel("example.xlsx")

# Filtrar ventas > 1000
filtrado = df > 1000]

# Guardar sin índice
filtrado.to_excel("filtered.xlsx", index=False)
print("Archivo guardado")

Si necesitas mantener una columna original y crear otra modificada (por ejemplo, sumar un 10% a «Área Total»), la operación vectorizada evita bucles y te deja un DataFrame limpio y fácil de inspeccionar.

df = pd.read_excel("cultivos.xlsx")

df = df
df = df * 1.1

# Mostrar primeras 10 filas a partir de la tercera columna
print(df.iloc)

Si además prefieres ocultar temporalmente resultados en el archivo final en lugar de borrarlos, considera reglas para ocultar filas según el valor de la celda y facilitar la revisión por equipos.

Eliminar filas y limpieza de datos

Otra tarea frecuente es eliminar registros por posición o por condición. Con pandas, borrar las primeras 10 filas es directo usando el índice; para filtros más complejos, usa expresiones booleanas sin for-loops.

df = pd.read_excel("cultivos.xlsx")

# Quitar las 10 primeras filas por índice
df.drop(df.index, inplace=True)
print(df.head(10))

Si tu limpieza depende de reglas como «borrar filas con Área Total par», puedes construir una condición y aplicarla, manteniendo el código expresivo y mantenible frente a bucles y contadores manuales. Y si la hoja está protegida, recuerda cómo desproteger una hoja Excel con contraseña antes de modificarla.

Edición y borrado con openpyxl: celdas y filas

Cuando trabajas con openpyxl, modificar una columna entera implica recorrer celdas. La ventaja es que puedes insertar columnas nuevas, respetar el layout original y guardar en otro archivo sin romper el formato.

from openpyxl import load_workbook
from openpyxl.utils import get_column_letter

wb = load_workbook("cultivos.xlsx")
ws = wb

# Insertar columna G y titularla
ws.insert_cols(7)
ws = "Area Total Modificada"

# Sumar 10% a la columna F y guardar antiguo valor en G
for fila in ws.iter_rows(min_row=2):
    valor_antiguo = None
    for celda in fila:
        col = get_column_letter(celda.column)
        if col == "F":
            valor_antiguo = celda.value
            celda.value = float(celda.value) * 1.1
        if col == "G":
            celda.value = valor_antiguo

wb.save("cultivos_modify.xlsx")

Para eliminar filas por posición, openpyxl también lo resuelve con una llamada, aunque para condiciones avanzadas tendrás que iterar y decidir qué borrar según el contenido de cada fila.

wb = load_workbook("cultivos.xlsx")
ws = wb

# Eliminar las 10 primeras filas (ajusta idx si hay cabeceras)
ws.delete_rows(idx=1, amount=10)
wb.save("cultivos_modify.xlsx")

Consolidar múltiples archivos Excel en uno solo

Un clásico: tienes decenas de ficheros .xlsx con el mismo esquema y quieres unirlos en una sola tabla para analizarlos. Con pandas y glob lo tienes en un par de líneas, sin abrir manualmente cada archivo.

import pandas as pd
import glob

excel_files = glob.glob("*.xlsx")

# Concatenar todo en un DataFrame
todos = pd.concat(, ignore_index=True)

todos.to_excel("consolidated_data.xlsx", index=False)

Este enfoque es perfecto para integraciones mensuales, informes multidelegación o cualquier proceso en el que recibes múltiples libros con estructura homogénea.

Generar informes por departamento automáticamente

Desde un archivo con ventas globales, puedes segmentar por departamento y generar un informe personalizado para cada uno de forma automática. Cada fichero queda listo para compartirse con su equipo.

import pandas as pd

sales = pd.read_excel("sales_data.xlsx")
departamentos = sales.unique()

for dpto in departamentos:
    df_dpto = sales == dpto]
    df_dpto.to_excel(f"{dpto}_report.xlsx", index=False)

Si además necesitas aplicar formato a cada reporte, puedes cargar el archivo resultante con openpyxl y dar estilo a cabeceras, ajustar anchos de columna y añadir un color corporativo. También puedes automatizar la organización de los ficheros y crear carpetas y subcarpetas en cascada para cada departamento.

Pequeño dashboard interactivo con Tkinter y pandas

Para prototipos rápidos, puedes crear una ventana simple que muestre columnas y calcule el promedio de la seleccionada. No es un BI completo, pero sirve para validaciones express sin salirte de Python.

import tkinter as tk
import pandas as pd
from tkinter import messagebox

file = "data.xlsx"
data = pd.read_excel(file)

def calcular_media():
    col = listbox.get(listbox.curselection())
    media = data.mean()
    messagebox.showinfo("Resultado", f"Promedio en {col}: {media:.2f}")

root = tk.Tk()
root.title("Dashboard interactivo")

listbox = tk.Listbox(root)
listbox.pack()
for c in data.columns:
    listbox.insert(tk.END, c)

btn = tk.Button(root, text="Calcular promedio", command=calcular_media)
btn.pack()

root.mainloop()

Para proyectos de reporting más complejos quizá te interese mover esto a una app web con Streamlit o Dash, pero para una utilidad local rápida, Tkinter puede sacarte del apuro con muy poco código.

Análisis exploratorio: estadísticas y gráficos con pandas + Matplotlib

Cuando tu Excel contiene información de clientes o ventas, conviene hacer un vistazo rápido a distribuciones y relaciones. Con pandas puedes obtener estadísticas descriptivas y, con Matplotlib, generar histogramas y diagramas de dispersión muy útiles.

import pandas as pd
import matplotlib.pyplot as plt

clientes = pd.read_excel("clientes.xlsx")

# Estadísticas generales
print(clientes.describe())

# Histograma de edades
clientes.hist(bins=20)
plt.xlabel("Edad")
plt.ylabel("Frecuencia")
plt.title("Distribución de edades")
plt.show()

# Dispersión ingresos vs satisfacción
clientes.plot.scatter(x="Ingresos", y="Satisfaccion")
plt.xlabel("Ingresos")
plt.ylabel("Satisfacción")
plt.title("Ingresos vs. Satisfacción")
plt.show()

Con esto puedes detectar valores extremos, sesgos o relaciones interesantes para profundizar después. Si quieres reportarlo en Excel, exporta tablas resumen con pandas y crea gráficos in-book con openpyxl para un entregable redondo. Para análisis estadísticos concretos también puedes consultar la función cuartil en Excel como referencia al migrar indicadores.

Guardar resultados con pandas y openpyxl

Con pandas, escribir a Excel es inmediato; además, tienes la ventaja de exportar a otros formatos como CSV o parquet. Si el archivo va para negocio, añade hojas con distintos detalles o datos filtrados por segmentos en el mismo libro.

df = pd.read_excel("cultivos.xlsx")

df = "SI"
df.to_excel("cultivos_modify_pandas.xlsx", index=False)

Si trabajas con openpyxl, recuerda que puedes crear columnas nuevas y rellenarlas por rango. Es una forma directa de marcar registros revisados en informes con estructura fija.

from openpyxl import load_workbook

wb = load_workbook("cultivos.xlsx")
ws = wb

ws = "Revisado"
for celda in ws:
    celda.value = "SI"

wb.save("cultivos_modify_openpyxl.xlsx")

Rendimiento y buenas prácticas

Para archivos grandes, conviene limitar la cantidad de datos que traes a memoria. En pandas, lee solo las columnas necesarias con usecols y evita procesar hojas irrelevantes. En openpyxl, usa read_only=True para leer y write_only=True para escribir.

Vigila los tipos de datos: a veces Excel guarda números como texto y eso puede romper filtros y agregaciones. Al cargar con pandas, puedes especificar dtypes o normalizar columnas después de leer para evitar sorpresas con fechas, importes o IDs.

Con fórmulas de Excel, recuerda que no todas las funciones están soportadas del mismo modo por las librerías; lo más seguro es que se recalculen al abrir en Excel. Si necesitas valores fijos, evalúa primero con pandas y escribe números ya calculados.

En cuanto a compatibilidad, prioriza archivos .xlsx (formato moderno) y prueba tus scripts con distintas versiones de Excel cuando tus usuarios tengan entornos heterogéneos. Esto reduce incidencias por funciones o características no soportadas en versiones antiguas.

Como broche, piensa en pipelines reproducibles: fija dependencias (Poetry, requirements.txt), documenta tus parámetros (sheet_name, usecols, skiprows) y añade logs mínimos para depurar. Te ahorrarás tiempo cuando escale el proyecto o cambie el origen de datos.

Si llegaste hasta aquí, ya dominas la lectura, el procesado y la escritura de Excel con pandas y openpyxl, sabes cuándo conviene cada herramienta y cómo combinarlas para reportes profesionales. A partir de ahora verás tus hojas de cálculo como fuentes y destinos dentro de un flujo de trabajo robusto, automatizado y mucho más rápido.