Automatización de Excel con Python que va más allá de la edición básica

Cada mes trae el mismo trabajo en Excel: descargar los archivos de ventas regionales, pegarlos en un libro maestro, actualizar los totales, marcar cualquier cosa que parezca incorrecta, enviar el PDF por correo y archivar las copias del mes pasado. Nada de esto es difícil, y ese es precisamente el problema: el trabajo es repetitivo, propenso a errores cuando se hace a mano y crece silenciosamente a medida que aumenta el número de archivos. La automatización de Excel con Python reemplaza esos pasos manuales recurrentes con scripts que leen, actualizan, combinan, verifican y entregan libros de trabajo de forma programada.

Esta guía muestra cada una de esas tareas implementadas con Spire.XLS for Python 16.8.2 (el paquete independiente de Python en PyPI), desde la edición de una celda en cinco líneas hasta una canalización programada que recalcula fórmulas y entrega PDF. Cada fragmento de código que aparece a continuación se ejecutó, y sus archivos de salida se abrieron y verificaron, antes de publicarse. A lo largo del texto también se indica dónde encajan las otras bibliotecas habituales, para que pueda ver las ventajas y desventajas en lugar de un folleto de producto.

Elegir una biblioteca de Python para la automatización de Excel

La automatización de Excel con Python es una buena opción cuando una tarea se repite según un calendario, sigue reglas fijas y trabaja con archivos en lugar de criterio humano: el ensamblaje de informes mensuales, las comprobaciones semanales de datos, la actualización de cifras en una plantilla o la conversión de libros para sistemas posteriores. Si una tarea cambia de forma cada vez o necesita una decisión humana en el medio, automatizarla costará más de lo que ahorra. Una nota sobre los límites: esta guía abarca el procesamiento de archivos de Excel. Automatizar la generación de documentos de Excel a PowerPoint o de Excel a Word es un tema relacionado pero distinto.

La elección de la biblioteca depende de la tarea. La siguiente tabla resume las cinco bibliotecas que encontrará con más probabilidad; cada una ocupa una línea porque cada una tiene su especialidad.

pandas es difícil de superar para el análisis que ya encaja en una tabla, openpyxl para las ediciones a nivel de celda, XlsxWriter para escribir libros nuevos y xlwings para manejar Excel en sí. Cada una se centra en una parte distinta del flujo de trabajo, y combinarlas implica dependencias adicionales y trabajo de integración entre modelos de objetos diferentes. Spire.XLS ofrece una única API que abarca la lectura, la edición, el cálculo, la conversión y la protección en los formatos compatibles: los ejemplos siguientes mantienen todo en una sola.

Si está comparando las bibliotecas en profundidad en lugar de buscar código de implementación, consulte nuestra comparativa en la mejor biblioteca de Excel para Python.

Leer y actualizar libros de Excel con Python

La tarea de automatización más común es también la más sencilla: cargar un libro, cambiar algunas celdas y guardarlo. Instale primero el paquete con pip install Spire.XLS; después, todo el trabajo cabe en unas pocas líneas:

from spire.xls import Workbook, FileFormat

wb = Workbook()
wb.LoadFromFile("sales.xlsx")          # load the template
ws = wb.Worksheets[0]

ws.Range["B2"].NumberValue = 150       # update an existing cell
ws.Range["A6"].Text = "Widget E"       # append a new row
ws.Range["B6"].NumberValue = 45
ws.Range["C6"].NumberValue = 11.75
ws.Range["D6"].Formula = "=B6*C6"      # formulas can be written
ws.Range["D6"].NumberFormat = "#,##0.00"

wb.SaveToFile("sales_updated.xlsx", FileFormat.Version2016)
wb.Dispose()                           # release the workbook

Vale la pena conocer algunas convenciones de lectura antes de construir sobre esto. En la API de Spire.XLS, Range[addr].NumberValue devuelve el valor numérico de una celda y NaN cuando la celda contiene texto o nada; Range[addr].Text devuelve la cadena mostrada; y en el caso de las celdas con fórmula, Range[addr].Formula devuelve la cadena de la fórmula mientras que FormulaNumberValue devuelve el resultado calculado. Escribir una fórmula mediante .Formula almacena la fórmula en sí; para persistir su resultado calculado en el archivo, consulte la sección de recálculo más adelante en esta guía.

En nuestra prueba de este fragmento, el valor actualizado, la fila añadida, su formato numérico y el estilo existente del encabezado se conservaron tras guardar, y la fórmula se mantuvo exactamente como se escribió. Al volver a abrir el archivo guardado con Spire.XLS y llamar a CalculateAllValue() se obtuvo 528.75 para la celda =B6*C6 añadida, y una lectura independiente con openpyxl confirmó los mismos valores en el archivo guardado.

Automatizar informes de Excel y el procesamiento por lotes

Combinar libros regionales en un único informe maestro

Combinar los archivos regionales en un único libro maestro es donde la automatización empieza a amortizarse. Con Spire.XLS, cada archivo de origen se carga por turno, sus filas se leen a través del rango asignado y los datos llegan a un libro nuevo con una columna de origen para que cada fila siga siendo trazable:

import glob, os
from spire.xls import Workbook, FileFormat

master = Workbook()
ms = master.Worksheets[0]
ms.Range["A1"].Text = "Month"
ms.Range["B1"].Text = "Store"
ms.Range["C1"].Text = "Revenue"
ms.Range["D1"].Text = "Source File"
out_row = 2

for path in glob.glob("region_*.xlsx"):
    wb = Workbook()
    wb.LoadFromFile(path)
    ws = wb.Worksheets[0]
    for r in range(2, ws.AllocatedRange.RowCount + 1):   # skip each file's header
        for c in range(1, 4):
            src = ws.Range[r, c]
            nv = src.NumberValue
            if not (isinstance(nv, float) and nv != nv):  # NaN means "not a number"
                ms.Range[out_row, c].NumberValue = nv
            else:
                ms.Range[out_row, c].Text = src.Value
        ms.Range[out_row, 4].Text = os.path.basename(path)
        out_row += 1
    wb.Dispose()

master.SaveToFile("master_report.xlsx", FileFormat.Version2016)
master.Dispose()

En nuestra prueba con tres archivos de entrada, la salida combinada contenía exactamente la suma de las filas de entrada —nueve en total—, la columna de ingresos contenía números reales (sumaban 94,298.00, coincidiendo con las entradas hasta el céntimo), la columna de origen resolvía exactamente los tres nombres de archivo y ninguna fila de encabezado se coló en los datos. El resultado también se pudo volver a leer con openpyxl, por lo que puede alimentar directamente el siguiente paso de una canalización. Un límite que conviene señalar: este bucle copia valores de celda, no el formato de origen. Si sus columnas de origen contienen fechas reales de Excel, porcentajes o cifras de moneda, aplique los formatos numéricos correspondientes a las columnas de destino; en nuestros datos de prueba la columna Month es texto, así que la copia es exacta.

Generar informes con formato para cada cliente

La combinación le da un conjunto de datos; la generación de informes lo convierte en entregables. Leer una tabla maestra y producir un libro de factura con formato para cada cliente es un bucle: agrupar las filas y luego construir cada factura con un título combinado, una fila de encabezado con estilo, importes con formato numérico y un total con SUM:

from spire.xls import Workbook, FileFormat, Color

wb = Workbook()
wb.LoadFromFile("invoice_master.xlsx")
ws = wb.Worksheets[0]

clients = {}
for r in range(2, ws.AllocatedRange.RowCount + 1):
    client = ws.Range[r, 1].Value
    clients.setdefault(client, []).append(
        (ws.Range[r, 2].Value, ws.Range[r, 3].NumberValue))

for client, items in clients.items():
    inv = Workbook()
    sheet = inv.Worksheets[0]
    sheet.Range["A1"].Text = f"Invoice - {client}"
    sheet.Range["A1"].Style.Font.IsBold = True
    sheet.Range["A1"].Style.Font.Size = 13
    sheet.Range["A1:B1"].Merge()
    sheet.Range["A3"].Text = "Service"
    sheet.Range["B3"].Text = "Amount"
    header = sheet.Range["A3:B3"]
    header.Style.Color = Color.FromArgb(255, 68, 114, 196)
    header.Style.Font.Color = Color.FromArgb(255, 255, 255, 255)
    header.Style.Font.IsBold = True
    row = 4
    for service, amount in items:
        sheet.Range[row, 1].Text = service
        sheet.Range[row, 2].NumberValue = amount
        sheet.Range[row, 2].NumberFormat = "#,##0.00"
        row += 1
    sheet.Range[row, 1].Text = "Total"
    sheet.Range[row, 1].Style.Font.IsBold = True
    sheet.Range[row, 2].Formula = f"=SUM(B4:B{row - 1})"
    sheet.Range[row, 2].NumberFormat = "#,##0.00"
    sheet.SetColumnWidth(1, 22)
    sheet.SetColumnWidth(2, 14)
    inv.SaveToFile(f"{client.replace(' ', '_').lower()}_invoice.xlsx",
                   FileFormat.Version2016)
    inv.Dispose()

En nuestra prueba, tres clientes produjeron tres libros, el título combinado y el encabezado con estilo se conservaron, y la fórmula =SUM sobrevivió al guardado. Una nota práctica: el nombre del archivo proviene directamente del nombre del cliente; si los nombres reales pueden contener caracteres como / o :, saneélos antes de construir el nombre del archivo. Tras CalculateAllValue(), el total de la factura de Acme marcaba 8,680.50 —coincidiendo exactamente con las tres líneas de detalle— y la cadena de la fórmula seguía en la celda, de modo que Excel la sigue recalculando al abrir. En el caso de plantillas complejas con gráficos o tablas dinámicas, el ciclo de ida y vuelta es donde se pone a prueba la conservación de objetos; eso se trata en la sección avanzada que aparece más abajo.

Validar datos de Excel y resaltar excepciones

La automatización no consiste solo en producir archivos, sino también en revisarlos. Un patrón útil es un paso de escaneo que recorre un libro, aplica sus reglas de calidad de datos y marca las filas que las incumplen, de modo que una persona revise las filas señaladas en lugar de releerlo todo. Se trata de una comprobación de datos con marcadores visibles: no sustituye a la característica Validación de datos de Excel, que controla lo que un usuario puede escribir en una celda. Con Spire.XLS, el escaneo lee las celdas a través de NumberValue, que devuelve NaN tanto para texto como para celdas vacías —por lo que la primera regla de abajo informa de missing_or_non_numeric en lugar de pretender distinguir ambos casos— y marca los fallos mediante estilos de celda:

import math
from spire.xls import Workbook, FileFormat, Color

LIGHT_RED = Color.FromArgb(255, 254, 226, 226)
NOTE_RED = Color.FromArgb(255, 185, 28, 28)

wb = Workbook()
wb.LoadFromFile("payroll.xlsx")
ws = wb.Worksheets[0]

for row in range(2, ws.AllocatedRange.RowCount + 1):
    salary = ws.Range[row, 2].NumberValue
    bonus = ws.Range[row, 3].NumberValue
    reasons = []
    if math.isnan(salary) or math.isnan(bonus):
        reasons.append("missing_or_non_numeric")
    if not math.isnan(salary) and salary > 100000:
        reasons.append("outlier")
    if not math.isnan(bonus) and bonus < 0:
        reasons.append("invalid")
    if reasons:
        ws.Range[row, 1, row, 3].Style.Color = LIGHT_RED
        ws.Range[row, 4].Text = "; ".join(reasons)
        ws.Range[row, 4].Style.Font.Color = NOTE_RED

wb.SaveToFile("qa_flagged.xlsx", FileFormat.Version2016)
wb.Dispose()

En nuestros datos de prueba, esto marcó correctamente las cuatro filas problemáticas —dos con valores faltantes o no numéricos, un salario atípico por encima del umbral y una bonificación negativa—, dejó intactas las filas correctas y escribió el motivo de cada fila en la columna D, algo que verificamos tanto reabriendo el archivo como en el XML subyacente. Volver a ejecutar el escaneo sobre el libro de prueba sin cambios produjo las mismas cuatro filas marcadas. Las reglas de aquí son deliberadamente simples: para datos de nómina reales, los umbrales y el conjunto de reglas son la parte interesante, y viven en su código, donde se pueden versionar y revisar.

Este patrón se combina bien con las secciones anteriores: combine los archivos regionales, escanee los datos combinados y dirija el libro a revisión o a entrega según lo que encuentre el escaneo.

Programar la automatización de Excel con Python

Un script que hay que ejecutar a mano es solo la mitad de una automatización. La otra mitad es hacer que se ejecute cuando debe. Como los pasos anteriores son Python puro, el flujo de trabajo terminado —cargar, combinar, escanear, generar, entregar— se empaqueta en una función que un programador de tareas del sistema operativo puede ejecutar por sí solo:

Ambos inician su script, lo dejan hacer su trabajo y terminan: ningún proceso de larga duración que vigilar. Sin embargo, su comportamiento ante ejecuciones omitidas es distinto: el Programador de tareas de Windows se puede configurar para ejecutar una tarea lo antes posible después de que se haya perdido su inicio programado, mientras que los trabajos cron estándar generalmente no recuperan las ejecuciones perdidas mientras el sistema estaba apagado. Una nota de despliegue que ahorra confusión más adelante: Spire.XLS procesa los archivos de libro directamente y no necesita Excel de escritorio instalado, por lo que los scripts anteriores se ejecutan en un servidor Linux o en un contenedor, lo que sustituye el enfoque antiguo de automatizar Office de escritorio mediante COM. No obstante, no necesitar Excel no es lo mismo que reproducir todo el comportamiento de Excel; la siguiente sección trata de las partes que resultan realmente difíciles de reproducir.

Manejar tareas avanzadas de automatización de Excel

Para muchas canalizaciones, las secciones anteriores son la respuesta completa. Algunos flujos de trabajo siguen añadiendo requisitos: más formatos de entrada, fórmulas que deben recalcularse, entrega en PDF, archivos protegidos. Esta sección recorre esos puntos con código probado con Spire.XLS for Python 16.8.2 (el paquete independiente de Python en PyPI). Es una ruta de implementación para los requisitos más difíciles, no la respuesta predeterminada para todas las tareas de esta página.

Trabajar con varios formatos de archivo

Es habitual que un sistema de origen exporte .xls, .xlsb u .ods mientras que su canalización espera .xlsx. Cada formato suele implicar un paquete y un motor de Python distintos. Spire.XLS los maneja a través de la misma API de libro; y en nuestras pruebas con 16.8.2, el mismo objeto de libro cargó y guardó .xls, .ods, .xlsx y .xlsb (FileFormat.Xlsb2007 / Xlsb2010), e hizo el ciclo de ida y vuelta de .xls, .ods y .xlsb a sus propios formatos con los valores intactos. Los archivos .xlsb que escribimos también se reabrieron en Excel sin problemas, aunque el analizador de código abierto pyxlsb no pudo leerlos; conviene verificarlo con sus propios lectores posteriores antes de comprometerse.

from spire.xls import Workbook, FileFormat

wb = Workbook()
wb.LoadFromFile("legacy_input.xls")           # also reads .xlsb and .ods
wb.SaveToFile("converted.xlsx", FileFormat.Version2016)
wb.Dispose()

Una distinción que conviene mantener: «editar y guardar en el formato original» y «convertir para la entrega» son objetivos distintos. El primero mantiene un archivo de trabajo en su sitio; el segundo alimenta a un consumidor posterior. Ambos aparecen en el ejemplo de extremo a extremo que se muestra a continuación.

Recalcular fórmulas

Las bibliotecas que escriben fórmulas no necesariamente escriben resultados. openpyxl, por ejemplo, conserva la cadena de la fórmula pero no almacena ningún valor calculado, así que un lector posterior que no calcula no ve nada: un problema real cuando una canalización programada entrega archivos a sistemas que leen el archivo tal cual.

Un motor de cálculo cierra esa brecha:

from spire.xls import Workbook, FileFormat

wb = Workbook()
wb.LoadFromFile("model.xlsx")     # formulas written by another tool, no cached values
wb.CalculateAllValue()            # compute every formula
wb.SaveToFile("model_calculated.xlsx", FileFormat.Version2016)
wb.Dispose()

Verificamos ambos lados de esto. Al cargar, Spire.XLS ya calcula en memoria de forma predeterminada (RecalculateOnOpen está activado), por lo que FormulaNumberValue lee los números calculados de inmediato; pero persistir los resultados en el archivo requiere la llamada explícita a CalculateAllValue() antes de guardar. Con esa llamada, el archivo guardado contenía los valores calculados, lo que confirmó nuestro lector de openpyxl con data_only=True; sin ella, las mismas celdas se leían como None. Después de ese guardado, cualquier biblioteca puede leer los resultados. Un límite que vale la pena señalar: el cálculo abarca las funciones y dependencias que admite el motor; los libros que dependen de vínculos externos, funciones de complementos o funciones fuera del conjunto admitido deben probarse con sus propios archivos antes de confiar en la salida calculada.

Exportar informes de Excel a PDF

Los informes programados suelen terminar como PDF para personas que nunca abren el libro. Representar una hoja de cálculo con fidelidad —anchos de columna, fuentes, gráficos— es justo la parte en la que las herramientas de conversión genéricas fallan. Con Spire.XLS la hoja de cálculo se representa a sí misma, con la configuración de página definida primero:

from spire.xls import Workbook, PageOrientationType

wb = Workbook()
wb.LoadFromFile("model_calculated.xlsx")
sheet = wb.Worksheets[0]
sheet.PageSetup.Orientation = PageOrientationType.Portrait
sheet.PageSetup.FitToPagesWide = 1
sheet.PageSetup.FitToPagesTall = 1
sheet.SaveToPdf("report.pdf")       # worksheet-level export
wb.Dispose()

Los ajustes FitToPagesWide y FitToPagesTall escalan la hoja para que quepa en una página de ancho y una de alto, lo que evita que las columnas se dividan entre páginas; no obstante, en hojas muy anchas el texto reducido puede volverse demasiado pequeño para leerlo con comodidad. El método SaveToPdf a nivel de hoja entrega exactamente la hoja que elija, en lugar de todas las hojas del libro. En nuestra prueba, el PDF exportado salió como una sola página con el título, la tabla completa incluidos los totales recalculados y el gráfico representado. Para más detalles sobre el diseño, consulte convertir Excel a PDF en Python.

Trabajar con gráficos y tablas dinámicas

Los libros de informes suelen contener objetos, no solo celdas. En nuestro libro de prueba, un ciclo de ida y vuelta con Spire.XLS 16.8.2 mantuvo las partes del gráfico intactas a nivel de XML, y el gráfico se representó por completo cuando el archivo se reabrió en Excel. Presentamos eso como un resultado para nuestros datos de prueba, no como una garantía para todos los objetos DrawingML; las formas complejas deben verificarse con sus propios archivos, el mismo consejo que se aplica a cualquier biblioteca. La API de libro de Spire.XLS también abarca las tablas dinámicas y los gráficos dinámicos: creación, actualización y operaciones con campos; para la parte de tablas dinámicas, consulte crear u operar tablas dinámicas en Excel. Nuestro archivo de prueba no incluía una tabla dinámica, así que haga pasar sus propios libros por el ciclo de ida y vuelta antes de comprometerse.

Proteger libros de Excel

Los informes archivados o enviados por correo suelen necesitar una contraseña de apertura. Una sola llamada la establece:

wb.Protect("Report2026")
wb.SaveToFile("protected_report.xlsx", FileFormat.Version2016)
wb.Dispose()

En nuestra prueba, el archivo no se abría sin la contraseña, incluso en openpyxl, que lanzó un error con el contenedor cifrado. Leerlo de vuelta a través de la misma biblioteca requiere la propiedad OpenPassword. Por lo tanto, si una canalización protege archivos y luego los lee, el lado lector de la cadena de herramientas debe admitirlo.

Elegir una biblioteca para la automatización de Excel en producción

Más allá de la cobertura de la API, una dependencia de producción también necesita un plan de mantenimiento. Spire.XLS for Python sigue publicando versiones: 16.8.2 (agosto de 2026, la versión probada a lo largo de esta guía) añadió, por ejemplo, soporte para la fórmula TEXTSPLIT. La licencia es perpetua: la licencia cubre el uso continuado según sus términos, mientras que el acceso a las versiones más recientes depende del derecho de actualización; los planes de licencia incluyen un año de actualizaciones de producto y correcciones, y el soporte comercial le ofrece un canal definido con el proveedor para problemas de formato, cálculo o conversión, en lugar de un rastreador de la comunidad. Los plazos de respuesta, los canales de soporte y los extras de cada plan varían según el nivel; consulte la página de planes de licencia de Spire.XLS for Python, o la comparativa de la mejor biblioteca de Excel para Python para ver cómo el número de desarrolladores y el alcance del despliegue encajan en la elección.

Un ejemplo de extremo a extremo

Las piezas anteriores se combinan en un único flujo de trabajo de conversión y entrega: leer una entrada .xlsb heredada, actualizar una cifra, recalcular y entregar tanto un PDF como un .xlsx protegido con contraseña:

from spire.xls import Workbook, FileFormat, PageOrientationType

wb = Workbook()
wb.LoadFromFile("monthly_input.xlsb")        # read the binary format

sheet = wb.Worksheets[0]
sheet.Range["B2"].NumberValue = 125000       # update an input cell

wb.CalculateAllValue()                        # persist computed results

sheet.PageSetup.Orientation = PageOrientationType.Portrait
sheet.PageSetup.FitToPagesWide = 1
sheet.PageSetup.FitToPagesTall = 1
sheet.SaveToPdf("monthly_report.pdf")         # deliverable 1: PDF

wb.Protect("Report2026")                      # deliverable 2: protected xlsx
wb.SaveToFile("monthly_report.xlsx", FileFormat.Version2016)
wb.Dispose()                                  # release the workbook

Cada paso se verificó en nuestro entorno de pruebas con Spire.XLS for Python 16.8.2 y Python 3.13. Si este flujo de trabajo se ajusta a sus requisitos, explore Spire.XLS for Python. La edición gratuita es suficiente para una evaluación básica; para proyectos comerciales, solicite una licencia temporal de un mes y pruebe la API completa con sus propios libros antes de elegir una licencia de producción (consulte la página oficial para conocer los términos vigentes).

Preguntas frecuentes

¿Puede Python automatizar Excel sin tener Excel instalado?

Sí, para el procesamiento de archivos: Spire.XLS lee y escribe archivos de libro directamente, y ninguno de los ejemplos de aquí necesitó Excel de escritorio. La excepción es xlwings Classic, que controla la aplicación de Excel en ejecución. «Sin necesidad de Excel» se refiere a ejecutar el código, no a reproducir todos los comportamientos de Excel.

¿Qué biblioteca de Python es mejor para la automatización de Excel?

Depende de la tarea: pandas para el análisis, openpyxl para ediciones de .xlsx a nivel de celda, XlsxWriter para libros nuevos con formato y xlwings para manejar Excel en sí. Para una única API que abarque lectura, edición, cálculo, conversión y protección, consulte nuestra comparativa de la mejor biblioteca de Excel para Python.

¿Puede openpyxl recalcular fórmulas de Excel?

No: conserva las cadenas de las fórmulas pero no tiene motor de cálculo, y las fórmulas escritas por openpyxl no llevan resultados en caché; data_only=True solo lee las cachés almacenadas en el archivo, por lo que devuelve None para esas celdas. Para calcular y persistir resultados, consulte agregar o leer fórmulas en Excel.

¿Cómo programo un script de Excel en Python?

Utilice el Programador de tareas de Windows o cron para que el sistema operativo inicie el script; tenga en cuenta que el Programador de tareas se puede configurar para volver a ejecutar las tareas perdidas, mientras que cron estándar no recupera las ejecuciones perdidas mientras la máquina estaba apagada. Dado que el script procesa archivos de libro directamente, no se necesita Excel de escritorio en la máquina que lo ejecuta.

¿Cómo puedo convertir Excel a PDF con Python?

Configure la página (orientación, ajuste a la página) y exporte la hoja de cálculo directamente con una biblioteca que genere los PDF por sí misma. La vía de código abierto necesita una biblioteca de conversión aparte en la que usted se encargue del diseño. Encontrará los detalles en convertir Excel a PDF en Python.

Conclusión

La automatización de Excel con Python abarca desde la edición de una celda en cinco líneas hasta una canalización programada que combina archivos, marca datos incorrectos, recalcula fórmulas y entrega PDF y libros protegidos. pandas, openpyxl y sus vecinas siguen siendo opciones sólidas para el análisis y las ediciones de una sola tarea. Cuando el trabajo se convierte en un flujo —varios formatos de entrada, resultados calculados de salida, PDF y archivos protegidos entregados según un calendario—, lo que lo sostiene en producción es una API de libro unificada con versiones mantenidas y un canal de soporte, y eso es lo que demostraron los ejemplos de Spire.XLS for Python de esta guía.